using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using Anvil;
using BepInEx;
using BepInEx.Bootstrap;
using FistVR;
using FistVR.BTrap;
using FistVR.MG;
using H3MP.Networking;
using H3MP.Patches;
using H3MP.Scripts;
using H3MP.Tracking;
using HarmonyLib;
using HarmonyLib.Public.Patching;
using Mono.Cecil.Cil;
using Open.Nat;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Valve.Newtonsoft.Json.Linq;
using Valve.VR;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("H3MP")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("H3MP")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4e60aee7-baed-4e40-8c9c-2edc0a12f580")]
[assembly: AssemblyFileVersion("1.14.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.14.0.0")]
[module: UnverifiableCode]
namespace H3MP
{
	public class GameManager : MonoBehaviour
	{
		public delegate void OnUpdatePlayerHiddenDelegate(PlayerManager player, ref bool visible);

		public delegate void OnPlayerDamageDelegate(float damageMultiplier, Damage damage, ref bool processDamage);

		public delegate void OnSpectatorHostsChangedDelegate();

		public delegate void OnSpectatorHostToggledDelegate(bool spectatorHost);

		public delegate void OnInstanceLeftDelegate(int instance, int destination);

		public delegate void OnInstanceJoinedDelegate(int instance, int source);

		public delegate void OnPlayerInstanceChangedDelegate(int ID, int instance, int destination);

		public delegate void OnSceneLeftDelegate(string scene, string destination);

		public delegate void OnSceneJoinedDelegate(string scene, string source);

		public delegate void OnPlayerBodyInitDelegate(FVRPlayerBody playerBody);

		public delegate void OnPlayerAddedDelegate(PlayerManager player);

		private static GameManager _singleton;

		public static Dictionary<int, PlayerManager> players = new Dictionary<int, PlayerManager>();

		public static List<TrackedObjectData> objects = new List<TrackedObjectData>();

		public static Dictionary<MonoBehaviour, TrackedObject> trackedObjectByObject = new Dictionary<MonoBehaviour, TrackedObject>();

		public static Dictionary<FVRInteractiveObject, TrackedObject> trackedObjectByInteractive = new Dictionary<FVRInteractiveObject, TrackedObject>();

		public static Dictionary<IFVRDamageable, TrackedObject> trackedObjectByDamageable = new Dictionary<IFVRDamageable, TrackedObject>();

		public static Dictionary<UberShatterable, TrackedObject> trackedObjectByShatterable = new Dictionary<UberShatterable, TrackedObject>();

		public static Dictionary<FVRPhysicalObject, TrackedItem> trackedItemByItem = new Dictionary<FVRPhysicalObject, TrackedItem>();

		public static Dictionary<SosigWeapon, TrackedItem> trackedItemBySosigWeapon = new Dictionary<SosigWeapon, TrackedItem>();

		public static Dictionary<Sosig, TrackedSosig> trackedSosigBySosig = new Dictionary<Sosig, TrackedSosig>();

		public static Dictionary<AutoMeater, TrackedAutoMeater> trackedAutoMeaterByAutoMeater = new Dictionary<AutoMeater, TrackedAutoMeater>();

		public static Dictionary<TNH_EncryptionTarget, TrackedEncryption> trackedEncryptionByEncryption = new Dictionary<TNH_EncryptionTarget, TrackedEncryption>();

		public static Dictionary<BreakableGlass, TrackedBreakableGlass> trackedBreakableGlassByBreakableGlass = new Dictionary<BreakableGlass, TrackedBreakableGlass>();

		public static Dictionary<BreakableGlassDamager, TrackedBreakableGlass> trackedBreakableGlassByBreakableGlassDamager = new Dictionary<BreakableGlassDamager, TrackedBreakableGlass>();

		public static Dictionary<wwGatlingGun, TrackedGatlingGun> trackedGatlingGunByGatlingGun = new Dictionary<wwGatlingGun, TrackedGatlingGun>();

		public static Dictionary<BrutBlockSystem, TrackedBrutBlockSystem> trackedBrutBlockSystemByBrutBlockSystem = new Dictionary<BrutBlockSystem, TrackedBrutBlockSystem>();

		public static Dictionary<Construct_Blister, TrackedBlister> trackedBlisterByBlister = new Dictionary<Construct_Blister, TrackedBlister>();

		public static Dictionary<Construct_Floater, TrackedFloater> trackedFloaterByFloater = new Dictionary<Construct_Floater, TrackedFloater>();

		public static Dictionary<Construct_Iris, TrackedIris> trackedIrisByIris = new Dictionary<Construct_Iris, TrackedIris>();

		public static Dictionary<Construct_Sentinel, TrackedSentinel> trackedSentinelBySentinel = new Dictionary<Construct_Sentinel, TrackedSentinel>();

		public static Dictionary<Construct_Node, TrackedNode> trackedNodeByNode = new Dictionary<Construct_Node, TrackedNode>();

		public static Dictionary<Construct_Haze, TrackedHaze> trackedHazeByHaze = new Dictionary<Construct_Haze, TrackedHaze>();

		public static Dictionary<int, int> activeInstances = new Dictionary<int, int>();

		public static Dictionary<int, TNHInstance> TNHInstances = new Dictionary<int, TNHInstance>();

		public static List<int> playersAtLoadStart;

		public static Dictionary<string, Dictionary<int, List<int>>> playersByInstanceByScene = new Dictionary<string, Dictionary<int, List<int>>>();

		public static Dictionary<string, Dictionary<int, List<int>>> objectsByInstanceByScene = new Dictionary<string, Dictionary<int, List<int>>>();

		public static List<GameObject> retrack = new List<GameObject>();

		public static bool spectatorHost;

		public static List<int> spectatorHosts = new List<int>();

		public static int controlledSpectatorHost = -1;

		public static int spectatorHostControlledBy = -1;

		public static bool resetSpectatorHost;

		public static bool instanceBringItems;

		public static long ping = -1L;

		public static int reconnectionInstance = -1;

		public static Dictionary<string, byte> nonSynchronizedScenes = new Dictionary<string, byte>();

		public static int giveControlOfDestroyed;

		public static bool controlOverride;

		public static bool firstPlayerInSceneInstance;

		public static bool dontAddToInstance;

		public static bool inPostSceneLoadTrack;

		public static int ID = 0;

		public static Vector3 torsoOffset = new Vector3(0f, -0.4f, 0f);

		public static Vector3 overheadDisplayOffset = new Vector3(0f, 0.25f, 0f);

		public static List<int> playersPresent = new List<int>();

		public static int playerStateAddtionalDataSize = -1;

		public static int instance = 0;

		public static string scene = "MainMenu3";

		public static bool sceneLoading;

		public static int instanceAtSceneLoadStart;

		public static string sceneAtSceneLoadStart;

		public static bool connectedAtLoadStart;

		public static int colorIndex = 0;

		public static readonly string[] colorNames = new string[7] { "White", "Red", "Green", "Blue", "Black", "Desert", "Forest" };

		public static readonly Color[] colors = (Color[])(object)new Color[7]
		{
			Color.white,
			Color.red,
			Color.green,
			Color.blue,
			Color.black,
			new Color(0.98431f, 0.86275f, 0.71373f),
			new Color(0.31373f, 0.31373f, 0.15294f)
		};

		public static bool colorByIFF = false;

		public static int nameplateMode = 1;

		public static int radarMode = 0;

		public static bool radarColor = true;

		public static bool overrideMaxHealthSetting = false;

		public static float[] maxHealths = new float[9] { 1f, 500f, 1000f, 2000f, 3000f, 4000f, 5000f, 7500f, 10000f };

		public static int maxHealthIndex = -1;

		public static Dictionary<string, Dictionary<int, KeyValuePair<float, int>>> maxHealthByInstanceByScene = new Dictionary<string, Dictionary<int, KeyValuePair<float, int>>>();

		public static string playerPrefabID = "None";

		public static int playerPrefabIndex = -1;

		public static TrackedPlayerBody currentTrackedPlayerBody;

		public static bool playerModelAwaitingInstantiation = false;

		public static PlayerBody currentPlayerBody = null;

		public static bool bodyVisible = true;

		public static bool handsVisible = true;

		public static Dictionary<string, Object> playerPrefabs = new Dictionary<string, Object>();

		public static List<string> playerPrefabIDs = new List<string>();

		public static GameManager singleton
		{
			get
			{
				return _singleton;
			}
			private set
			{
				if ((Object)(object)_singleton == (Object)null)
				{
					_singleton = value;
				}
				else if ((Object)(object)_singleton != (Object)(object)value)
				{
					Mod.LogInfo("GameManager instance already exists, destroying duplicate!", debug: false);
					Object.Destroy((Object)(object)value);
				}
			}
		}

		public static event OnUpdatePlayerHiddenDelegate OnUpdatePlayerHidden;

		public static event OnPlayerDamageDelegate OnPlayerDamage;

		public static event OnSpectatorHostsChangedDelegate OnSpectatorHostsChanged;

		public static event OnSpectatorHostToggledDelegate OnSpectatorHostToggled;

		public static event OnInstanceLeftDelegate OnInstanceLeft;

		public static event OnInstanceJoinedDelegate OnInstanceJoined;

		public static event OnPlayerInstanceChangedDelegate OnPlayerInstanceChanged;

		public static event OnSceneLeftDelegate OnSceneLeft;

		public static event OnSceneJoinedDelegate OnSceneJoined;

		public static event OnPlayerBodyInitDelegate OnPlayerBodyInit;

		public static event OnPlayerAddedDelegate OnPlayerAdded;

		private void Awake()
		{
			singleton = this;
			activeInstances.Add(instance, 1);
		}

		private void Update()
		{
			if (!Input.GetKeyDown((KeyCode)287) || sceneLoading)
			{
				return;
			}
			spectatorHost = !spectatorHost;
			if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				((Behaviour)GM.CurrentPlayerBody.EyeCam).enabled = !spectatorHost;
			}
			if (ThreadManager.host)
			{
				if (spectatorHost)
				{
					spectatorHosts.Add(0);
					Server.availableSpectatorHosts.Add(0);
				}
				else
				{
					spectatorHosts.Remove(0);
					Server.availableSpectatorHosts.Remove(0);
				}
				ServerSend.SpectatorHost(0, spectatorHost);
			}
			else
			{
				spectatorHosts.Add(ID);
				ClientSend.SpectatorHost(spectatorHost);
			}
			if (spectatorHost)
			{
				Mod.LogWarning("Player is now a spectator host!");
				if (!scene.Equals("MainMenu3"))
				{
					SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
				}
			}
			else
			{
				Mod.LogWarning("Player is no longer a spectator host!");
				spectatorHostControlledBy = -1;
				Mod.spectatorHostWaitingForTNHSetup = false;
			}
			if (GameManager.OnSpectatorHostToggled != null)
			{
				GameManager.OnSpectatorHostToggled(spectatorHost);
			}
		}

		public static void OnSpectatorHostsChangedInvoke()
		{
			if (GameManager.OnSpectatorHostsChanged != null)
			{
				GameManager.OnSpectatorHostsChanged();
			}
		}

		public void SpawnPlayer(int ID, string username, string scene, int instance, int IFF, int colorIndex, bool join = false)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			if ((Object)(object)Client.singleton != (Object)null && ID == Client.singleton.ID)
			{
				return;
			}
			Mod.LogInfo($"Spawn player called with ID: {ID}", debug: false);
			GameObject val = new GameObject("PlayerRoot" + ID);
			Object.DontDestroyOnLoad((Object)(object)val);
			PlayerManager playerManager = val.AddComponent<PlayerManager>();
			playerManager.Init(ID, username, scene, instance, IFF, colorIndex);
			players.Add(ID, playerManager);
			bool flag = false;
			if (playersByInstanceByScene.TryGetValue(scene, out var value))
			{
				if (value.TryGetValue(instance, out var value2))
				{
					value2.Add(ID);
					flag = value2.Count == 1;
				}
				else
				{
					value.Add(instance, new List<int> { ID });
					flag = true;
				}
			}
			else
			{
				Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
				dictionary.Add(instance, new List<int> { ID });
				playersByInstanceByScene.Add(scene, dictionary);
				flag = true;
			}
			flag = (playerManager.firstInSceneInstance = flag & (sceneLoading || !scene.Equals(GameManager.scene) || instance != GameManager.instance));
			if (ThreadManager.host)
			{
				Server.clients[ID].player.firstInSceneInstance = flag;
			}
			if (activeInstances.ContainsKey(instance))
			{
				Dictionary<int, int> dictionary2 = activeInstances;
				int value3 = dictionary2[instance] + 1;
				dictionary2[instance] = value3;
			}
			else
			{
				activeInstances.Add(instance, 1);
			}
			UpdatePlayerHidden(playerManager);
			if (!nonSynchronizedScenes.ContainsKey(scene) && scene.Equals(GameManager.scene) && instance == GameManager.instance)
			{
				playersPresent.Add(ID);
				if (join)
				{
					firstPlayerInSceneInstance = false;
				}
			}
			if (GameManager.OnPlayerAdded != null)
			{
				GameManager.OnPlayerAdded(playerManager);
			}
		}

		public static IEnumerator InstantiatePlayerBody(FVRObject playerModelFVRObject, string playerPrefabID)
		{
			yield return ((AnvilAsset)playerModelFVRObject).GetGameObjectAsync();
			GameObject prefab = ((AnvilAsset)playerModelFVRObject).GetGameObject();
			if ((Object)(object)prefab == (Object)null)
			{
				Mod.LogWarning("Attempted to instantiate player model \"" + playerPrefabID + "\" but failed to get prefab. Using Default instead.");
				GameManager.playerPrefabID = "Default";
			}
			currentPlayerBody = Object.Instantiate<GameObject>(prefab).GetComponent<PlayerBody>();
			playerModelAwaitingInstantiation = false;
		}

		public static void Reset()
		{
			foreach (KeyValuePair<int, PlayerManager> player in players)
			{
				Object.Destroy((Object)(object)((Component)player.Value).gameObject);
			}
			players.Clear();
			objects.Clear();
			spectatorHosts.Clear();
			trackedObjectByObject.Clear();
			trackedObjectByInteractive.Clear();
			trackedObjectByDamageable.Clear();
			trackedItemByItem.Clear();
			trackedSosigBySosig.Clear();
			trackedItemBySosigWeapon.Clear();
			trackedAutoMeaterByAutoMeater.Clear();
			trackedEncryptionByEncryption.Clear();
			trackedBreakableGlassByBreakableGlass.Clear();
			trackedBreakableGlassByBreakableGlassDamager.Clear();
			trackedBlisterByBlister.Clear();
			trackedFloaterByFloater.Clear();
			trackedGatlingGunByGatlingGun.Clear();
			trackedBrutBlockSystemByBrutBlockSystem.Clear();
			trackedIrisByIris.Clear();
			trackedSentinelBySentinel.Clear();
			trackedNodeByNode.Clear();
			trackedObjectByShatterable.Clear();
			if (playersAtLoadStart != null)
			{
				playersAtLoadStart.Clear();
			}
			activeInstances.Clear();
			TNHInstances.Clear();
			playersByInstanceByScene.Clear();
			objectsByInstanceByScene.Clear();
			ID = 0;
			instance = 0;
			giveControlOfDestroyed = 0;
			controlOverride = false;
			firstPlayerInSceneInstance = false;
			dontAddToInstance = false;
			playersPresent.Clear();
			playerStateAddtionalDataSize = -1;
			sceneLoading = false;
			instanceAtSceneLoadStart = 0;
			ping = -1L;
			colorByIFF = false;
			nameplateMode = 1;
			radarMode = 0;
			radarColor = true;
			maxHealthIndex = -1;
			maxHealthByInstanceByScene.Clear();
			spectatorHost = false;
			((Behaviour)GM.CurrentPlayerBody.EyeCam).enabled = true;
			spectatorHostControlledBy = -1;
			controlledSpectatorHost = -1;
			for (int i = 0; i < TrackedObject.trackedReferenceObjects.Length; i++)
			{
				if ((Object)(object)TrackedObject.trackedReferenceObjects[i] != (Object)null)
				{
					Object.Destroy((Object)(object)TrackedObject.trackedReferenceObjects[i]);
				}
			}
			TrackedObject.trackedReferenceObjects = (GameObject[])(object)new GameObject[100];
			TrackedObject.trackedReferences = new TrackedObject[100];
			TrackedObject.availableTrackedRefIndices = new List<int>
			{
				1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
				11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
				21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
				31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
				41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
				51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
				61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
				71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
				81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
				91, 92, 93, 94, 95, 96, 97, 98, 99
			};
			TrackedObject.unknownTrackedIDs.Clear();
			TrackedObject.unknownParentWaitList.Clear();
			TrackedObject.unknownControlTrackedIDs.Clear();
			TrackedObject.unknownDestroyTrackedIDs.Clear();
			TrackedObject.unknownParentTrackedIDs.Clear();
			TrackedItem.unknownCrateHolding.Clear();
			TrackedItem.unknownSosigInventoryItems.Clear();
			TrackedItem.unknownSosigInventoryObjects.Clear();
			TrackedItem.unknownGasCuboidGout.Clear();
			TrackedItem.unknownGasCuboidDamageHandle.Clear();
			TrackedSosig.unknownBodyStates.Clear();
			TrackedSosig.unknownIFFChart.Clear();
			TrackedSosig.unknownItemInteract.Clear();
			TrackedSosig.unknownSetIFFs.Clear();
			TrackedSosig.unknownSetOriginalIFFs.Clear();
			TrackedSosig.unknownTNHKills.Clear();
			TrackedSosig.unknownCurrentOrder.Clear();
			TrackedSosig.unknownConfiguration.Clear();
			TrackedSosig.unknownWearable.Clear();
			TrackedEncryption.unknownDisableSubTarg.Clear();
			TrackedEncryption.unknownInit.Clear();
			TrackedEncryption.unknownResetGrowth.Clear();
			TrackedEncryption.unknownSpawnGrowth.Clear();
			TrackedEncryption.unknownSpawnSubTarg.Clear();
			TrackedEncryption.unknownSpawnSubTargGeo.Clear();
			TrackedEncryption.unknownUpdateDisplay.Clear();
			TrackedEncryption.unknownPreviewPos.Clear();
			TrackedEncryption.unknownShieldRot.Clear();
			TrackedFloater.unknownFloaterBeginExploding.Clear();
			TrackedFloater.unknownFloaterBeginDefusing.Clear();
			TrackedFloater.unknownFloaterExplode.Clear();
			TrackedIris.unknownIrisShatter.Clear();
			TrackedIris.unknownIrisSetState.Clear();
			TrackedNode.unknownInit.Clear();
			TrackedSentinel.unknownInit.Clear();
		}

		public static void UpdatePlayerState(int ID, Vector3 position, Quaternion rotation, Vector3 headPos, Quaternion headRot, Vector3 torsoPos, Quaternion torsoRot, Vector3 leftHandPos, Quaternion leftHandRot, Vector3 rightHandPos, Quaternion rightHandRot, float health, int maxHealth, byte[] additionalData)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!players.ContainsKey(ID))
			{
				Mod.LogWarning($"Received UDP order to update player {ID} state but player of this ID hasnt been spawned yet");
				return;
			}
			PlayerManager playerManager = players[ID];
			Transform transform = ((Component)playerManager).transform;
			transform.position = position;
			transform.rotation = rotation;
			playerManager.head.position = headPos;
			playerManager.head.rotation = headRot;
			playerManager.leftHand.position = leftHandPos;
			playerManager.leftHand.rotation = leftHandRot;
			playerManager.rightHand.position = rightHandPos;
			playerManager.rightHand.rotation = rightHandRot;
			float health2 = playerManager.health;
			playerManager.health = health;
			int maxHealth2 = playerManager.maxHealth;
			playerManager.maxHealth = maxHealth;
			if ((Object)(object)playerManager.playerBody != (Object)null && (health != health2 || maxHealth != maxHealth2))
			{
				playerManager.playerBody.UpdateHealthLabel();
			}
			if ((health <= 0f && playerManager.visible) || (health > 0f && !playerManager.visible))
			{
				UpdatePlayerHidden(playerManager);
			}
		}

		public static void UpdatePlayerScene(int playerID, string sceneName)
		{
			Mod.LogInfo("Player " + playerID + " joining scene " + sceneName, debug: false);
			PlayerManager value = null;
			if (!players.TryGetValue(playerID, out value))
			{
				return;
			}
			playersByInstanceByScene[value.scene][value.instance].Remove(value.ID);
			if (playersByInstanceByScene[value.scene][value.instance].Count == 0)
			{
				playersByInstanceByScene[value.scene].Remove(value.instance);
			}
			if (playersByInstanceByScene[value.scene].Count == 0)
			{
				playersByInstanceByScene.Remove(value.scene);
			}
			if (value.scene.Equals(scene) && !nonSynchronizedScenes.ContainsKey(value.scene) && instance == value.instance)
			{
				playersPresent.Remove(playerID);
			}
			value.scene = sceneName;
			bool flag = false;
			if (playersByInstanceByScene.TryGetValue(value.scene, out var value2))
			{
				if (value2.TryGetValue(value.instance, out var value3))
				{
					value3.Add(value.ID);
					flag = value3.Count == 1;
				}
				else
				{
					value2.Add(value.instance, new List<int> { value.ID });
					flag = true;
				}
			}
			else
			{
				Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
				dictionary.Add(value.instance, new List<int> { value.ID });
				playersByInstanceByScene.Add(value.scene, dictionary);
				flag = true;
			}
			flag = (value.firstInSceneInstance = flag & (sceneLoading || !value.scene.Equals(scene) || value.instance != instance));
			if (ThreadManager.host)
			{
				Server.clients[playerID].player.scene = sceneName;
				Server.clients[playerID].player.firstInSceneInstance = flag;
			}
			UpdatePlayerHidden(value);
			if (sceneName.Equals(scene) && !nonSynchronizedScenes.ContainsKey(sceneName) && instance == value.instance)
			{
				playersPresent.Add(playerID);
			}
		}

		public static bool UpdatePlayerHidden(PlayerManager player)
		{
			bool flag = true;
			flag &= !nonSynchronizedScenes.ContainsKey(player.scene) && player.scene.Equals(scene) && player.instance == instance && !spectatorHosts.Contains(player.ID) && player.health > 0f;
			if (flag && Mod.currentTNHInstance != null)
			{
				flag &= !Mod.currentTNHInstance.dead.Contains(player.ID);
				if (!flag && (Object)(object)player.reticleContact != (Object)null)
				{
					if ((Object)(object)Mod.currentTNHInstance.manager != (Object)null && (Object)(object)Mod.currentTNHInstance.manager.TAHReticle != (Object)null)
					{
						for (int i = 0; i < Mod.currentTNHInstance.manager.TAHReticle.Contacts.Count; i++)
						{
							if ((Object)(object)Mod.currentTNHInstance.manager.TAHReticle.Contacts[i] == (Object)(object)player.reticleContact)
							{
								GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[i].TrackedTransform);
								Object.Destroy((Object)(object)((Component)Mod.currentTNHInstance.manager.TAHReticle.Contacts[i]).gameObject);
								Mod.currentTNHInstance.manager.TAHReticle.Contacts.RemoveAt(i);
								player.reticleContact = null;
								break;
							}
						}
					}
				}
				else if (flag && (Object)(object)player.reticleContact == (Object)null && (Object)(object)Mod.currentTNHInstance.manager != (Object)null && Mod.currentTNHInstance.currentlyPlaying.Contains(player.ID))
				{
					switch (radarMode)
					{
					case 0:
						player.reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(player.head, (ContactType)((!radarColor) ? (player.colorIndex - 4) : ((player.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
						break;
					case 1:
						if (player.IFF == GM.CurrentPlayerBody.GetPlayerIFF())
						{
							player.reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(player.head, (ContactType)((!radarColor) ? (player.colorIndex - 4) : ((player.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
						}
						break;
					}
				}
			}
			if (GameManager.OnUpdatePlayerHidden != null)
			{
				GameManager.OnUpdatePlayerHidden(player, ref flag);
			}
			player.SetVisible(flag);
			return flag;
		}

		public static void UpdatePlayerInstance(int playerID, int instance)
		{
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			Mod.LogInfo("Player " + playerID + " joining instance " + instance, debug: false);
			PlayerManager playerManager = players[playerID];
			if (activeInstances.ContainsKey(playerManager.instance))
			{
				Dictionary<int, int> dictionary = activeInstances;
				int key = playerManager.instance;
				int value = dictionary[key] - 1;
				dictionary[key] = value;
				if (activeInstances[playerManager.instance] == 0)
				{
					activeInstances.Remove(playerManager.instance);
				}
			}
			if (TNHInstances.TryGetValue(playerManager.instance, out var value2))
			{
				int num = value2.playerIDs[0];
				value2.playerIDs.Remove(playerID);
				if (value2.playerIDs.Count == 0)
				{
					TNHInstances.Remove(playerManager.instance);
					if ((Object)(object)Mod.TNHInstanceList != (Object)null && Mod.joinTNHInstances != null && Mod.joinTNHInstances.ContainsKey(instance))
					{
						Object.Destroy((Object)(object)Mod.joinTNHInstances[instance]);
						Mod.joinTNHInstances.Remove(instance);
					}
					if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == playerManager.instance)
					{
						Mod.TNHSpectating = false;
						if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
						{
							GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
							if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
							{
								((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
								((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
							}
						}
					}
				}
				else
				{
					if ((Object)(object)Mod.TNHMenu != (Object)null && (Object)(object)Mod.TNHPlayerList != (Object)null && (Object)(object)Mod.TNHPlayerPrefab != (Object)null && Mod.currentTNHInstancePlayers != null && Mod.currentTNHInstancePlayers.ContainsKey(playerID))
					{
						Object.Destroy((Object)(object)Mod.currentTNHInstancePlayers[playerID]);
						Mod.currentTNHInstancePlayers.Remove(playerID);
						if (num != value2.playerIDs[0])
						{
							Text component = ((Component)Mod.currentTNHInstancePlayers[value2.playerIDs[0]].transform.GetChild(0)).GetComponent<Text>();
							component.text += " (Host)";
						}
					}
					value2.currentlyPlaying.Remove(playerID);
					value2.played.Remove(playerID);
					value2.dead.Remove(playerID);
				}
			}
			if (GameManager.OnPlayerInstanceChanged != null)
			{
				GameManager.OnPlayerInstanceChanged(playerManager.ID, playerManager.instance, instance);
			}
			playersByInstanceByScene[playerManager.scene][playerManager.instance].Remove(playerManager.ID);
			if (playersByInstanceByScene[playerManager.scene][playerManager.instance].Count == 0)
			{
				playersByInstanceByScene[playerManager.scene].Remove(playerManager.instance);
			}
			if (playerManager.scene.Equals(scene) && !nonSynchronizedScenes.ContainsKey(playerManager.scene) && GameManager.instance == playerManager.instance)
			{
				playersPresent.Remove(playerID);
			}
			playerManager.instance = instance;
			bool flag = false;
			if (playersByInstanceByScene[playerManager.scene].TryGetValue(instance, out var value3))
			{
				value3.Add(playerManager.ID);
				flag = value3.Count == 1;
			}
			else
			{
				playersByInstanceByScene[playerManager.scene].Add(instance, new List<int> { playerManager.ID });
				flag = true;
			}
			flag = (playerManager.firstInSceneInstance = flag & (sceneLoading || !playerManager.scene.Equals(scene) || playerManager.instance != GameManager.instance));
			if (ThreadManager.host)
			{
				Server.clients[playerID].player.instance = instance;
				Server.clients[playerID].player.firstInSceneInstance = flag;
			}
			UpdatePlayerHidden(playerManager);
			if (playerManager.scene.Equals(scene) && !nonSynchronizedScenes.ContainsKey(playerManager.scene) && GameManager.instance == playerManager.instance)
			{
				playersPresent.Add(playerID);
			}
			if (activeInstances.ContainsKey(instance))
			{
				Dictionary<int, int> dictionary2 = activeInstances;
				int value = instance;
				int key = dictionary2[value] + 1;
				dictionary2[value] = key;
			}
			else
			{
				activeInstances.Add(instance, 1);
			}
			if (TNHInstances.ContainsKey(instance) && !TNHInstances[instance].playerIDs.Contains(playerID))
			{
				TNHInstances[instance].playerIDs.Add(playerID);
				if ((Object)(object)Mod.TNHMenu != (Object)null && (Object)(object)Mod.TNHPlayerList != (Object)null && (Object)(object)Mod.TNHPlayerPrefab != (Object)null && Mod.currentTNHInstancePlayers != null && !Mod.currentTNHInstancePlayers.ContainsKey(playerID))
				{
					GameObject val = Object.Instantiate<GameObject>(Mod.TNHPlayerPrefab, Mod.TNHPlayerList.transform);
					((Component)val.transform.GetChild(0)).GetComponent<Text>().text = playerManager.username;
					val.SetActive(true);
					Mod.currentTNHInstancePlayers.Add(playerID, val);
				}
			}
		}

		public static void SetPlayerColor(int ID, int index, bool received = false, int clientID = 0, bool send = true)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				colorIndex = index;
				if ((Object)(object)BodyWristMenuSection.colorText != (Object)null)
				{
					BodyWristMenuSection.colorText.text = "Current color: " + colorNames[colorIndex];
				}
				return;
			}
			if (GameManager.ID == ID)
			{
				colorIndex = index;
				if ((Object)(object)currentPlayerBody != (Object)null)
				{
					currentPlayerBody.SetColor(colors[colorIndex]);
				}
				if ((Object)(object)BodyWristMenuSection.colorText != (Object)null)
				{
					BodyWristMenuSection.colorText.text = "Current color: " + colorNames[colorIndex];
				}
			}
			else
			{
				players[ID].SetColor(index);
				if (ThreadManager.host)
				{
					Server.clients[ID].player.colorIndex = index;
				}
			}
			if (send)
			{
				if (ThreadManager.host)
				{
					ServerSend.PlayerColor(ID, index, clientID);
				}
				else if (!received)
				{
					ClientSend.PlayerColor(ID, index);
				}
			}
		}

		public static void SetPlayerPrefab(string prefabID)
		{
			string text = playerPrefabID;
			if (playerPrefabs.ContainsKey(prefabID))
			{
				playerPrefabID = prefabID;
			}
			else if ((Object)(object)Mod.managerObject == (Object)null)
			{
				playerPrefabID = "None";
			}
			else
			{
				playerPrefabID = "Default";
			}
			if (text.Equals(playerPrefabID) && (Object)(object)currentPlayerBody != (Object)null)
			{
				return;
			}
			if ((Object)(object)currentPlayerBody != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)currentPlayerBody).gameObject);
			}
			if (playerPrefabID.Equals("None"))
			{
				return;
			}
			if (playerPrefabID.Equals("Default"))
			{
				Object obj = playerPrefabs["Default"];
				currentPlayerBody = Object.Instantiate<GameObject>((GameObject)(object)((obj is GameObject) ? obj : null)).GetComponent<PlayerBody>();
			}
			else
			{
				bool flag = false;
				if (playerPrefabs.TryGetValue(playerPrefabID, out var value))
				{
					if (value == (Object)null)
					{
						if (IM.OD.TryGetValue(playerPrefabID, out var value2) && (Object)(object)value2 != (Object)null)
						{
							flag = true;
							playerModelAwaitingInstantiation = true;
							AnvilManager.Run(InstantiatePlayerBody(value2, playerPrefabID));
						}
					}
					else if (value is FVRObject)
					{
						flag = true;
						playerModelAwaitingInstantiation = true;
						AnvilManager.Run(InstantiatePlayerBody((FVRObject)(object)((value is FVRObject) ? value : null), playerPrefabID));
					}
				}
				if (!flag)
				{
					Mod.LogWarning("Attempt to set player prefab to \"" + playerPrefabID + "\" failed, could not obtain prefab, using default");
					playerPrefabID = "Default";
					Object obj2 = playerPrefabs[playerPrefabID];
					currentPlayerBody = Object.Instantiate<GameObject>((GameObject)(object)((obj2 is GameObject) ? obj2 : null)).GetComponent<PlayerBody>();
				}
			}
			if ((Object)(object)BodyWristMenuSection.playerBodyText != (Object)null)
			{
				BodyWristMenuSection.playerBodyText.text = "Body: " + playerPrefabID;
			}
		}

		public static void AddPlayerPrefabID(string newPlayerPrefabID)
		{
			if (newPlayerPrefabID.Equals("Default"))
			{
				Mod.LogError("A mod attempted to register \"Default\" player prefab ID:\n" + Environment.StackTrace);
				return;
			}
			playerPrefabs.Add(newPlayerPrefabID, null);
			playerPrefabIDs.Add(newPlayerPrefabID);
		}

		public static void SyncTrackedObjects(bool init = false, bool inControl = false)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!ThreadManager.host && !Client.singleton.gotConnectSync)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			GameObject[] array = rootGameObjects;
			foreach (GameObject val in array)
			{
				SyncTrackedObjects(val.transform, init ? inControl : controlOverride, null);
			}
			_ = Mod.DDOLScene;
			if (true)
			{
				rootGameObjects = ((Scene)(ref Mod.DDOLScene)).GetRootGameObjects();
				GameObject[] array2 = rootGameObjects;
				foreach (GameObject val2 in array2)
				{
					SyncTrackedObjects(val2.transform, init ? inControl : controlOverride, null);
				}
			}
		}

		public static void SyncTrackedObjects(Transform root, bool controlEverything, TrackedObjectData parent)
		{
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			if (!ThreadManager.host && !Client.singleton.gotConnectSync)
			{
				return;
			}
			if (GetTrackedObjectType(root, out var trackedObjectType))
			{
				TrackedObject component = ((Component)root).GetComponent<TrackedObject>();
				if ((Object)(object)component == (Object)null)
				{
					if (controlEverything || IsControlled(root, trackedObjectType))
					{
						TrackedObject trackedObject = MakeObjectTracked(root, parent, trackedObjectType);
						if (!((Object)(object)trackedObject != (Object)null))
						{
							return;
						}
						if (trackedObject.awoken)
						{
							if (ThreadManager.host)
							{
								Mod.LogInfo("Server made new object tracked with type ID: " + trackedObject.data.typeIdentifier, debug: false);
								Server.AddTrackedObject(trackedObject.data, 0);
							}
							else
							{
								trackedObject.data.localWaitingIndex = Client.localObjectCounter++;
								Mod.LogInfo("Client made new object tracked with local waiting index: " + trackedObject.data.localWaitingIndex + " and type ID: " + trackedObject.data.typeIdentifier, debug: false);
								Client.waitingLocalObjects.Add(trackedObject.data.localWaitingIndex, trackedObject.data);
								ClientSend.TrackedObject(trackedObject.data);
							}
							trackedObject.data.OnTracked();
						}
						else
						{
							trackedObject.sendOnAwake = true;
						}
						{
							foreach (Transform item in root)
							{
								Transform root2 = item;
								SyncTrackedObjects(root2, controlEverything, trackedObject.data);
							}
							return;
						}
					}
					if (TrackSkipped(root, trackedObjectType))
					{
						Object.Destroy((Object)(object)((Component)root).gameObject);
					}
				}
				else
				{
					parent?.children.Add(component.data);
				}
				return;
			}
			foreach (Transform item2 in root)
			{
				Transform root3 = item2;
				SyncTrackedObjects(root3, controlEverything, parent);
			}
		}

		private static TrackedObject MakeObjectTracked(Transform root, TrackedObjectData parent, Type trackedObjectType)
		{
			Mod.LogInfo("Making tracked object from " + ((Object)root).name, debug: false);
			return (TrackedObject)trackedObjectType.GetMethod("MakeTracked", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Invoke(null, new object[2] { root, parent });
		}

		public static TNHInstance AddNewTNHInstance(int hostID, bool letPeopleJoin, int progressionTypeSetting, int healthModeSetting, int equipmentModeSetting, int targetModeSetting, int AIDifficultyModifier, int radarModeModifier, int itemSpawnerMode, int backpackMode, int healthMult, int sosiggunShakeReloading, int TNHSeed, string levelID)
		{
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			if (ThreadManager.host)
			{
				int freeInstance = 1;
				while (activeInstances.ContainsKey(freeInstance))
				{
					int num = freeInstance + 1;
					freeInstance = num;
				}
				TNHInstance tNHInstance = new TNHInstance(freeInstance, hostID, letPeopleJoin, progressionTypeSetting, healthModeSetting, equipmentModeSetting, targetModeSetting, AIDifficultyModifier, radarModeModifier, itemSpawnerMode, backpackMode, healthMult, sosiggunShakeReloading, TNHSeed, levelID);
				TNHInstances.Add(freeInstance, tNHInstance);
				if ((tNHInstance.letPeopleJoin || tNHInstance.currentlyPlaying.Count == 0) && (Object)(object)Mod.TNHInstanceList != (Object)null && Mod.joinTNHInstances != null && !Mod.joinTNHInstances.ContainsKey(freeInstance))
				{
					GameObject val = Object.Instantiate<GameObject>(Mod.TNHInstancePrefab, Mod.TNHInstanceList.transform);
					((Component)val.transform.GetChild(0)).GetComponent<Text>().text = "Instance " + freeInstance;
					val.SetActive(true);
					FVRPointableButton val2 = val.AddComponent<FVRPointableButton>();
					val2.SetButton();
					((FVRPointable)val2).MaxPointingRange = 5f;
					((UnityEvent)val2.Button.onClick).AddListener((UnityAction)delegate
					{
						Mod.OnTNHInstanceClicked(freeInstance);
					});
					Mod.joinTNHInstances.Add(freeInstance, val);
				}
				activeInstances.Add(freeInstance, 0);
				Mod.modInstance.OnTNHInstanceReceived(tNHInstance);
				return tNHInstance;
			}
			ClientSend.AddTNHInstance(hostID, letPeopleJoin, progressionTypeSetting, healthModeSetting, equipmentModeSetting, targetModeSetting, AIDifficultyModifier, radarModeModifier, itemSpawnerMode, backpackMode, healthMult, sosiggunShakeReloading, TNHSeed, levelID);
			return null;
		}

		public static int AddNewInstance()
		{
			if (ThreadManager.host)
			{
				int i;
				for (i = 1; activeInstances.ContainsKey(i); i++)
				{
				}
				activeInstances.Add(i, 0);
				Mod.modInstance.OnInstanceReceived(i);
				ServerSend.AddInstance(i);
				return i;
			}
			ClientSend.AddInstance();
			return -1;
		}

		public static void AddTNHInstance(TNHInstance instance)
		{
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			if (!activeInstances.ContainsKey(instance.instance))
			{
				activeInstances.Add(instance.instance, instance.playerIDs.Count);
			}
			TNHInstances.Add(instance.instance, instance);
			if ((instance.letPeopleJoin || instance.currentlyPlaying.Count == 0) && (Object)(object)Mod.TNHInstanceList != (Object)null && Mod.joinTNHInstances != null && !Mod.joinTNHInstances.ContainsKey(instance.instance))
			{
				GameObject val = Object.Instantiate<GameObject>(Mod.TNHInstancePrefab, Mod.TNHInstanceList.transform);
				((Component)val.transform.GetChild(0)).GetComponent<Text>().text = "Instance " + instance.instance;
				val.SetActive(true);
				FVRPointableButton val2 = val.AddComponent<FVRPointableButton>();
				val2.SetButton();
				((FVRPointable)val2).MaxPointingRange = 5f;
				((UnityEvent)val2.Button.onClick).AddListener((UnityAction)delegate
				{
					Mod.OnTNHInstanceClicked(instance.instance);
				});
				Mod.joinTNHInstances.Add(instance.instance, val);
			}
			dontAddToInstance = Mod.setLatestInstance;
			Mod.modInstance.OnTNHInstanceReceived(instance);
		}

		public static void AddInstance(int instance)
		{
			if (!activeInstances.ContainsKey(instance))
			{
				activeInstances.Add(instance, 0);
			}
			Mod.modInstance.OnInstanceReceived(instance);
		}

		public static void SetInstance(int instance)
		{
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			Mod.LogInfo("Changing instance from " + GameManager.instance + " to " + instance + ":\n" + Environment.StackTrace, debug: false);
			if (activeInstances.ContainsKey(GameManager.instance))
			{
				Dictionary<int, int> dictionary = activeInstances;
				int key = GameManager.instance;
				int value = dictionary[key] - 1;
				dictionary[key] = value;
				if (activeInstances[GameManager.instance] == 0)
				{
					activeInstances.Remove(GameManager.instance);
				}
			}
			else
			{
				Mod.LogError("Instance we are leaving is missing from active instances!");
			}
			if (GameManager.OnInstanceLeft != null)
			{
				GameManager.OnInstanceLeft(GameManager.instance, instance);
			}
			if (TNHInstances.TryGetValue(GameManager.instance, out var value2))
			{
				value2.playerIDs.Remove(ID);
				if (value2.playerIDs.Count == 0)
				{
					TNHInstances.Remove(GameManager.instance);
					if ((Object)(object)Mod.TNHInstanceList != (Object)null && Mod.joinTNHInstances.ContainsKey(instance))
					{
						Object.Destroy((Object)(object)Mod.joinTNHInstances[instance]);
						Mod.joinTNHInstances.Remove(instance);
					}
					Mod.TNHSpectating = false;
					if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
					{
						GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
						if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
						{
							((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
							((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
						}
					}
				}
				value2.currentlyPlaying.Remove(ID);
				value2.dead.Remove(ID);
				if (controlledSpectatorHost != -1 && value2.currentlyPlaying.Count > 1 && value2.currentlyPlaying.Contains(controlledSpectatorHost))
				{
					if (ThreadManager.host)
					{
						ReassignSpectatorHost(0, new List<int> { 0 });
					}
					else
					{
						ClientSend.ReassignSpectatorHost(new List<int> { ID });
					}
					Mod.OnSpectatorHostGiveUpInvoke();
				}
			}
			if (!sceneLoading)
			{
				if (playersByInstanceByScene.TryGetValue(scene, out var value3))
				{
					if (value3.TryGetValue(GameManager.instance, out var value4))
					{
						playersAtLoadStart = value4;
					}
					else
					{
						playersAtLoadStart = null;
					}
				}
				else
				{
					playersAtLoadStart = null;
				}
			}
			int source = GameManager.instance;
			GameManager.instance = instance;
			if (!activeInstances.ContainsKey(instance))
			{
				activeInstances.Add(instance, 0);
			}
			if (dontAddToInstance)
			{
				dontAddToInstance = false;
			}
			else
			{
				Dictionary<int, int> dictionary2 = activeInstances;
				int value = instance;
				int key = dictionary2[value] + 1;
				dictionary2[value] = key;
			}
			instanceBringItems = !playersByInstanceByScene.TryGetValue(sceneLoading ? LoadLevelBeginPatch.loadingLevel : scene, out var value5) || !value5.TryGetValue(instance, out var value6) || value6.Count == 0;
			if (GameManager.OnInstanceJoined != null)
			{
				GameManager.OnInstanceJoined(instance, source);
			}
			if (TNHInstances.ContainsKey(instance))
			{
				if (!TNHInstances[instance].playerIDs.Contains(ID))
				{
					TNHInstances[instance].playerIDs.Add(ID);
				}
				if ((Object)(object)Mod.currentTNHUIManager != (Object)null)
				{
					Mod.InitTNHUIManager(TNHInstances[instance]);
				}
				else
				{
					Mod.currentTNHUIManager = Object.FindObjectOfType<TNH_UIManager>();
					Mod.currentTNHSceneLoader = Object.FindObjectOfType<TNH_LevelLoader>();
					if ((Object)(object)Mod.currentTNHUIManager != (Object)null)
					{
						Mod.InitTNHUIManager(TNHInstances[instance]);
					}
				}
			}
			if (sceneLoading)
			{
				controlOverride = instanceBringItems;
				firstPlayerInSceneInstance = instanceBringItems;
			}
			if (ThreadManager.host)
			{
				ServerSend.PlayerInstance(0, instance);
			}
			else
			{
				ClientSend.PlayerInstance(instance, sceneLoading);
			}
			playersPresent.Clear();
			if (!nonSynchronizedScenes.ContainsKey(scene))
			{
				foreach (KeyValuePair<int, PlayerManager> player in players)
				{
					if (player.Value.scene.Equals(scene) && player.Value.instance == instance)
					{
						playersPresent.Add(player.Key);
						if (ThreadManager.host && !sceneLoading)
						{
							if (Server.clientsWaitingUpDate.TryGetValue(player.Key, out var value7))
							{
								value7.Add(0);
							}
							else
							{
								Server.clientsWaitingUpDate.Add(player.Key, new List<int> { 0 });
							}
							if (Server.loadingClientsWaitingFrom.TryGetValue(0, out var value8))
							{
								value8.Add(player.Key);
							}
							else
							{
								Server.loadingClientsWaitingFrom.Add(0, new List<int> { player.Key });
							}
							ServerSend.RequestUpToDateObjects(player.Key, instantiateOnReceive: true, 0);
						}
					}
					UpdatePlayerHidden(player.Value);
				}
			}
			else
			{
				foreach (KeyValuePair<int, PlayerManager> player2 in players)
				{
					UpdatePlayerHidden(player2.Value);
				}
			}
			H3MPWristMenuSection.UpdateMaxHealth(scene, instance, -2, -1f);
		}

		public static void DestroyTrackedScripts(TrackedObjectData trackedObjectData)
		{
			if (trackedObjectData.children != null)
			{
				for (int i = 0; i < trackedObjectData.children.Count; i++)
				{
					DestroyTrackedScripts(trackedObjectData.children[i]);
				}
			}
			if ((Object)(object)trackedObjectData.physical != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)trackedObjectData.physical);
			}
		}

		public static void ReassignSpectatorHost(int clientID, List<int> debounce)
		{
			if (!Server.spectatorHostByController.TryGetValue(clientID, out var value))
			{
				return;
			}
			List<int> list = new List<int>();
			if (scene.Equals(Server.clients[clientID].player.scene) && instance == Server.clients[clientID].player.instance)
			{
				list.Add(0);
			}
			if (playersByInstanceByScene.TryGetValue(Server.clients[clientID].player.scene, out var value2) && value2.TryGetValue(Server.clients[clientID].player.instance, out var value3))
			{
				list.AddRange(value3);
			}
			list.RemoveRange(0, debounce.Count);
			int num = -1;
			if (list.Count > 0)
			{
				num = Mod.GetBestPotentialObjectHost(clientID, forUs: false);
			}
			if (num == -1)
			{
				Server.spectatorHostByController.Remove(clientID);
				Server.spectatorHostControllers.Remove(value);
				if (spectatorHosts.Contains(value))
				{
					Server.availableSpectatorHosts.Add(value);
				}
				if (value == ID)
				{
					spectatorHostControlledBy = -1;
					if (!sceneLoading)
					{
						if (!scene.Equals("MainMenu3"))
						{
							SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
						}
					}
					else
					{
						resetSpectatorHost = true;
					}
				}
				else
				{
					ServerSend.UnassignSpectatorHost(value);
				}
			}
			else
			{
				Server.spectatorHostByController.Remove(clientID);
				Server.spectatorHostControllers.Remove(value);
				Server.spectatorHostByController.Add(num, value);
				Server.spectatorHostControllers.Add(value, num);
				if (value == 0)
				{
					spectatorHostControlledBy = num;
				}
				else if (num == 0)
				{
					Mod.OnSpectatorHostReceivedInvoke(value, reassignment: true);
				}
				ServerSend.SpectatorHostAssignment(value, num, reassignment: true);
			}
		}

		public static bool GetTrackedObjectType(Transform t, out Type trackedObjectType)
		{
			List<Type> list = new List<Type>();
			foreach (KeyValuePair<Type, List<Type>> trackedObjectType2 in Mod.trackedObjectTypes)
			{
				for (int num = trackedObjectType2.Value.Count - 1; num >= 0; num--)
				{
					MethodInfo method = trackedObjectType2.Value[num].GetMethod("IsOfType", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if ((bool)method.Invoke(null, new object[1] { t }))
					{
						list.Add(trackedObjectType2.Value[num]);
						break;
					}
				}
			}
			if (list.Count == 0)
			{
				trackedObjectType = null;
				return false;
			}
			if (list.Count == 1)
			{
				trackedObjectType = list[0];
				return true;
			}
			Type type = list[0];
			for (int i = 0; i < list.Count; i++)
			{
				MethodInfo method2 = list[i].GetMethod("GetTypeOverrides", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if ((object)method2 != null && method2.Invoke(null, null) is Type[] array)
				{
					int num2 = 0;
					while (num2 < array.Length)
					{
						list.Remove(array[i]);
						i++;
					}
				}
			}
			if (list.Count == 0)
			{
				Mod.LogWarning(((Object)t).name + " had conflicting possible tracked types overriding each other. Tracked as: " + type.Name);
				trackedObjectType = type;
			}
			else if (list.Count == 1)
			{
				trackedObjectType = list[0];
			}
			else
			{
				Mod.LogWarning(((Object)t).name + " had conflicting possible tracked types missing override. Tracked as: " + list[0].Name);
				trackedObjectType = list[0];
			}
			return true;
		}

		public static bool IsControlled(Transform root, Type trackedObjectType)
		{
			MethodInfo method = trackedObjectType.GetMethod("IsControlled", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if ((object)method != null && (object)method.ReturnType == typeof(bool) && (object)method.GetParameters()[0].ParameterType == typeof(Transform))
			{
				return (bool)method.Invoke(null, new object[1] { root });
			}
			return false;
		}

		public static bool TrackSkipped(Transform root, Type trackedObjectType)
		{
			MethodInfo method = trackedObjectType.GetMethod("TrackSkipped", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if ((object)method != null && (object)method.ReturnType == typeof(bool) && (object)method.GetParameters()[0].ParameterType == typeof(Transform))
			{
				return (bool)method.Invoke(null, new object[1] { root });
			}
			return true;
		}

		public static void OnSceneLoadedVR(bool loading)
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			if (loading)
			{
				Mod.LogInfo("Switching scene, from " + scene + " to " + LoadLevelBeginPatch.loadingLevel, debug: false);
				sceneLoading = true;
				instanceAtSceneLoadStart = instance;
				sceneAtSceneLoadStart = scene;
				if ((Object)(object)Mod.managerObject == (Object)null)
				{
					connectedAtLoadStart = false;
					return;
				}
				connectedAtLoadStart = true;
				giveControlOfDestroyed++;
				Mod.skipAllInstantiates++;
				if (playersByInstanceByScene.TryGetValue(scene, out var value))
				{
					if (value.TryGetValue(instance, out var value2))
					{
						playersAtLoadStart = value2;
					}
					else
					{
						playersAtLoadStart = null;
					}
				}
				else
				{
					playersAtLoadStart = null;
				}
				if (LoadLevelBeginPatch.loadingLevel.Equals("MainMenu3") && Mod.currentTNHInstance != null)
				{
					SetInstance(0);
					if (Mod.currentlyPlayingTNH)
					{
						Mod.currentTNHInstance.RemoveCurrentlyPlaying(send: true, ID, ThreadManager.host);
						Mod.currentlyPlayingTNH = false;
					}
					Mod.currentTNHInstance = null;
					Mod.TNHSpectating = false;
					if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
					{
						GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
						if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
						{
							((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
							((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
						}
					}
					Mod.currentlyPlayingTNH = false;
				}
				if (LoadLevelBeginPatch.loadingLevel.Equals("TakeAndHold_Lobby_2") && Mod.currentTNHInstance != null)
				{
					Mod.TNHSpectating = false;
					if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
					{
						GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
						if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
						{
							((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
							((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
						}
					}
				}
				if (playersByInstanceByScene.TryGetValue(LoadLevelBeginPatch.loadingLevel, out var value3))
				{
					if (value3.TryGetValue(instance, out var value4))
					{
						controlOverride = value4.Count == 0;
						firstPlayerInSceneInstance = controlOverride;
					}
					else
					{
						controlOverride = true;
						firstPlayerInSceneInstance = true;
					}
				}
				else
				{
					controlOverride = true;
					firstPlayerInSceneInstance = true;
				}
				ClearUnawoken();
				if (GameManager.OnSceneLeft != null)
				{
					GameManager.OnSceneLeft(sceneAtSceneLoadStart, LoadLevelBeginPatch.loadingLevel);
				}
				return;
			}
			scene = LoadLevelBeginPatch.loadingLevel;
			sceneLoading = false;
			Mod.LogInfo("Arrived in scene: " + scene, debug: false);
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.PlayerScene(0, LoadLevelBeginPatch.loadingLevel);
				}
				else
				{
					ClientSend.PlayerScene(LoadLevelBeginPatch.loadingLevel);
				}
				if (connectedAtLoadStart)
				{
					Mod.skipAllInstantiates--;
					giveControlOfDestroyed--;
				}
				playersPresent.Clear();
				if (!nonSynchronizedScenes.ContainsKey(scene))
				{
					controlOverride = true;
					firstPlayerInSceneInstance = true;
					foreach (KeyValuePair<int, PlayerManager> player in players)
					{
						if (player.Value.scene.Equals(scene) && player.Value.instance == instance)
						{
							playersPresent.Add(player.Key);
							controlOverride = false;
							firstPlayerInSceneInstance = false;
							if (ThreadManager.host)
							{
								if (Server.clientsWaitingUpDate.TryGetValue(player.Key, out var value5))
								{
									value5.Add(0);
								}
								else
								{
									Server.clientsWaitingUpDate.Add(player.Key, new List<int> { 0 });
								}
								if (Server.loadingClientsWaitingFrom.TryGetValue(0, out var value6))
								{
									value6.Add(player.Key);
								}
								else
								{
									Server.loadingClientsWaitingFrom.Add(0, new List<int> { player.Key });
								}
								ServerSend.RequestUpToDateObjects(player.Key, instantiateOnReceive: true, 0);
							}
						}
						UpdatePlayerHidden(player.Value);
					}
					controlOverride &= connectedAtLoadStart;
					firstPlayerInSceneInstance &= connectedAtLoadStart;
					inPostSceneLoadTrack = true;
					SyncTrackedObjects();
					inPostSceneLoadTrack = false;
					controlOverride = false;
					for (int i = 0; i < objects.Count; i++)
					{
						if ((Object)(object)objects[i].physical == (Object)null && !objects[i].awaitingInstantiation)
						{
							objects[i].awaitingInstantiation = true;
							AnvilManager.Run(objects[i].Instantiate());
						}
					}
					if (Mod.spectatorHostWaitingForTNHSetup)
					{
						if (scene.Equals("TakeAndHold_Lobby_2"))
						{
							if (spectatorHostControlledBy != -1)
							{
								Mod.OnTNHHostClicked();
								Mod.TNHOnDeathSpectate = Mod.TNHRequestHostOnDeathSpectate;
								Mod.OnTNHHostConfirmClicked();
								if (ThreadManager.host)
								{
									ServerSend.TNHSpectatorHostReady(spectatorHostControlledBy, instance);
								}
								else
								{
									Mod.spectatorHostWaitingForTNHInstance = true;
								}
							}
							Mod.spectatorHostWaitingForTNHSetup = false;
						}
						else if (scene.Equals("MainMenu3"))
						{
							SteamVR_LoadLevel.Begin("TakeAndHold_Lobby_2", false, 0.5f, 0f, 0f, 0f, 1f);
							Mod.spectatorHostWaitingForTNHSetup = true;
						}
						else
						{
							SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
							Mod.spectatorHostWaitingForTNHSetup = true;
						}
					}
				}
				else
				{
					foreach (KeyValuePair<int, PlayerManager> player2 in players)
					{
						UpdatePlayerHidden(player2.Value);
					}
				}
				H3MPWristMenuSection.UpdateMaxHealth(scene, instance, -2, -1f);
				if (resetSpectatorHost)
				{
					if (!scene.Equals("MainMenu3"))
					{
						SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
					}
					resetSpectatorHost = false;
				}
				if (GameManager.OnSceneJoined != null)
				{
					GameManager.OnSceneJoined(scene, sceneAtSceneLoadStart);
				}
				TrackedGatlingGunData.firstInScene = true;
				for (int j = 0; j < retrack.Count; j++)
				{
					if ((Object)(object)retrack[j] != (Object)null)
					{
						SyncTrackedObjects(retrack[j].transform, controlEverything: true, null);
					}
				}
				retrack.Clear();
			}
			Mod.LogInfo("Setting player prefab to " + playerPrefabID);
			SetPlayerPrefab(playerPrefabID);
		}

		public static void ClearUnawoken()
		{
			for (int num = objects.Count - 1; num >= 0; num--)
			{
				if (((Object)(object)objects[num].physical != (Object)null && !objects[num].physical.awoken) || ((Object)(object)objects[num].physical == (Object)null && !objects[num].awaitingInstantiation))
				{
					objects[num].RemoveFromLocal();
				}
			}
		}

		public static void ProcessPlayerDamage(float damageMult, bool head, Damage damage)
		{
			bool processDamage = true;
			if (GameManager.OnPlayerDamage != null)
			{
				GameManager.OnPlayerDamage(damageMult, damage, ref processDamage);
			}
			if (processDamage)
			{
				damage.Dam_TotalEnergetic *= damageMult;
				damage.Dam_TotalKinetic *= damageMult;
				if (head)
				{
					GM.CurrentPlayerBody.Hitboxes[0].Damage(damage);
				}
				else
				{
					GM.CurrentPlayerBody.Hitboxes[2].Damage(damage);
				}
			}
		}

		public static void DistributeAllControl(int clientID, int overrideController = -1, List<Type> types = null)
		{
			int num = ((overrideController == -1) ? Mod.GetBestPotentialObjectHost(clientID, forUs: false) : overrideController);
			for (int i = 0; i < Server.objects.Length; i++)
			{
				if (Server.objects[i] == null || (types != null && !types.Contains(Server.objects[i].GetType())) || Server.objects[i].controller != clientID)
				{
					continue;
				}
				TrackedObjectData trackedObjectData = Server.objects[i];
				bool flag = num == -1;
				if (flag)
				{
					if ((Object)(object)trackedObjectData.physical == (Object)null)
					{
						ServerSend.DestroyObject(trackedObjectData.trackedID);
						Server.objects[trackedObjectData.trackedID] = null;
						if (Server.connectedClients.Count > 0)
						{
							if (Server.availableIndexBufferWaitingFor.TryGetValue(trackedObjectData.trackedID, out var value))
							{
								for (int j = 0; j < Server.connectedClients.Count; j++)
								{
									if (!value.Contains(Server.connectedClients[j]))
									{
										value.Add(Server.connectedClients[j]);
									}
								}
							}
							else
							{
								Server.availableIndexBufferWaitingFor.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
							}
							for (int k = 0; k < Server.connectedClients.Count; k++)
							{
								if (Server.availableIndexBufferClients.TryGetValue(Server.connectedClients[k], out var value2))
								{
									value2.Add(trackedObjectData.trackedID);
									continue;
								}
								Server.availableIndexBufferClients.Add(Server.connectedClients[k], new List<int> { trackedObjectData.trackedID });
							}
							if (Server.IDsToConfirm.TryGetValue(trackedObjectData.trackedID, out var value3))
							{
								for (int l = 0; l < Server.connectedClients.Count; l++)
								{
									if (!value3.Contains(Server.connectedClients[l]))
									{
										value3.Add(Server.connectedClients[l]);
									}
								}
							}
							else
							{
								Server.IDsToConfirm.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
							}
							Mod.LogInfo("Added " + trackedObjectData.trackedID + " to ID buffer");
						}
						else
						{
							Server.availableObjectIndices.Add(trackedObjectData.trackedID);
						}
						if (objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value4) && value4.TryGetValue(trackedObjectData.instance, out var value5))
						{
							value5.Remove(trackedObjectData.trackedID);
						}
						trackedObjectData.awaitingInstantiation = false;
						if (clientID == ID)
						{
							trackedObjectData.RemoveFromLocal();
						}
					}
					else
					{
						Object.Destroy((Object)(object)((Component)trackedObjectData.physical).gameObject);
					}
				}
				else if (clientID != 0 && num == 0)
				{
					trackedObjectData.localTrackedID = objects.Count;
					objects.Add(trackedObjectData);
					if ((Object)(object)trackedObjectData.physical == (Object)null && !sceneLoading)
					{
						if (trackedObjectData.scene.Equals(scene) && trackedObjectData.instance == instance)
						{
							if (!trackedObjectData.awaitingInstantiation)
							{
								trackedObjectData.awaitingInstantiation = true;
								AnvilManager.Run(trackedObjectData.Instantiate());
							}
						}
						else
						{
							if ((Object)(object)trackedObjectData.physical != (Object)null)
							{
								Object.Destroy((Object)(object)((Component)trackedObjectData.physical).gameObject);
							}
							else
							{
								ServerSend.DestroyObject(trackedObjectData.trackedID);
								trackedObjectData.RemoveFromLocal();
								Server.objects[trackedObjectData.trackedID] = null;
								if (Server.connectedClients.Count > 0)
								{
									if (Server.availableIndexBufferWaitingFor.TryGetValue(trackedObjectData.trackedID, out var value6))
									{
										for (int m = 0; m < Server.connectedClients.Count; m++)
										{
											if (!value6.Contains(Server.connectedClients[m]))
											{
												value6.Add(Server.connectedClients[m]);
											}
										}
									}
									else
									{
										Server.availableIndexBufferWaitingFor.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
									}
									for (int n = 0; n < Server.connectedClients.Count; n++)
									{
										if (Server.availableIndexBufferClients.TryGetValue(Server.connectedClients[n], out var value7))
										{
											value7.Add(trackedObjectData.trackedID);
											continue;
										}
										Server.availableIndexBufferClients.Add(Server.connectedClients[n], new List<int> { trackedObjectData.trackedID });
									}
									if (Server.IDsToConfirm.TryGetValue(trackedObjectData.trackedID, out var value8))
									{
										for (int num2 = 0; num2 < Server.connectedClients.Count; num2++)
										{
											if (!value8.Contains(Server.connectedClients[num2]))
											{
												value8.Add(Server.connectedClients[num2]);
											}
										}
									}
									else
									{
										Server.IDsToConfirm.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
									}
									Mod.LogInfo("Added " + trackedObjectData.trackedID + " to ID buffer");
								}
								else
								{
									Server.availableObjectIndices.Add(trackedObjectData.trackedID);
								}
								if (objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value9) && value9.TryGetValue(trackedObjectData.instance, out var value10))
								{
									value10.Remove(trackedObjectData.trackedID);
								}
								trackedObjectData.awaitingInstantiation = false;
							}
							flag = true;
						}
					}
				}
				if (!flag)
				{
					trackedObjectData.SetController(num);
					ServerSend.GiveObjectControl(trackedObjectData.trackedID, num, null);
				}
			}
		}

		public static void TakeAllPhysicalControl(bool destroyTrackedScript)
		{
			TrackedObjectData[] array = null;
			array = ((!ThreadManager.host) ? Client.objects : Server.objects);
			TrackedObjectData[] array2 = array;
			foreach (TrackedObjectData trackedObjectData in array2)
			{
				if (trackedObjectData != null && (Object)(object)trackedObjectData.physical != (Object)null)
				{
					trackedObjectData.controller = ID;
					if (destroyTrackedScript)
					{
						trackedObjectData.physical.skipFullDestroy = true;
						Object.Destroy((Object)(object)trackedObjectData.physical);
					}
				}
			}
		}

		public static void RaisePlayerBodyInit(FVRPlayerBody playerBody)
		{
			if (GameManager.OnPlayerBodyInit != null)
			{
				GameManager.OnPlayerBodyInit(playerBody);
			}
		}

		public static bool InSceneInit()
		{
			return SpawnVaultFileRoutinePatch.inInitSpawnVaultFileRoutine || AnvilPrefabSpawnPatch.inInitPrefabSpawn || inPostSceneLoadTrack || BrutPlacerPatch.inInitBrutPlacer;
		}
	}
	[BepInPlugin("VIP.TommySoucy.H3MP", "H3MP", "1.14.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Mod : BaseUnityPlugin
	{
		public delegate void CustomPacketHandler(int clientID, Packet packet);

		public delegate void CustomPacketHandlerReceivedDelegate(string ID, int index);

		public delegate void GenericCustomPacketReceivedDelegate(int clientID, string ID, Packet packet);

		public delegate void OnGetBestPotentialObjectHostDelegate(int currentController, bool forUs, bool hasWhiteList, List<int> whiteList, string sceneOverride, int instanceOverride, ref int bestPotentialObjectHost);

		public delegate void OnRemovePlayerFromSpecificListsDelegate(PlayerManager player);

		public delegate void OnSpectatorHostReceivedDelegate(int host, ref bool confirmed);

		public delegate void OnSpectatorHostGiveUpDelegate();

		public delegate void OnInstantiationTrackDelegate(GameObject gameObject);

		public delegate void OnConnectionDelegate();

		public delegate void OnPlayerRemovedDelegate(PlayerManager player);

		public const string pluginGuid = "VIP.TommySoucy.H3MP";

		public const string pluginName = "H3MP";

		public const string pluginVersion = "1.14.0";

		public static JObject config;

		public static GameObject TNHMenuPrefab;

		public static GameObject TNHStartEquipButtonPrefab;

		public static GameObject playerPrefab;

		public static GameObject keyboardPrefab;

		public static GameObject serverListPrefab;

		public static Material reticleFriendlyContactArrowMat;

		public static Material reticleFriendlyContactIconMat;

		public static Dictionary<string, string> sosigWearableMap;

		public static string H3MPPath;

		public static GameObject glassPrefab;

		public static GameObject glassPFXPrefab;

		public static MatDef glassMatDef;

		public static AudioEvent glassShotEvent;

		public static AudioEvent glassThudHeadEvent;

		public static AudioEvent glassThudTailEvent;

		public static AudioEvent glassTotalMediumEvent;

		public static AudioEvent glassGroundShatterEvent;

		public static Dictionary<FVRSoundEnvironment, AudioEvent> distantShotSets;

		public static SosigSpeechSet defaultSosigSpeechSet;

		public static AudioEvent sosigAlertAlarm;

		public static Text mainStatusText;

		public static Text statusLocationText;

		public static Text statusPlayerCountText;

		public GameObject hostButton;

		public GameObject connectButton;

		public GameObject joinButton;

		public static GameObject TNHMenu;

		public static GameObject[] TNHMenuPages;

		public static Text TNHStatusText;

		public static GameObject TNHInstanceList;

		public static GameObject TNHInstancePrefab;

		public static GameObject TNHInstanceListScrollUpArrow;

		public static GameObject TNHInstanceListScrollDownArrow;

		public static Scrollbar TNHInstanceListScrollBar;

		public static GameObject TNHHostButton;

		public static GameObject TNHJoinButton;

		public static GameObject TNHLPJCheck;

		public static GameObject TNHHostOnDeathSpectateRadio;

		public static GameObject TNHHostOnDeathLeaveRadio;

		public static GameObject TNHHostConfirmButton;

		public static GameObject TNHHostCancelButton;

		public static GameObject TNHJoinCancelButton;

		public static GameObject TNHJoinInstanceCancelButton;

		public static GameObject TNHJoinOptionsCancelButton;

		public static GameObject TNHJoinOnDeathSpectateRadio;

		public static GameObject TNHJoinOnDeathLeaveRadio;

		public static GameObject TNHJoinConfirmButton;

		public static GameObject TNHPlayerList;

		public static GameObject TNHPlayerPrefab;

		public static GameObject TNHPlayerListScrollUpArrow;

		public static GameObject TNHPlayerListScrollDownArrow;

		public static Scrollbar TNHPlayerListScrollBar;

		public static GameObject TNHLPJCheckMark;

		public static GameObject TNHHostOnDeathSpectateCheckMark;

		public static GameObject TNHHostOnDeathLeaveCheckMark;

		public static GameObject TNHJoinOnDeathSpectateCheckMark;

		public static GameObject TNHJoinOnDeathLeaveCheckMark;

		public static GameObject TNHRequestHostButton;

		public static GameObject TNHRequestHostConfirmButton;

		public static GameObject TNHRequestHostCancelButton;

		public static GameObject TNHRequestHostWaitingCancelButton;

		public static GameObject TNHRequestHostOnDeathSpectateRadio;

		public static GameObject TNHRequestHostOnDeathLeaveRadio;

		public static GameObject TNHRequestHostOnDeathSpectateCheckMark;

		public static GameObject TNHRequestHostOnDeathLeaveCheckMark;

		public static Text TNHInstanceTitle;

		public static Mod modInstance;

		public static GameObject managerObject;

		public static int skipNextFires = 0;

		public static int skipAllInstantiates = 0;

		public static AudioEvent sosigFootstepAudioEvent;

		public static bool TNHMenuLPJ;

		public static bool TNHOnDeathSpectate;

		public static bool TNHRequestHostOnDeathSpectate;

		public static bool TNHSpectating;

		public static bool setLatestInstance;

		public static TNHInstance currentTNHInstance;

		public static bool currentlyPlayingTNH;

		public static Dictionary<int, GameObject> joinTNHInstances;

		public static Dictionary<int, GameObject> currentTNHInstancePlayers;

		public static TNH_UIManager currentTNHUIManager;

		public static TNH_LevelLoader currentTNHSceneLoader;

		public static bool waitingForTNHHost;

		public static int TNHHostedInstance;

		public static GameObject TNHStartEquipButton;

		public static Dictionary<Type, List<Type>> trackedObjectTypes;

		public static Dictionary<string, Type> trackedObjectTypesByName;

		public static CustomPacketHandler[] customPacketHandlers = new CustomPacketHandler[10];

		public static List<int> availableCustomPacketIndices = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

		public static Dictionary<string, int> registeredCustomPacketIDs = new Dictionary<string, int>();

		public static bool spectatorHostWaitingForTNHInstance;

		public static bool spectatorHostWaitingForTNHSetup;

		public static bool waitingForTNHGameStart;

		public static Scene DDOLScene;

		public static bool waitingForDebugCode;

		public static string debugCode;

		public static Vector3 TNHSpawnPoint;

		public static bool nullDriverControls;

		public static Vector3 nullDriverMovement = Vector3.zero;

		public static float defaultNullDriverMovementMultiplier = 0.2f;

		public static float defaultNullDriverRotationMultiplier = 0.4f;

		public static float nullDriverVerticalRot = 0f;

		public static float nullDriverHorzontalRot = 0f;

		public static int testCustomPacketID;

		public static event CustomPacketHandlerReceivedDelegate CustomPacketHandlerReceived;

		public static event GenericCustomPacketReceivedDelegate GenericCustomPacketReceived;

		public static event OnGetBestPotentialObjectHostDelegate OnGetBestPotentialObjectHost;

		public static event OnRemovePlayerFromSpecificListsDelegate OnRemovePlayerFromSpecificLists;

		public static event OnSpectatorHostReceivedDelegate OnSpectatorHostReceived;

		public static event OnSpectatorHostGiveUpDelegate OnSpectatorHostGiveUp;

		public static event OnInstantiationTrackDelegate OnInstantiationTrack;

		public static event OnConnectionDelegate OnConnection;

		public static event OnPlayerRemovedDelegate OnPlayerRemoved;

		private void Start()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"H3MP Started");
			modInstance = this;
			Init();
		}

		public static void Reset()
		{
			//IL_00a5: 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)
			LogInfo("Mod reset called", debug: false);
			skipNextFires = 0;
			skipAllInstantiates = 0;
			TNHMenuLPJ = true;
			TNHOnDeathSpectate = true;
			TNHSpectating = false;
			if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				SetPlayerIFFPatch.skip++;
				GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
				SetPlayerIFFPatch.skip--;
				if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
				{
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
				}
			}
			setLatestInstance = false;
			currentTNHInstance = null;
			currentlyPlayingTNH = false;
			customPacketHandlers = new CustomPacketHandler[10];
			registeredCustomPacketIDs.Clear();
			availableCustomPacketIndices = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
			spectatorHostWaitingForTNHSetup = false;
			Object.DestroyImmediate((Object)(object)managerObject);
			managerObject = null;
		}

		private void Update()
		{
			//IL_116c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1171: Unknown result type (might be due to invalid IL or missing references)
			//IL_1184: Unknown result type (might be due to invalid IL or missing references)
			//IL_1193: Unknown result type (might be due to invalid IL or missing references)
			//IL_119d: Unknown result type (might be due to invalid IL or missing references)
			//IL_11a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_11a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_11bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_11ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_11d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_11d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_11de: Unknown result type (might be due to invalid IL or missing references)
			//IL_11f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1201: Unknown result type (might be due to invalid IL or missing references)
			//IL_120b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1210: Unknown result type (might be due to invalid IL or missing references)
			//IL_1215: Unknown result type (might be due to invalid IL or missing references)
			//IL_1229: Unknown result type (might be due to invalid IL or missing references)
			//IL_1238: Unknown result type (might be due to invalid IL or missing references)
			//IL_1242: Unknown result type (might be due to invalid IL or missing references)
			//IL_1247: Unknown result type (might be due to invalid IL or missing references)
			//IL_124c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0906: Unknown result type (might be due to invalid IL or missing references)
			//IL_0910: Unknown result type (might be due to invalid IL or missing references)
			//IL_0915: Unknown result type (might be due to invalid IL or missing references)
			//IL_091a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0947: Unknown result type (might be due to invalid IL or missing references)
			//IL_0956: Unknown result type (might be due to invalid IL or missing references)
			//IL_095b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0960: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e91: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e98: Expected O, but got Unknown
			//IL_0ece: Unknown result type (might be due to invalid IL or missing references)
			//IL_0edc: Expected O, but got Unknown
			//IL_0ef5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f57: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f69: Expected O, but got Unknown
			//IL_0f69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f70: Expected O, but got Unknown
			//IL_1040: Unknown result type (might be due to invalid IL or missing references)
			//IL_1047: Expected O, but got Unknown
			//IL_1047: Unknown result type (might be due to invalid IL or missing references)
			//IL_104e: Expected O, but got Unknown
			//IL_1260: Unknown result type (might be due to invalid IL or missing references)
			//IL_126f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1279: Unknown result type (might be due to invalid IL or missing references)
			//IL_127e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cda: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cdf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d04: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d0b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d22: Unknown result type (might be due to invalid IL or missing references)
			//IL_12ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_12d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_12dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_129a: Unknown result type (might be due to invalid IL or missing references)
			//IL_12a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_12b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_12b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_12bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_12fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_1304: Unknown result type (might be due to invalid IL or missing references)
			//IL_1309: Unknown result type (might be due to invalid IL or missing references)
			//IL_1419: Unknown result type (might be due to invalid IL or missing references)
			//IL_142f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1434: Unknown result type (might be due to invalid IL or missing references)
			//IL_1439: Unknown result type (might be due to invalid IL or missing references)
			//IL_159e: Unknown result type (might be due to invalid IL or missing references)
			//IL_15a3: Unknown result type (might be due to invalid IL or missing references)
			if (waitingForDebugCode)
			{
				if (Input.GetKeyDown((KeyCode)256))
				{
					debugCode += "0";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)257))
				{
					debugCode += "1";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)258))
				{
					debugCode += "2";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)259))
				{
					debugCode += "3";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)260))
				{
					debugCode += "4";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)261))
				{
					debugCode += "5";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)262))
				{
					debugCode += "6";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)263))
				{
					debugCode += "7";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)264))
				{
					debugCode += "8";
					LogInfo("DebugCode: " + debugCode);
				}
				else if (Input.GetKeyDown((KeyCode)265))
				{
					debugCode += "9";
					LogInfo("DebugCode: " + debugCode);
				}
			}
			if (Input.GetKeyDown((KeyCode)292))
			{
				waitingForDebugCode = !waitingForDebugCode;
				if (waitingForDebugCode)
				{
					debugCode = string.Empty;
				}
				else
				{
					LogInfo("Activating DebugCode: " + debugCode);
					if (debugCode != string.Empty && int.TryParse(debugCode, out var result))
					{
						switch (result)
						{
						case 0:
							LogInfo("\tDebug: Start hosting");
							OnHostClicked();
							break;
						case 1:
							LogInfo("\tDebug: Connect");
							OnConnectClicked(null);
							break;
						case 2:
							LogInfo("\tDebug: Load config");
							LoadConfig();
							break;
						case 3:
							LogInfo("\tDebug: Disconnect/Close server");
							if ((Object)(object)managerObject != (Object)null)
							{
								if (ThreadManager.host)
								{
									Server.Close();
								}
								else
								{
									Client.singleton.Disconnect(sendToServer: true, 0);
								}
							}
							break;
						case 4:
							LogInfo("\tDebug: Load to main menu");
							SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
							break;
						case 5:
							LogInfo("\tDebug: Load to proving grounds");
							SteamVR_LoadLevel.Begin("ProvingGround", false, 0.5f, 0f, 0f, 0f, 1f);
							break;
						case 6:
						{
							LogInfo("\tDebug: Build sosig wearable map");
							Dictionary<string, string> dictionary = new Dictionary<string, string>();
							foreach (KeyValuePair<string, FVRObject> item in IM.OD)
							{
								LogInfo("Checking " + item.Key);
								GameObject val9 = null;
								try
								{
									val9 = ((AnvilAsset)item.Value).GetGameObject();
								}
								catch (Exception)
								{
									LogError("There was an error trying to retrieve prefab with ID: " + item.Key);
									continue;
								}
								try
								{
									SosigWearable component = val9.GetComponent<SosigWearable>();
									if ((Object)(object)component != (Object)null)
									{
										if (dictionary.ContainsKey(((Object)val9).name))
										{
											LogWarning("Sosig wearable with name: " + ((Object)val9).name + " is already in the map with value: " + dictionary[((Object)val9).name] + " and wewanted to add value: " + item.Key);
										}
										else
										{
											dictionary.Add(((Object)val9).name, item.Key);
											LogWarning("\tAdded");
										}
									}
								}
								catch (Exception ex2)
								{
									LogError("There was an error trying to check if prefab with ID: " + item.Key + " is wearable or adding it to the list: " + ex2.Message + "\n" + ex2.StackTrace);
								}
							}
							LogInfo("\tGot wearables, writing...");
							JObject val10 = JObject.FromObject((object)dictionary);
							File.WriteAllText(H3MPPath + "/SosigWearableMap.json", ((object)val10).ToString());
							LogInfo("\tNew wearables map written");
							break;
						}
						case 7:
							LogInfo("\tDebug: Load to TNH lobby");
							SteamVR_LoadLevel.Begin("TakeAndHold_Lobby_2", false, 0.5f, 0f, 0f, 0f, 1f);
							break;
						case 8:
							LogInfo("\tDebug: Join first TNH instance");
							if (currentTNHInstance == null)
							{
								OnTNHJoinClicked();
								OnTNHJoinConfirmClicked();
								OnTNHInstanceClicked(1);
							}
							break;
						case 9:
							LogInfo("\tDebug: Create new TNH instance");
							if (currentTNHInstance == null)
							{
								OnTNHHostClicked();
								OnTNHHostConfirmClicked();
							}
							break;
						case 10:
							LogInfo("\tDebug: Begin TNH hold");
							GM.TNH_Manager.m_curHoldPoint.m_systemNode.m_hasActivated = true;
							GM.TNH_Manager.m_curHoldPoint.m_systemNode.m_hasInitiatedHold = true;
							GM.TNH_Manager.m_curHoldPoint.BeginHoldChallenge();
							break;
						case 11:
							LogInfo("\tDebug: Trigger first scene loader we can find in the scene");
							Object.FindObjectOfType<SceneLoader>().LoadMG();
							break;
						case 12:
						{
							LogInfo("\tDebug: Write PatchHashes");
							string destFileName = H3MPPath + "/PatchHashes" + DateTimeOffset.Now.ToString().Replace("/", ".").Replace(":", ".") + ".json";
							File.Copy(H3MPPath + "/PatchHashes.json", destFileName);
							LogWarning("Writing new hashes to file!");
							File.WriteAllText(H3MPPath + "/PatchHashes.json", ((object)JObject.FromObject((object)PatchController.hashes)).ToString());
							break;
						}
						case 13:
							LogInfo("\tDebug: Load to friendly 45");
							SteamVR_LoadLevel.Begin("Friendly45_New", false, 0.5f, 0f, 0f, 0f, 1f);
							break;
						case 14:
						{
							LogInfo("\tDebug: Send packet with size > MTU");
							using (Packet packet = new Packet(ThreadManager.host ? 170 : 164))
							{
								byte[] value = new byte[2048];
								packet.Write(value);
								if (ThreadManager.host)
								{
									ServerSend.SendTCPDataToAll(packet);
								}
								else
								{
									ClientSend.SendTCPData(packet);
								}
							}
							break;
						}
						case 15:
						{
							LogInfo("\tDebug: Spawning items");
							GameObject gameObject = ((AnvilAsset)IM.OD["ModulAR300LowerFDEdupe"]).GetGameObject();
							Object.Instantiate<GameObject>(gameObject, GM.CurrentPlayerBody.Head.position + GM.CurrentPlayerBody.Head.forward * 0.5f, Quaternion.identity);
							GameObject gameObject2 = ((AnvilAsset)IM.OD["AR15UpperM4FDE"]).GetGameObject();
							Object.Instantiate<GameObject>(gameObject2, GM.CurrentPlayerBody.Head.position + GM.CurrentPlayerBody.Head.forward, Quaternion.identity);
							break;
						}
						case 16:
							LogInfo("\tDebug: Dumping item IDs");
							foreach (KeyValuePair<string, FVRObject> item2 in IM.OD)
							{
								LogInfo(item2.Key);
							}
							break;
						case 17:
							nullDriverControls = !nullDriverControls;
							LogInfo("\tDebug: Null driver controls: " + nullDriverControls);
							if (nullDriverControls)
							{
								nullDriverVerticalRot = 0f;
								nullDriverHorzontalRot = 0f;
							}
							break;
						case 18:
							LogInfo("\tDebug: Sub domain h3mp.tommysoucy.vip resolved to: " + Dns.GetHostAddresses("h3mp.tommysoucy.vip")[0].ToString());
							break;
						case 19:
							LogInfo("\tDebug: Load to grillhouse");
							SteamVR_LoadLevel.Begin("Grillhouse_2Story", false, 0.5f, 0f, 0f, 0f, 1f);
							break;
						case 20:
							LogInfo("\tDebug: Spawn SMG AutoMeater");
							SpawnItem("Turburgert_SMG");
							break;
						case 21:
							LogInfo("\tDebug: Spawn Flak AutoMeater");
							SpawnItem("Turburgert_Flak");
							break;
						case 22:
							LogInfo("\tDebug: Spawn Flamethrower AutoMeater");
							SpawnItem("Turburgert_Flamethrower");
							break;
						case 23:
							LogInfo("\tDebug: Spawn MachineGun AutoMeater");
							SpawnItem("Turburgert_MachineGun");
							break;
						case 24:
							LogInfo("\tDebug: Spawn Suppression AutoMeater");
							SpawnItem("Turburgert_Suppression");
							break;
						case 25:
							LogInfo("\tDebug: Spawn blue MF AutoMeater");
							SpawnItem("TurburgertMFBlue");
							break;
						case 26:
							LogInfo("\tDebug: Spawn red MF AutoMeater");
							SpawnItem("TurburgertMFRed");
							break;
						case 27:
							LogInfo("\tDebug: Load to SamplerPlatter");
							SteamVR_LoadLevel.Begin("SamplerPlatter", false, 0.5f, 0f, 0f, 0f, 1f);
							break;
						case 28:
						{
							LogInfo("\tDebug: Register test custom packet");
							int value3;
							if (ThreadManager.host)
							{
								if (registeredCustomPacketIDs.TryGetValue("TestCustomPacketID", out var value2))
								{
									testCustomPacketID = value2;
								}
								else
								{
									testCustomPacketID = Server.RegisterCustomPacketType("TestCustomPacketID");
								}
								customPacketHandlers[testCustomPacketID] = TestCustomPacketIDServerHandler;
							}
							else if (registeredCustomPacketIDs.TryGetValue("TestCustomPacketID", out value3))
							{
								testCustomPacketID = value3;
								customPacketHandlers[testCustomPacketID] = TestCustomPacketIDClientHandler;
							}
							else
							{
								ClientSend.RegisterCustomPacketType("TestCustomPacketID");
								CustomPacketHandlerReceived += TestCustomPacketIDReceived;
							}
							break;
						}
						case 29:
							LogInfo("\tDebug: Send test custom packet");
							if (ThreadManager.host)
							{
								using Packet packet2 = new Packet(testCustomPacketID);
								ServerSend.SendTCPDataToAll(packet2, custom: true);
							}
							else
							{
								using Packet packet3 = new Packet(testCustomPacketID);
								ClientSend.SendTCPData(packet3, custom: true);
							}
							break;
						case 30:
							LogInfo("\tDebug: Toggle server list");
							if ((Object)(object)ServerListController.instance == (Object)null)
							{
								Object.Instantiate<GameObject>(serverListPrefab);
								Vector3 val8 = Vector3.ProjectOnPlane(GM.CurrentPlayerBody.Head.forward, Vector3.up);
								((Component)ServerListController.instance).transform.position = GM.CurrentPlayerBody.Head.position + 2f * val8;
								((Component)ServerListController.instance).transform.rotation = Quaternion.LookRotation(val8);
							}
							else
							{
								Object.Destroy((Object)(object)((Component)ServerListController.instance).gameObject);
							}
							break;
						case 31:
							LogInfo("\tDebug: Server list, host");
							if ((Object)(object)ServerListController.instance != (Object)null)
							{
								ServerListController.instance.OnHostClicked();
								ServerListController.instance.hostServerName.text = "Debug server";
								ServerListController.instance.hostLimit.text = "5";
								ServerListController.instance.hostUsername.text = "Debug host";
								ServerListController.instance.hostPort.text = "7863";
								ServerListController.instance.OnHostConfirmClicked();
							}
							break;
						case 32:
							LogInfo("\tDebug: Server list, join first host");
							if ((Object)(object)ServerListController.instance != (Object)null)
							{
								((UnityEvent)((Component)ServerListController.instance.main.transform.GetChild(2).GetChild(1).GetChild(1)).GetComponent<Button>().onClick).Invoke();
								ServerListController.instance.joinUsername.text = "Debug client";
								ServerListController.instance.OnJoinConfirmClicked();
							}
							break;
						case 33:
							LogInfo("\tDebug: Load to Institution Preview");
							SteamVR_LoadLevel.Begin("Institution_Preview", false, 0.5f, 0f, 0f, 0f, 1f);
							break;
						case 34:
						{
							LogInfo("\tDebug: Patch ViveHand.PollInput");
							Harmony val7 = new Harmony("VIP.TommySoucy.H3MPDebug");
							MethodInfo method = typeof(FVRViveHand).GetMethod("PollInput", BindingFlags.Instance | BindingFlags.Public);
							MethodInfo method2 = typeof(Mod).GetMethod("PollInputPrefix", BindingFlags.Static | BindingFlags.Public);
							val7.Patch((MethodBase)method, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							break;
						}
						case 35:
							LogInfo("\tDebug: Toggle vulnerability");
							SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
							H3MPWristMenuSection.invulnerable = !H3MPWristMenuSection.invulnerable;
							if ((Object)(object)H3MPWristMenuSection.invulnerableText != (Object)null)
							{
								H3MPWristMenuSection.invulnerableText.text = "Debug: Invulnerable: " + H3MPWristMenuSection.invulnerable;
							}
							break;
						case 36:
						{
							LogInfo("\tDebug: Discover NAT devices");
							SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
							NatDiscoverer val4 = new NatDiscoverer();
							CancellationTokenSource val5 = new CancellationTokenSource();
							CancellationTokenSourceExtension.CancelAfter(val5, 10000);
							Task<IEnumerable<NatDevice>> val6 = val4.DiscoverDevicesAsync((PortMapper)2, val5);
							((Task)val6).Wait();
							List<NatDevice> list2 = new List<NatDevice>(val6.Result);
							LogInfo("Got " + list2.Count + " devices:");
							for (int j = 0; j < list2.Count; j++)
							{
								Task<IPAddress> externalIPAsync = list2[j].GetExternalIPAsync();
								((Task)externalIPAsync).Wait();
								IPAddress result3 = externalIPAsync.Result;
								LogInfo("NAT Device " + j + ": " + result3);
							}
							break;
						}
						case 37:
						{
							LogInfo("\tDebug: Clear UPnP mappings");
							NatDiscoverer val = new NatDiscoverer();
							CancellationTokenSource val2 = new CancellationTokenSource();
							CancellationTokenSourceExtension.CancelAfter(val2, 10000);
							Task<NatDevice> val3 = val.DiscoverDeviceAsync((PortMapper)2, val2);
							((Task)val3).Wait();
							NatDevice result2 = val3.Result;
							Task<IEnumerable<Mapping>> allMappingsAsync = result2.GetAllMappingsAsync();
							((Task)allMappingsAsync).Wait();
							List<Mapping> list = new List<Mapping>(allMappingsAsync.Result);
							LogInfo("Got " + list.Count + " mappings:");
							for (int i = 0; i < list.Count; i++)
							{
								LogInfo("\tMapping " + i + ": " + list[i].Description);
								if (list[i].Description.Contains("H3MP"))
								{
									LogInfo("\t\tH3MP Mapping, removing...");
									result2.DeletePortMapAsync(list[i]).Wait();
								}
							}
							break;
						}
						case 38:
							currentTNHSceneLoader.Load();
							break;
						}
					}
				}
			}
			if (!nullDriverControls)
			{
				return;
			}
			nullDriverMovement = Vector3.zero;
			if (Input.GetKey((KeyCode)119))
			{
				nullDriverMovement += GM.CurrentPlayerBody.Head.forward * Time.deltaTime;
			}
			if (Input.GetKey((KeyCode)115))
			{
				nullDriverMovement -= GM.CurrentPlayerBody.Head.forward * Time.deltaTime;
			}
			if (Input.GetKey((KeyCode)100))
			{
				nullDriverMovement += GM.CurrentPlayerBody.Head.right * Time.deltaTime;
			}
			if (Input.GetKey((KeyCode)97))
			{
				nullDriverMovement -= GM.CurrentPlayerBody.Head.right * Time.deltaTime;
			}
			if (Input.GetKey((KeyCode)32))
			{
				nullDriverMovement += GM.CurrentPlayerBody.Head.up * Time.deltaTime;
			}
			if (Input.GetKey((KeyCode)306))
			{
				nullDriverMovement -= GM.CurrentPlayerBody.Head.up * Time.deltaTime;
			}
			((Vector3)(ref nullDriverMovement)).Normalize();
			nullDriverMovement *= defaultNullDriverMovementMultiplier;
			float num = defaultNullDriverRotationMultiplier;
			if (Input.GetKey((KeyCode)304))
			{
				nullDriverMovement *= 5f;
				num = 2f;
			}
			if (Input.GetKey((KeyCode)273))
			{
				nullDriverVerticalRot -= 90f * Time.deltaTime * num;
				if (nullDriverVerticalRot < -90f)
				{
					nullDriverVerticalRot = -90f;
				}
			}
			else if (Input.GetKey((KeyCode)274))
			{
				nullDriverVerticalRot += 90f * Time.deltaTime * num;
				if (nullDriverVerticalRot > 90f)
				{
					nullDriverVerticalRot = 90f;
				}
			}
			if (Input.GetKey((KeyCode)275))
			{
				nullDriverHorzontalRot += 90f * Time.deltaTime * num;
			}
			if (Input.GetKey((KeyCode)276))
			{
				nullDriverHorzontalRot -= 90f * Time.deltaTime * num;
			}
			((Component)GM.CurrentPlayerBody).transform.rotation = Quaternion.Euler(nullDriverVerticalRot, nullDriverHorzontalRot, 0f);
			Transform transform = ((Component)GM.CurrentPlayerBody).transform;
			transform.position += nullDriverMovement;
			bool mouseButtonDown = Input.GetMouseButtonDown(0);
			bool mouseButtonDown2 = Input.GetMouseButtonDown(1);
			bool flag = false;
			if (mouseButtonDown)
			{
				FVRViveHand component2 = ((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>();
				if ((Object)(object)component2.CurrentInteractable != (Object)null)
				{
					TrackedItem component3 = ((Component)component2.CurrentInteractable).GetComponent<TrackedItem>();
					if ((Object)(object)component3 == (Object)null)
					{
						component2.CurrentInteractable.ForceBreakInteraction();
					}
					else if (component3.fireFunc != null)
					{
						component3.fireFunc(0);
					}
					else
					{
						component2.CurrentInteractable.ForceBreakInteraction();
					}
				}
				flag = true;
			}
			if (mouseButtonDown2)
			{
				FVRViveHand component4 = ((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>();
				if ((Object)(object)component4.CurrentInteractable != (Object)null)
				{
					TrackedItem component5 = ((Component)component4.CurrentInteractable).GetComponent<TrackedItem>();
					if ((Object)(object)component5 == (Object)null)
					{
						component4.CurrentInteractable.ForceBreakInteraction();
					}
					else if (component5.fireFunc != null)
					{
						component5.fireFunc(0);
					}
					else
					{
						component4.CurrentInteractable.ForceBreakInteraction();
					}
				}
				flag = true;
			}
			if (flag || !(mouseButtonDown || mouseButtonDown2))
			{
				return;
			}
			RaycastHit[] array = Physics.RaycastAll(Camera.main.ScreenPointToRay(Input.mousePosition), 10f);
			if (array == null || array.Length == 0)
			{
				return;
			}
			for (int k = 0; k < array.Length; k++)
			{
				FVRInteractiveObject component6 = ((Component)((RaycastHit)(ref array[k])).collider).GetComponent<FVRInteractiveObject>();
				if ((Object)(object)component6 != (Object)null)
				{
					if (mouseButtonDown)
					{
						FVRViveHand component7 = ((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>();
						component6.BeginInteraction(component7);
						component7.ForceSetInteractable(component6);
					}
					else if (mouseButtonDown2)
					{
						FVRViveHand component8 = ((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>();
						component6.BeginInteraction(component8);
						component8.ForceSetInteractable(component6);
					}
				}
			}
		}

		public static void TestCustomPacketIDServerHandler(int clientID, Packet packet)
		{
			LogInfo("Custom packet received from client " + clientID);
		}

		public static void TestCustomPacketIDClientHandler(int clientID, Packet packet)
		{
			LogInfo("Custom packet received from server");
		}

		public static void TestCustomPacketIDReceived(string identifier, int ID)
		{
			LogInfo("Client received ID " + ID + " for custom packet ID " + identifier);
			if (identifier.Equals("TestCustomPacketID"))
			{
				testCustomPacketID = ID;
				customPacketHandlers[testCustomPacketID] = TestCustomPacketIDClientHandler;
				CustomPacketHandlerReceived -= TestCustomPacketIDReceived;
			}
		}

		public GameObject SpawnItem(string itemID)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (IM.OD.TryGetValue(itemID, out var value))
			{
				return Object.Instantiate<GameObject>(((AnvilAsset)value).GetGameObject(), ((Component)Camera.main).transform.position + ((Component)Camera.main).transform.forward, Quaternion.identity);
			}
			return null;
		}

		public static bool PollInputPrefix()
		{
			return false;
		}

		public static void CustomPacketHandlerReceivedInvoke(string handlerID, int index)
		{
			if (Mod.CustomPacketHandlerReceived != null)
			{
				Mod.CustomPacketHandlerReceived(handlerID, index);
			}
		}

		public static void GenericCustomPacketReceivedInvoke(int clientID, string ID, Packet packet)
		{
			if (Mod.GenericCustomPacketReceived != null)
			{
				Mod.GenericCustomPacketReceived(clientID, ID, packet);
			}
		}

		public static void OnInstantiationTrackInvoke(GameObject gameObject)
		{
			if (Mod.OnInstantiationTrack != null)
			{
				Mod.OnInstantiationTrack(gameObject);
			}
		}

		public static void OnConnectionInvoke()
		{
			if (Mod.OnConnection != null)
			{
				Mod.OnConnection();
			}
		}

		private void SpawnDummyPlayer()
		{
			GameObject val = Object.Instantiate<GameObject>(playerPrefab);
			PlayerManager component = val.GetComponent<PlayerManager>();
			component.ID = -1;
			component.username = "Dummy";
			component.scene = GameManager.scene;
			component.instance = GameManager.instance;
			component.SetIFF(GM.CurrentPlayerBody.GetPlayerIFF());
		}

		public void LoadConfig()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading config...");
			try
			{
				config = JObject.Parse(File.ReadAllText(H3MPPath + "/Config.json"));
			}
			catch (Exception ex)
			{
				LogError("Failed to load config: " + ex.Message + ". Setting defaults config");
				config = new JObject();
				config["IP"] = JToken.op_Implicit("");
				config["Port"] = JToken.op_Implicit((ushort)7863);
				config["MaxClientCount"] = JToken.op_Implicit(5);
				config["Username"] = JToken.op_Implicit("Default Username");
				config["TickRate"] = JToken.op_Implicit(20);
				config["ServerName"] = JToken.op_Implicit("Default Server Name");
				JArray val = new JArray();
				config["ISList"] = (JToken)(object)val;
				JObject val2 = new JObject();
				val2["Name"] = JToken.op_Implicit("Official");
				val2["IP"] = JToken.op_Implicit("h3mp.tommysoucy.vip");
				val2["Port"] = JToken.op_Implicit(7862);
				val.Add((JToken)(object)val2);
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Config loaded");
		}

		public static void WriteConfig()
		{
			File.WriteAllText(H3MPPath + "/Config.json", ((object)JObject.FromObject((object)config)).ToString());
		}

		public static void InitTNHMenu()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Expected O, but got Unknown
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Expected O, but got Unknown
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Expected O, but got Unknown
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: Expected O, but got Unknown
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Expected O, but got Unknown
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Expected O, but got Unknown
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Expected O, but got Unknown
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b6: Expected O, but got Unknown
			//IL_0706: Unknown result type (might be due to invalid IL or missing references)
			//IL_0710: Expected O, but got Unknown
			//IL_0760: Unknown result type (might be due to invalid IL or missing references)
			//IL_076a: Expected O, but got Unknown
			//IL_0879: Unknown result type (might be due to invalid IL or missing references)
			//IL_0883: Expected O, but got Unknown
			//IL_08d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e3: Expected O, but got Unknown
			//IL_0933: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Expected O, but got Unknown
			//IL_098d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0997: Expected O, but got Unknown
			//IL_0aa0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aaa: Expected O, but got Unknown
			//IL_0b00: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0a: Expected O, but got Unknown
			//IL_0b60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6a: Expected O, but got Unknown
			//IL_0bba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc4: Expected O, but got Unknown
			//IL_0c14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c1e: Expected O, but got Unknown
			//IL_0c6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c78: Expected O, but got Unknown
			//IL_0d38: Unknown result type (might be due to invalid IL or missing references)
			TNHMenu = Object.Instantiate<GameObject>(TNHMenuPrefab, new Vector3(-2.4418f, 1.04f, 6.2977f), Quaternion.Euler(0f, 270f, 0f));
			joinTNHInstances = new Dictionary<int, GameObject>();
			currentTNHInstancePlayers = new Dictionary<int, GameObject>();
			FVRPointable val = ((Component)TNHMenu.transform.GetChild(0)).gameObject.AddComponent<FVRPointable>();
			val.MaxPointingRange = 5f;
			TNHMenuPages = (GameObject[])(object)new GameObject[7];
			TNHMenuPages[0] = ((Component)TNHMenu.transform.GetChild(1)).gameObject;
			TNHMenuPages[1] = ((Component)TNHMenu.transform.GetChild(2)).gameObject;
			TNHMenuPages[2] = ((Component)TNHMenu.transform.GetChild(3)).gameObject;
			TNHMenuPages[3] = ((Component)TNHMenu.transform.GetChild(4)).gameObject;
			TNHMenuPages[4] = ((Component)TNHMenu.transform.GetChild(5)).gameObject;
			TNHMenuPages[5] = ((Component)TNHMenu.transform.GetChild(6)).gameObject;
			TNHMenuPages[6] = ((Component)TNHMenu.transform.GetChild(7)).gameObject;
			TNHStatusText = ((Component)TNHMenu.transform.GetChild(8).GetChild(0)).GetComponent<Text>();
			TNHInstanceList = ((Component)TNHMenu.transform.GetChild(4).GetChild(2).GetChild(0)
				.GetChild(0)).gameObject;
			TNHInstancePrefab = ((Component)TNHMenu.transform.GetChild(4).GetChild(2).GetChild(0)
				.GetChild(0)
				.GetChild(0)).gameObject;
			TNHInstanceListScrollBar = ((Component)TNHMenu.transform.GetChild(4).GetChild(2).GetChild(1)).GetComponent<Scrollbar>();
			TNHPlayerList = ((Component)TNHMenu.transform.GetChild(5).GetChild(2).GetChild(0)
				.GetChild(0)).gameObject;
			TNHPlayerPrefab = ((Component)TNHMenu.transform.GetChild(5).GetChild(2).GetChild(0)
				.GetChild(0)
				.GetChild(0)).gameObject;
			TNHPlayerListScrollBar = ((Component)TNHMenu.transform.GetChild(5).GetChild(2).GetChild(1)).GetComponent<Scrollbar>();
			TNHLPJCheckMark = ((Component)TNHMenu.transform.GetChild(2).GetChild(1).GetChild(0)
				.GetChild(0)).gameObject;
			TNHHostOnDeathSpectateCheckMark = ((Component)TNHMenu.transform.GetChild(2).GetChild(2).GetChild(1)
				.GetChild(0)).gameObject;
			TNHHostOnDeathLeaveCheckMark = ((Component)TNHMenu.transform.GetChild(2).GetChild(2).GetChild(2)
				.GetChild(0)).gameObject;
			TNHJoinOnDeathSpectateCheckMark = ((Component)TNHMenu.transform.GetChild(3).GetChild(1).GetChild(1)
				.GetChild(0)).gameObject;
			TNHJoinOnDeathLeaveCheckMark = ((Component)TNHMenu.transform.GetChild(3).GetChild(1).GetChild(2)
				.GetChild(0)).gameObject;
			TNHInstanceTitle = ((Component)TNHMenu.transform.GetChild(5).GetChild(0)).GetComponent<Text>();
			TNHRequestHostOnDeathSpectateCheckMark = ((Component)TNHMenu.transform.GetChild(6).GetChild(1).GetChild(1)
				.GetChild(0)).gameObject;
			TNHRequestHostOnDeathLeaveCheckMark = ((Component)TNHMenu.transform.GetChild(6).GetChild(1).GetChild(2)
				.GetChild(0)).gameObject;
			TNHHostButton = ((Component)TNHMenu.transform.GetChild(1).GetChild(1)).gameObject;
			FVRPointableButton val2 = TNHHostButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHHostClicked));
			TNHJoinButton = ((Component)TNHMenu.transform.GetChild(1).GetChild(2)).gameObject;
			val2 = TNHJoinButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHJoinClicked));
			TNHRequestHostButton = ((Component)TNHMenu.transform.GetChild(1).GetChild(3)).gameObject;
			val2 = TNHRequestHostButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHRequestHostClicked));
			TNHRequestHostButton.SetActive(GameManager.spectatorHosts.Count > 0);
			TNHLPJCheck = ((Component)TNHMenu.transform.GetChild(2).GetChild(1).GetChild(0)).gameObject;
			val2 = TNHLPJCheck.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHLPJCheckClicked));
			TNHHostOnDeathSpectateRadio = ((Component)TNHMenu.transform.GetChild(2).GetChild(2).GetChild(1)).gameObject;
			val2 = TNHHostOnDeathSpectateRadio.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHHostOnDeathSpectateClicked));
			TNHHostOnDeathLeaveRadio = ((Component)TNHMenu.transform.GetChild(2).GetChild(2).GetChild(2)).gameObject;
			val2 = TNHHostOnDeathLeaveRadio.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHHostOnDeathLeaveClicked));
			TNHHostConfirmButton = ((Component)TNHMenu.transform.GetChild(2).GetChild(3)).gameObject;
			val2 = TNHHostConfirmButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHHostConfirmClicked));
			TNHHostCancelButton = ((Component)TNHMenu.transform.GetChild(2).GetChild(4)).gameObject;
			val2 = TNHHostCancelButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHHostCancelClicked));
			TNHJoinCancelButton = ((Component)TNHMenu.transform.GetChild(3).GetChild(3)).gameObject;
			val2 = TNHJoinCancelButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHJoinCancelClicked));
			TNHJoinInstanceCancelButton = ((Component)TNHMenu.transform.GetChild(4).GetChild(3)).gameObject;
			val2 = TNHJoinInstanceCancelButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHJoinCancelClicked));
			TNHInstanceListScrollUpArrow = ((Component)TNHMenu.transform.GetChild(4).GetChild(2).GetChild(2)).gameObject;
			TNHInstanceListScrollDownArrow = ((Component)TNHMenu.transform.GetChild(4).GetChild(2).GetChild(3)).gameObject;
			H3MPHoverScroll h3MPHoverScroll = TNHInstanceListScrollUpArrow.AddComponent<H3MPHoverScroll>();
			H3MPHoverScroll h3MPHoverScroll2 = TNHInstanceListScrollDownArrow.AddComponent<H3MPHoverScroll>();
			((FVRPointable)h3MPHoverScroll).MaxPointingRange = 5f;
			h3MPHoverScroll.scrollbar = TNHInstanceListScrollBar;
			h3MPHoverScroll.other = h3MPHoverScroll2;
			h3MPHoverScroll.up = true;
			h3MPHoverScroll.rate = 0.25f;
			((FVRPointable)h3MPHoverScroll2).MaxPointingRange = 5f;
			h3MPHoverScroll2.scrollbar = TNHInstanceListScrollBar;
			h3MPHoverScroll2.other = h3MPHoverScroll;
			h3MPHoverScroll2.rate = 0.25f;
			TNHJoinOnDeathSpectateRadio = ((Component)TNHMenu.transform.GetChild(3).GetChild(1).GetChild(1)).gameObject;
			val2 = TNHJoinOnDeathSpectateRadio.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHJoinOnDeathSpectateClicked));
			TNHJoinOnDeathLeaveRadio = ((Component)TNHMenu.transform.GetChild(3).GetChild(1).GetChild(2)).gameObject;
			val2 = TNHJoinOnDeathLeaveRadio.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHJoinOnDeathLeaveClicked));
			TNHJoinConfirmButton = ((Component)TNHMenu.transform.GetChild(3).GetChild(2)).gameObject;
			val2 = TNHJoinConfirmButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHJoinConfirmClicked));
			TNHJoinOptionsCancelButton = ((Component)TNHMenu.transform.GetChild(3).GetChild(3)).gameObject;
			val2 = TNHJoinOptionsCancelButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHJoinCancelClicked));
			TNHPlayerListScrollUpArrow = ((Component)TNHMenu.transform.GetChild(5).GetChild(2).GetChild(2)).gameObject;
			TNHPlayerListScrollDownArrow = ((Component)TNHMenu.transform.GetChild(5).GetChild(2).GetChild(3)).gameObject;
			h3MPHoverScroll = TNHPlayerListScrollUpArrow.AddComponent<H3MPHoverScroll>();
			h3MPHoverScroll2 = TNHPlayerListScrollDownArrow.AddComponent<H3MPHoverScroll>();
			((FVRPointable)h3MPHoverScroll).MaxPointingRange = 5f;
			h3MPHoverScroll.scrollbar = TNHInstanceListScrollBar;
			h3MPHoverScroll.other = h3MPHoverScroll2;
			h3MPHoverScroll.up = true;
			h3MPHoverScroll.rate = 0.25f;
			((FVRPointable)h3MPHoverScroll2).MaxPointingRange = 5f;
			h3MPHoverScroll2.scrollbar = TNHInstanceListScrollBar;
			h3MPHoverScroll2.other = h3MPHoverScroll;
			h3MPHoverScroll2.rate = 0.25f;
			TNHJoinOptionsCancelButton = ((Component)TNHMenu.transform.GetChild(5).GetChild(3)).gameObject;
			val2 = TNHJoinOptionsCancelButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHDisconnectClicked));
			TNHRequestHostOnDeathSpectateRadio = ((Component)TNHMenu.transform.GetChild(6).GetChild(1).GetChild(1)).gameObject;
			val2 = TNHJoinOnDeathSpectateRadio.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHRequestHostOnDeathSpectateClicked));
			TNHRequestHostOnDeathLeaveRadio = ((Component)TNHMenu.transform.GetChild(6).GetChild(1).GetChild(2)).gameObject;
			val2 = TNHJoinOnDeathLeaveRadio.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHRequestHostOnDeathLeaveClicked));
			TNHRequestHostConfirmButton = ((Component)TNHMenu.transform.GetChild(6).GetChild(2)).gameObject;
			val2 = TNHRequestHostConfirmButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHRequestHostConfirmClicked));
			TNHRequestHostCancelButton = ((Component)TNHMenu.transform.GetChild(6).GetChild(3)).gameObject;
			val2 = TNHRequestHostCancelButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHRequestHostCancelClicked));
			TNHRequestHostWaitingCancelButton = ((Component)TNHMenu.transform.GetChild(7).GetChild(2)).gameObject;
			val2 = TNHRequestHostWaitingCancelButton.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 5f;
			((UnityEvent)val2.Button.onClick).AddListener(new UnityAction(OnTNHRequestHostWaitingCancelClicked));
			currentTNHUIManager = Object.FindObjectOfType<TNH_UIManager>();
			currentTNHSceneLoader = Object.FindObjectOfType<TNH_LevelLoader>();
			if (currentTNHInstance != null)
			{
				InitTNHUIManager(currentTNHInstance);
				TNHMenuPages[0].SetActive(false);
				TNHMenuPages[1].SetActive(false);
				TNHMenuPages[2].SetActive(false);
				TNHMenuPages[3].SetActive(false);
				TNHMenuPages[4].SetActive(true);
				if (currentTNHInstance.playerIDs[0] == GameManager.ID)
				{
					TNHStatusText.text = "Hosting TNH instance";
				}
				else
				{
					TNHStatusText.text = "Client in TNH game";
				}
				((Graphic)TNHStatusText).color = Color.green;
				for (int i = 0; i < currentTNHInstance.playerIDs.Count; i++)
				{
					GameObject val3 = Object.Instantiate<GameObject>(TNHPlayerPrefab, TNHPlayerList.transform);
					if (GameManager.players.ContainsKey(currentTNHInstance.playerIDs[i]))
					{
						((Component)val3.transform.GetChild(0)).GetComponent<Text>().text = GameManager.players[currentTNHInstance.playerIDs[i]].username + ((i == 0) ? " (Host)" : "");
					}
					else
					{
						((Component)val3.transform.GetChild(0)).GetComponent<Text>().text = ((object)config["Username"]).ToString() + ((i == 0) ? " (Host)" : "");
					}
					val3.SetActive(true);
					currentTNHInstancePlayers.Add(currentTNHInstance.playerIDs[i], val3);
				}
			}
			else
			{
				TNHMenuLPJ = true;
				TNHOnDeathSpectate = true;
			}
		}

		public static void InitTNHUIManager(TNHInstance instance)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			currentTNHUIManager.OBS_Progression.SetSelectedButton(instance.progressionTypeSetting);
			GM.TNHOptions.ProgressionTypeSetting = (TNHSetting_ProgressionType)instance.progressionTypeSetting;
			currentTNHUIManager.OBS_EquipmentMode.SetSelectedButton(instance.equipmentModeSetting);
			GM.TNHOptions.EquipmentModeSetting = (TNHSetting_EquipmentMode)instance.equipmentModeSetting;
			currentTNHUIManager.OBS_HealthMode.SetSelectedButton(instance.healthModeSetting);
			GM.TNHOptions.HealthModeSetting = (TNHSetting_HealthMode)instance.healthModeSetting;
			currentTNHUIManager.OBS_TargetMode.SetSelectedButton(instance.targetModeSetting);
			GM.TNHOptions.TargetModeSetting = (TNHSetting_TargetMode)instance.targetModeSetting;
			currentTNHUIManager.OBS_AIDifficulty.SetSelectedButton(instance.AIDifficultyModifier);
			GM.TNHOptions.AIDifficultyModifier = (TNHModifier_AIDifficulty)instance.AIDifficultyModifier;
			currentTNHUIManager.OBS_AIRadarMode.SetSelectedButton(instance.radarModeModifier);
			GM.TNHOptions.RadarModeModifier = (TNHModifier_RadarMode)instance.radarModeModifier;
			currentTNHUIManager.OBS_ItemSpawner.SetSelectedButton(instance.itemSpawnerMode);
			GM.TNHOptions.ItemSpawnerMode = (TNH_ItemSpawnerMode)instance.itemSpawnerMode;
			currentTNHUIManager.OBS_Backpack.SetSelectedButton(instance.backpackMode);
			GM.TNHOptions.BackpackMode = (TNH_BackpackMode)instance.backpackMode;
			currentTNHUIManager.OBS_HealthMult.SetSelectedButton(instance.healthMult);
			GM.TNHOptions.HealthMult = (TNH_HealthMult)instance.healthMult;
			currentTNHUIManager.OBS_SosiggunReloading.SetSelectedButton(instance.sosiggunShakeReloading);
			GM.TNHOptions.SosiggunShakeReloading = (TNH_SosiggunShakeReloading)instance.sosiggunShakeReloading;
			currentTNHUIManager.OBS_RunSeed.SetSelectedButton(instance.TNHSeed + 1);
			GM.TNHOptions.TNHSeed = instance.TNHSeed;
			bool flag = false;
			for (int i = 0; i < currentTNHUIManager.Levels.Count; i++)
			{
				if (currentTNHUIManager.Levels[i].LevelID.Equals(instance.levelID))
				{
					flag = true;
					currentTNHUIManager._currentLevelIndex = i;
					currentTNHUIManager.CurrentLevel.LevelID = instance.levelID;
					currentTNHUIManager.UpdateLevelSelectUi();
					currentTNHUIManager.UpdateTableBasedOnOptions();
					((Component)currentTNHSceneLoader).gameObject.SetActive(true);
					break;
				}
			}
			if (!flag)
			{
				((Component)currentTNHSceneLoader).gameObject.SetActive(false);
				LogError("Missing TNH level: " + instance.levelID + "! Make sure you have it installed.");
			}
		}

		private void LoadAssets()
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Expected O, but got Unknown
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Expected I4, but got Unknown
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Expected O, but got Unknown
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Invalid comparison between Unknown and I4
			LogInfo("Loading assets...");
			AssetBundle val = AssetBundle.LoadFromFile(H3MPPath + "/H3MP.ab");
			TNHMenuPrefab = val.LoadAsset<GameObject>("TNHMenu");
			reticleFriendlyContactArrowMat = val.LoadAsset<Material>("ReticleFriendlyContactArrowMat");
			reticleFriendlyContactIconMat = val.LoadAsset<Material>("ReticleFriendlyContactIconMat");
			keyboardPrefab = val.LoadAsset<GameObject>("KeyBoard");
			serverListPrefab = val.LoadAsset<GameObject>("ServerList");
			playerPrefab = val.LoadAsset<GameObject>("Player");
			GameManager.playerPrefabs.Add("Default", (Object)(object)playerPrefab);
			GameManager.playerPrefabIDs.Add("Default");
			sosigWearableMap = ((JToken)JObject.Parse(File.ReadAllText(H3MPPath + "/SosigWearableMap.json"))).ToObject<Dictionary<string, string>>();
			TNHStartEquipButtonPrefab = val.LoadAsset<GameObject>("TNHStartEquipButton");
			FVRPointableButton val2 = ((Component)TNHStartEquipButtonPrefab.transform.GetChild(0)).gameObject.AddComponent<FVRPointableButton>();
			val2.SetButton();
			((FVRPointable)val2).MaxPointingRange = 1f;
			glassMatDef = ScriptableObject.CreateInstance<MatDef>();
			glassMatDef.BallisticType = (MatBallisticType)90;
			glassMatDef.SoundType = (MatSoundType)6;
			glassMatDef.ImpactEffectType = (BallisticImpactEffectType)0;
			glassMatDef.BulletHoleType = (BulletHoleDecalType)0;
			glassMatDef.BulletImpactSound = (BulletImpactSoundType)9;
			glassShotEvent = new AudioEvent();
			glassThudHeadEvent = new AudioEvent();
			glassThudTailEvent = new AudioEvent();
			glassGroundShatterEvent = new AudioEvent();
			glassTotalMediumEvent = new AudioEvent();
			for (int i = 1; i <= 3; i++)
			{
				glassShotEvent.Clips.Add(val.LoadAsset<AudioClip>("SheetBreak_Shot_Head_0" + i + ".wav"));
			}
			for (int j = 1; j <= 4; j++)
			{
				glassThudHeadEvent.Clips.Add(val.LoadAsset<AudioClip>("SheetBreak_Thud_Head_0" + j + ".wav"));
				glassThudTailEvent.Clips.Add(val.LoadAsset<AudioClip>("SheetBreak_Thud_Tail_0" + j + ".wav"));
				glassGroundShatterEvent.Clips.Add(val.LoadAsset<AudioClip>("SmallShard_GroundImpactShatter_0" + j + ".wav"));
			}
			for (int k = 1; k <= 8; k++)
			{
				glassTotalMediumEvent.Clips.Add(val.LoadAsset<AudioClip>("SheetBreak_Total_Medium_0" + k + ".wav"));
			}
			glassPrefab = val.LoadAsset<GameObject>("GlassPrefab");
			BreakableGlassDamager val3 = glassPrefab.AddComponent<BreakableGlassDamager>();
			val3.Glass = glassPrefab.AddComponent<BreakableGlass>();
			val3.AudEvent_Head_Projectile = glassShotEvent;
			val3.AudEvent_Head_Melee = glassThudHeadEvent;
			val3.AudEvent_Tail = glassThudTailEvent;
			val3.AudEvent_Shatter_BlowOut = glassTotalMediumEvent;
			val3.AudEvent_GroundShatter = glassGroundShatterEvent;
			glassPrefab.AddComponent<PMat>().MatDef = glassMatDef;
			glassPFXPrefab = val.LoadAsset<GameObject>("GlassPFXPlaceholder");
			glassPFXPrefab.AddComponent<KillAfter>().DieTime = 5f;
			val3.DestructionPFX_Directional = glassPFXPrefab;
			val3.DestructionPFX_Omni = glassPFXPrefab;
			AudioEvent[] array = (AudioEvent[])(object)new AudioEvent[4];
			for (int l = 0; l < 3; l++)
			{
				array[l] = new AudioEvent();
				array[l].PitchRange = new Vector2(1.3f, 1.33f);
				array[l].VolumeRange = new Vector2(0.4f, 0.4f);
				string text = "";
				switch (l)
				{
				case 0:
					text = "InsideLarge";
					break;
				case 1:
					text = "InsideSmall";
					break;
				case 2:
					text = "OutsideOpen";
					break;
				}
				for (int m = 1; m < 4; m++)
				{
					array[l].Clips.Add(val.LoadAsset<AudioClip>("DistantShot_" + text + "_" + m + ".wav"));
				}
			}
			distantShotSets = new Dictionary<FVRSoundEnvironment, AudioEvent>();
			foreach (FVRSoundEnvironment value in Enum.GetValues(typeof(FVRSoundEnvironment)))
			{
				FVRSoundEnvironment val5 = value;
				FVRSoundEnvironment val6 = val5;
				switch ((int)val6)
				{
				default:
					if (val6 - 30 > 1)
					{
						break;
					}
					goto case 0;
				case 0:
				case 10:
				case 12:
				case 15:
				case 17:
					distantShotSets.Add(value, array[0]);
					break;
				case 11:
				case 13:
				case 14:
				case 16:
					distantShotSets.Add(value, array[1]);
					break;
				case 1:
				case 20:
				case 21:
				case 22:
					distantShotSets.Add(value, array[2]);
					break;
				case 2:
				case 3:
				case 4:
				case 5:
				case 6:
				case 7:
				case 8:
				case 9:
				case 18:
				case 19:
					break;
				}
			}
			defaultSosigSpeechSet = val.LoadAsset<SosigSpeechSet>("DefaultSpeechSet");
			sosigAlertAlarm = new AudioEvent();
			sosigAlertAlarm.Clips.Add(val.LoadAsset<AudioClip>("Blister_LaserAlarm"));
		}

		private void GetTrackedObjectTypes()
		{
			trackedObjectTypes = new Dictionary<Type, List<Type>>();
			trackedObjectTypesByName = new Dictionary<string, Type>();
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				if (assemblies[i].FullName.Split(new char[1] { ',' })[0].Equals("H3MP"))
				{
					AddTrackedType(typeof(TrackedItemData));
					AddTrackedType(typeof(TrackedSosigData));
					AddTrackedType(typeof(TrackedEncryptionData));
					AddTrackedType(typeof(TrackedAutoMeaterData));
					AddTrackedType(typeof(TrackedBreakableGlassData));
					AddTrackedType(typeof(TrackedBlisterData));
					AddTrackedType(typeof(TrackedFloaterData));
					AddTrackedType(typeof(TrackedGatlingGunData));
					AddTrackedType(typeof(TrackedPlayerBodyData));
					AddTrackedType(typeof(TrackedIrisData));
					AddTrackedType(typeof(TrackedSentinelData));
					continue;
				}
				try
				{
					Type[] types = assemblies[i].GetTypes();
					for (int j = 0; j < types.Length; j++)
					{
						if (IsTypeTrackedObject(types[j]))
						{
							AddTrackedType(types[j]);
						}
					}
				}
				catch
				{
					LogWarning("Unable to read types from assembly: " + assemblies[i].FullName);
				}
			}
		}

		public void AddTrackedType(Type type)
		{
			trackedObjectTypesByName.Add(type.Name, type);
			if (trackedObjectTypes.Count == 0)
			{
				trackedObjectTypes.Add(type, new List<Type> { type });
				return;
			}
			foreach (KeyValuePair<Type, List<Type>> trackedObjectType in trackedObjectTypes)
			{
				if (type.IsSubclassOf(trackedObjectType.Key))
				{
					int num = 0;
					for (int i = 1; i < trackedObjectType.Value.Count; i++)
					{
						if (type.IsSubclassOf(trackedObjectType.Value[i]))
						{
							num = i;
						}
					}
					trackedObjectType.Value.Insert(num + 1, type);
					return;
				}
				if (trackedObjectType.Key.IsSubclassOf(type))
				{
					trackedObjectType.Value.Insert(0, type);
					trackedObjectTypes.Add(type, trackedObjectType.Value);
					trackedObjectTypes.Remove(trackedObjectType.Key);
					return;
				}
			}
			trackedObjectTypes.Add(type, new List<Type> { type });
		}

		public bool IsTypeTrackedObject(Type type)
		{
			if ((object)type.BaseType != null && type.IsSubclassOf(typeof(TrackedObjectData)))
			{
				MethodInfo method = type.GetMethod("IsOfType", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo method2 = type.GetMethod("MakeTracked", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if ((object)method != null && (object)method.ReturnType == typeof(bool) && (object)method.GetParameters()[0].ParameterType == typeof(Transform) && (object)method2 != null && method2.ReturnType.IsSubclassOf(typeof(TrackedObject)) && (object)method2.GetParameters()[0].ParameterType == typeof(Transform) && (object)method2.GetParameters()[1].ParameterType == typeof(TrackedObjectData))
				{
					return true;
				}
				LogError("TrackedObjectData inheriting type \"" + type.Name + "\" is missing implementation for one of the following methods:\n\tstatic bool IsOfType(Transform)\n\tstatic TrackedObject MakeTracked(Transform, TrackedObjectData)\n\tThis type will not be tracked.");
			}
			return false;
		}

		private void Init()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"H3MP Init called");
			H3MPPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof(Mod)).Location);
			H3MPPath.Replace('\\', '/');
			LogInfo("H3MP path found: " + H3MPPath, debug: false);
			GetTrackedObjectTypes();
			PatchController.DoPatching();
			LoadConfig();
			LoadAssets();
			SteamVR_Events.Loading.Listen((UnityAction<bool>)GameManager.OnSceneLoadedVR);
			SceneManager.sceneLoaded += OnSceneLoaded;
			SteamVR_Events.Loading.Listen((UnityAction<bool>)TrackedBreakableGlassData.ClearWrapperDicts);
			GameManager.OnSpectatorHostsChanged += OnSpectatorHostsChanged;
			GM.SetRunningModded();
		}

		private void OnSpectatorHostsChanged()
		{
			if ((Object)(object)TNHRequestHostButton != (Object)null)
			{
				TNHRequestHostButton.SetActive(GameManager.spectatorHosts.Count > 0);
			}
		}

		public static void OnHostClicked()
		{
			if (!((Object)(object)managerObject != (Object)null))
			{
				CreateManagerObject(host: true);
				Server.Start((ushort)config["MaxClientCount"], (ushort)config["Port"], (int)config["TickRate"]);
				if (GameManager.scene.Equals("TakeAndHold_Lobby_2"))
				{
					LogInfo("Just connected in TNH lobby, initializing H3MP menu");
					InitTNHMenu();
				}
				ForceDefaultPlayerBody();
				GameManager.firstPlayerInSceneInstance = true;
				if (Mod.OnConnection != null)
				{
					Mod.OnConnection();
				}
			}
		}

		public static void OnConnectClicked(IPEndPoint endPointOverride)
		{
			if ((Object)(object)managerObject != (Object)null)
			{
				return;
			}
			string text;
			ushort port;
			if (endPointOverride == null)
			{
				text = ((object)config["IP"]).ToString();
				port = (ushort)config["Port"];
			}
			else
			{
				text = endPointOverride.Address.ToString();
				port = (ushort)endPointOverride.Port;
			}
			if (text.Equals(""))
			{
				LogError("Attempted to connect to server but no IP set in config!");
				return;
			}
			if (!IPAddress.TryParse(text, out IPAddress _))
			{
				LogError("Attempted to connect to server but IP could not be parsed!");
				return;
			}
			CreateManagerObject();
			Client client = managerObject.AddComponent<Client>();
			client.IP = text;
			client.port = port;
			client.ConnectToServer();
			if (GameManager.scene.Equals("TakeAndHold_Lobby_2"))
			{
				LogInfo("Just connected in TNH lobby, initializing H3MP menu");
				InitTNHMenu();
			}
		}

		public static void ForceDefaultPlayerBody()
		{
			if ((GameManager.playerPrefabIndex != -1 && !GameManager.playerPrefabID.Equals("None")) || !((Object)(object)GameManager.currentPlayerBody == (Object)null) || GameManager.playerModelAwaitingInstantiation)
			{
				return;
			}
			GameManager.playerPrefabID = "Default";
			for (int i = 0; i < GameManager.playerPrefabIDs.Count; i++)
			{
				if (GameManager.playerPrefabIDs[i].Equals(GameManager.playerPrefabID))
				{
					GameManager.playerPrefabIndex = i;
					break;
				}
			}
			Object obj = GameManager.playerPrefabs[GameManager.playerPrefabID];
			GameManager.currentPlayerBody = Object.Instantiate<GameObject>((GameObject)(object)((obj is GameObject) ? obj : null)).GetComponent<PlayerBody>();
			if ((Object)(object)BodyWristMenuSection.playerBodyText != (Object)null)
			{
				BodyWristMenuSection.playerBodyText.text = "Body: Default";
			}
		}

		public static void OnTNHHostClicked()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[0].SetActive(false);
			TNHMenuPages[1].SetActive(true);
			TNHStatusText.text = "Setting up as Host";
			((Graphic)TNHStatusText).color = Color.blue;
		}

		private static void OnTNHJoinClicked()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[0].SetActive(false);
			TNHMenuPages[2].SetActive(true);
			TNHStatusText.text = "Setting up as Client";
			((Graphic)TNHStatusText).color = Color.blue;
		}

		private static void OnTNHLPJCheckClicked()
		{
			TNHLPJCheckMark.SetActive(!TNHLPJCheckMark.activeSelf);
			TNHMenuLPJ = TNHLPJCheckMark.activeSelf;
		}

		private static void OnTNHHostOnDeathSpectateClicked()
		{
			TNHHostOnDeathSpectateCheckMark.SetActive(!TNHHostOnDeathSpectateCheckMark.activeSelf);
			TNHHostOnDeathLeaveCheckMark.SetActive(!TNHHostOnDeathSpectateCheckMark.activeSelf);
			TNHOnDeathSpectate = TNHHostOnDeathSpectateCheckMark.activeSelf;
		}

		private static void OnTNHHostOnDeathLeaveClicked()
		{
			TNHHostOnDeathLeaveCheckMark.SetActive(!TNHHostOnDeathLeaveCheckMark.activeSelf);
			TNHHostOnDeathSpectateCheckMark.SetActive(!TNHHostOnDeathLeaveCheckMark.activeSelf);
			TNHOnDeathSpectate = TNHHostOnDeathSpectateCheckMark.activeSelf;
		}

		public static void OnTNHHostConfirmClicked()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00af: Expected I4, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[1].SetActive(false);
			TNHMenuPages[4].SetActive(true);
			setLatestInstance = true;
			TNHInstance instance = GameManager.AddNewTNHInstance(GameManager.ID, TNHMenuLPJ, (int)GM.TNHOptions.ProgressionTypeSetting, (int)GM.TNHOptions.HealthModeSetting, (int)GM.TNHOptions.EquipmentModeSetting, (int)GM.TNHOptions.TargetModeSetting, (int)GM.TNHOptions.AIDifficultyModifier, (int)GM.TNHOptions.RadarModeModifier, (int)GM.TNHOptions.ItemSpawnerMode, (int)GM.TNHOptions.BackpackMode, (int)GM.TNHOptions.HealthMult, (int)GM.TNHOptions.SosiggunShakeReloading, GM.TNHOptions.TNHSeed, currentTNHUIManager.CurrentLevel.LevelID);
			if (ThreadManager.host)
			{
				ServerSend.AddTNHInstance(instance);
			}
			TNHStatusText.text = "Hosting TNH instance";
			((Graphic)TNHStatusText).color = Color.green;
		}

		private static void OnTNHHostCancelClicked()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[0].SetActive(true);
			TNHMenuPages[1].SetActive(false);
			TNHStatusText.text = "Solo";
			((Graphic)TNHStatusText).color = Color.red;
		}

		private static void OnTNHJoinCancelClicked()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[0].SetActive(true);
			TNHMenuPages[2].SetActive(false);
			TNHMenuPages[3].SetActive(false);
			TNHStatusText.text = "Solo";
			((Graphic)TNHStatusText).color = Color.red;
		}

		private static void OnTNHJoinOnDeathSpectateClicked()
		{
			TNHJoinOnDeathSpectateCheckMark.SetActive(!TNHJoinOnDeathSpectateCheckMark.activeSelf);
			TNHJoinOnDeathLeaveCheckMark.SetActive(!TNHJoinOnDeathSpectateCheckMark.activeSelf);
			TNHOnDeathSpectate = TNHJoinOnDeathSpectateCheckMark.activeSelf;
		}

		private static void OnTNHJoinOnDeathLeaveClicked()
		{
			TNHJoinOnDeathLeaveCheckMark.SetActive(!TNHJoinOnDeathLeaveCheckMark.activeSelf);
			TNHJoinOnDeathSpectateCheckMark.SetActive(!TNHJoinOnDeathLeaveCheckMark.activeSelf);
			TNHOnDeathSpectate = TNHJoinOnDeathSpectateCheckMark.activeSelf;
		}

		private static void OnTNHJoinConfirmClicked()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (waitingForTNHHost)
			{
				TNHMenuPages[2].SetActive(false);
				if (SetTNHInstance(GameManager.TNHInstances[TNHHostedInstance]))
				{
					TNHMenuPages[4].SetActive(true);
					TNHStatusText.text = "Client in TNH game";
					((Graphic)TNHStatusText).color = Color.green;
				}
				else
				{
					TNHMenuPages[3].SetActive(true);
					PopulateInstancesList();
					((Graphic)((Component)joinTNHInstances[TNHHostedInstance].transform.GetChild(0)).GetComponent<Text>()).color = Color.red;
				}
				waitingForTNHHost = false;
			}
			else
			{
				TNHMenuPages[2].SetActive(false);
				TNHMenuPages[3].SetActive(true);
				PopulateInstancesList();
			}
		}

		private static void PopulateInstancesList()
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			if (joinTNHInstances == null)
			{
				joinTNHInstances = new Dictionary<int, GameObject>();
			}
			else
			{
				foreach (KeyValuePair<int, GameObject> joinTNHInstance in joinTNHInstances)
				{
					Object.Destroy((Object)(object)joinTNHInstance.Value);
				}
			}
			joinTNHInstances.Clear();
			foreach (KeyValuePair<int, TNHInstance> tNHInstance in GameManager.TNHInstances)
			{
				if (tNHInstance.Value.letPeopleJoin || tNHInstance.Value.currentlyPlaying.Count == 0)
				{
					GameObject val = Object.Instantiate<GameObject>(TNHInstancePrefab, TNHInstanceList.transform);
					((Component)val.transform.GetChild(0)).GetComponent<Text>().text = "Instance " + tNHInstance.Key;
					val.SetActive(true);
					int instanceID = tNHInstance.Key;
					FVRPointableButton val2 = val.AddComponent<FVRPointableButton>();
					val2.SetButton();
					((FVRPointable)val2).MaxPointingRange = 5f;
					((UnityEvent)val2.Button.onClick).AddListener((UnityAction)delegate
					{
						OnTNHInstanceClicked(instanceID);
					});
					joinTNHInstances.Add(tNHInstance.Key, val);
				}
			}
		}

		public static void OnTNHInstanceClicked(int instance)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (SetTNHInstance(GameManager.TNHInstances[instance]))
			{
				TNHMenuPages[3].SetActive(false);
				TNHMenuPages[4].SetActive(true);
				TNHStatusText.text = "Client in TNH game";
				((Graphic)TNHStatusText).color = Color.green;
			}
			else
			{
				((Graphic)((Component)joinTNHInstances[instance].transform.GetChild(0)).GetComponent<Text>()).color = Color.red;
			}
		}

		private static void OnTNHDisconnectClicked()
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[4].SetActive(false);
			TNHMenuPages[0].SetActive(true);
			GameManager.SetInstance(0);
			if (currentlyPlayingTNH)
			{
				currentTNHInstance.RemoveCurrentlyPlaying(send: true, GameManager.ID, ThreadManager.host);
				currentlyPlayingTNH = false;
			}
			currentTNHInstance = null;
			TNHSpectating = false;
			if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
				if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
				{
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
				}
			}
			TNHStatusText.text = "Solo";
			((Graphic)TNHStatusText).color = Color.red;
		}

		private static void OnTNHRequestHostClicked()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[0].SetActive(false);
			TNHMenuPages[5].SetActive(true);
			TNHStatusText.text = "Setting up host request";
			((Graphic)TNHStatusText).color = Color.blue;
		}

		private static void OnTNHRequestHostOnDeathSpectateClicked()
		{
			TNHRequestHostOnDeathSpectateCheckMark.SetActive(!TNHRequestHostOnDeathSpectateCheckMark.activeSelf);
			TNHRequestHostOnDeathLeaveCheckMark.SetActive(!TNHRequestHostOnDeathSpectateCheckMark.activeSelf);
			TNHRequestHostOnDeathSpectate = TNHRequestHostOnDeathSpectateCheckMark.activeSelf;
		}

		private static void OnTNHRequestHostOnDeathLeaveClicked()
		{
			TNHRequestHostOnDeathLeaveCheckMark.SetActive(!TNHRequestHostOnDeathLeaveCheckMark.activeSelf);
			TNHRequestHostOnDeathSpectateCheckMark.SetActive(!TNHRequestHostOnDeathLeaveCheckMark.activeSelf);
			TNHRequestHostOnDeathSpectate = TNHRequestHostOnDeathSpectateCheckMark.activeSelf;
		}

		private static void OnTNHRequestHostConfirmClicked()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[5].SetActive(false);
			TNHMenuPages[6].SetActive(true);
			TNHStatusText.text = "Waiting for host";
			((Graphic)TNHStatusText).color = Color.blue;
			if (ThreadManager.host)
			{
				if (Server.availableSpectatorHosts.Count > 0)
				{
					GameManager.controlledSpectatorHost = Server.availableSpectatorHosts[Server.availableSpectatorHosts.Count - 1];
					Server.spectatorHostByController.Add(0, GameManager.controlledSpectatorHost);
					Server.spectatorHostControllers.Add(GameManager.controlledSpectatorHost, 0);
					Server.availableSpectatorHosts.RemoveAt(Server.availableSpectatorHosts.Count - 1);
					ServerSend.SpectatorHostAssignment(GameManager.controlledSpectatorHost, 0);
					ServerSend.SpectatorHostOrderTNHHost(GameManager.controlledSpectatorHost, TNHRequestHostOnDeathSpectate);
					waitingForTNHHost = true;
				}
				else
				{
					TNHRequestHostButton.SetActive(false);
					TNHMenuPages[0].SetActive(true);
					TNHMenuPages[6].SetActive(false);
				}
			}
			else
			{
				ClientSend.RequestSpectatorHost();
				OnSpectatorHostReceived += OnReceiveTNHHost;
				waitingForTNHHost = true;
			}
		}

		private static void OnReceiveTNHHost(int host, ref bool confirmed)
		{
			if (confirmed)
			{
				LogError("Spectator host was already confirmed!");
			}
			else if (waitingForTNHHost)
			{
				GameManager.controlledSpectatorHost = host;
				confirmed = true;
				OnSpectatorHostReceived -= OnReceiveTNHHost;
				OnSpectatorHostGiveUp += OnSpectatorHostGiveUpOrdered;
				ClientSend.SpectatorHostOrderTNHHost(TNHRequestHostOnDeathSpectate);
			}
		}

		private static void OnSpectatorHostGiveUpOrdered()
		{
			if (waitingForTNHHost)
			{
				TNHRequestHostButton.SetActive(false);
				TNHMenuPages[0].SetActive(true);
				TNHMenuPages[6].SetActive(false);
				waitingForTNHHost = false;
				OnSpectatorHostGiveUp -= OnSpectatorHostGiveUpOrdered;
			}
		}

		public static void OnSpectatorHostReceivedInvoke(int host, bool reassignment = false)
		{
			bool confirmed = false;
			if (Mod.OnSpectatorHostReceived != null)
			{
				Mod.OnSpectatorHostReceived(host, ref confirmed);
			}
			if (reassignment)
			{
				GameManager.controlledSpectatorHost = host;
			}
			else if (!confirmed)
			{
				GameManager.controlledSpectatorHost = -1;
				ClientSend.UnassignSpectatorHost();
			}
		}

		public static void OnSpectatorHostGiveUpInvoke()
		{
			if (Mod.OnSpectatorHostGiveUp != null)
			{
				Mod.OnSpectatorHostGiveUp();
			}
			GameManager.controlledSpectatorHost = -1;
		}

		private static void OnTNHRequestHostCancelClicked()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			TNHMenuPages[0].SetActive(true);
			TNHMenuPages[5].SetActive(false);
			TNHStatusText.text = "Solo";
			((Graphic)TNHStatusText).color = Color.red;
		}

		private static void OnTNHRequestHostWaitingCancelClicked()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (waitingForTNHHost)
			{
				TNHMenuPages[0].SetActive(true);
				TNHMenuPages[6].SetActive(false);
				TNHStatusText.text = "Solo";
				((Graphic)TNHStatusText).color = Color.red;
				waitingForTNHHost = false;
				if (ThreadManager.host)
				{
					Server.spectatorHostByController.Remove(0);
					Server.spectatorHostControllers.Remove(GameManager.controlledSpectatorHost);
					if (GameManager.spectatorHosts.Contains(GameManager.controlledSpectatorHost))
					{
						Server.availableSpectatorHosts.Add(GameManager.controlledSpectatorHost);
					}
					GameManager.controlledSpectatorHost = -1;
				}
				else
				{
					ClientSend.UnassignSpectatorHost();
				}
			}
			else if (waitingForTNHGameStart)
			{
				TNHMenuPages[6].SetActive(false);
				TNHMenuPages[4].SetActive(true);
				waitingForTNHGameStart = false;
			}
		}

		public static void OnTNHSpawnStartEquipClicked()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_091e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0920: Unknown result type (might be due to invalid IL or missing references)
			//IL_0922: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a61: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a63: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Expected O, but got Unknown
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: Expected O, but got Unknown
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Expected O, but got Unknown
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_055f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_057d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0582: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_0703: Unknown result type (might be due to invalid IL or missing references)
			//IL_070a: Expected O, but got Unknown
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_0643: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Unknown result type (might be due to invalid IL or missing references)
			//IL_0666: Unknown result type (might be due to invalid IL or missing references)
			//IL_066b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07da: Expected O, but got Unknown
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_0727: Unknown result type (might be due to invalid IL or missing references)
			//IL_0731: Unknown result type (might be due to invalid IL or missing references)
			//IL_0736: Unknown result type (might be due to invalid IL or missing references)
			//IL_073b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d25: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d2a: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e72: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e77: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fb8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fce: Unknown result type (might be due to invalid IL or missing references)
			//IL_110a: Unknown result type (might be due to invalid IL or missing references)
			//IL_110c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1116: Unknown result type (might be due to invalid IL or missing references)
			//IL_111b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1120: Unknown result type (might be due to invalid IL or missing references)
			LogInfo("OnTNHSpawnStartEquipClicked, TNHTweakerASM = " + PatchController.TNHTweakerAsmIdx, debug: false);
			int num = 0;
			try
			{
				if ((Object)(object)GM.TNH_Manager != (Object)null)
				{
					num++;
					if ((Object)(object)managerObject != (Object)null)
					{
						currentTNHInstance.spawnedStartEquip = true;
					}
					TNH_Manager tNH_Manager = GM.TNH_Manager;
					TNH_CharacterDef c = tNH_Manager.C;
					Vector3 val = Vector3.ProjectOnPlane(GM.CurrentPlayerBody.Head.forward, Vector3.up);
					if ((int)tNH_Manager.ItemSpawnerMode == 1)
					{
						tNH_Manager.ItemSpawner.transform.position = GM.CurrentPlayerBody.Head.position + ((Vector3)(ref val)).normalized * 2f;
						tNH_Manager.ItemSpawner.transform.rotation = Quaternion.LookRotation(-val, Vector3.up);
						tNH_Manager.ItemSpawner.SetActive(true);
					}
					Vector3 val2 = GM.CurrentPlayerBody.Head.position + Vector3.down * 0.5f;
					Vector3 val3 = Vector3.ProjectOnPlane(GM.CurrentPlayerBody.Head.right, Vector3.up);
					Vector3 val4 = val2 + val * 0.8f;
					Vector3 val5 = val2 + val3 * 0.8f;
					Vector3 val6 = val2 - val3 * 0.8f;
					if (PatchController.TNHTweakerAsmIdx == -1)
					{
						num++;
						if (c.Has_Weapon_Primary)
						{
							LoadoutEntry weapon_Primary = c.Weapon_Primary;
							int num2 = -1;
							int num3 = -1;
							FVRObject val7;
							if (weapon_Primary.ListOverride != null && weapon_Primary.ListOverride.Count > 0)
							{
								val7 = weapon_Primary.ListOverride[Random.Range(0, weapon_Primary.ListOverride.Count)];
							}
							else
							{
								ObjectTableDef val8 = weapon_Primary.TableDefs[Random.Range(0, weapon_Primary.TableDefs.Count)];
								ObjectTable val9 = new ObjectTable();
								val9.Initialize(val8);
								LogInfo("Initialized object table for character: " + ((Object)c).name + ", objectTable.objs null?: " + (val9.Objs == null));
								val7 = val9.GetRandomObject();
								num2 = val8.MinAmmoCapacity;
								num3 = val8.MaxAmmoCapacity;
							}
							LogInfo("Instantiating weapon case, prefab null?: " + ((Object)(object)tNH_Manager.Prefab_WeaponCaseLarge == (Object)null) + ", weapon null?: " + ((Object)(object)val7 == (Object)null));
							GameObject val10 = tNH_Manager.SpawnWeaponCase(tNH_Manager.Prefab_WeaponCaseLarge, val4, -val, val7, weapon_Primary.Num_Mags_SL_Clips, weapon_Primary.Num_Rounds, num2, num3, weapon_Primary.AmmoObjectOverride);
							val10.GetComponent<TNH_WeaponCrate>().M = tNH_Manager;
							val10.AddComponent<TimerDestroyer>();
						}
						num++;
						if (c.Has_Weapon_Secondary)
						{
							LoadoutEntry weapon_Secondary = c.Weapon_Secondary;
							int num4 = -1;
							int num5 = -1;
							FVRObject val11;
							if (weapon_Secondary.ListOverride != null && weapon_Secondary.ListOverride.Count > 0)
							{
								val11 = weapon_Secondary.ListOverride[Random.Range(0, weapon_Secondary.ListOverride.Count)];
							}
							else
							{
								ObjectTableDef val12 = weapon_Secondary.TableDefs[Random.Range(0, weapon_Secondary.TableDefs.Count)];
								ObjectTable val13 = new ObjectTable();
								val13.Initialize(val12);
								val11 = val13.GetRandomObject();
								num4 = val12.MinAmmoCapacity;
								num5 = val12.MaxAmmoCapacity;
							}
							GameObject val14 = tNH_Manager.SpawnWeaponCase(tNH_Manager.Prefab_WeaponCaseSmall, val5, -val3, val11, weapon_Secondary.Num_Mags_SL_Clips, weapon_Secondary.Num_Rounds, num4, num5, weapon_Secondary.AmmoObjectOverride);
							val14.GetComponent<TNH_WeaponCrate>().M = tNH_Manager;
							val14.AddComponent<TimerDestroyer>();
						}
						num++;
						if (c.Has_Weapon_Tertiary)
						{
							LoadoutEntry weapon_Tertiary = c.Weapon_Tertiary;
							FVRObject val15;
							if (weapon_Tertiary.ListOverride != null && weapon_Tertiary.ListOverride.Count > 0)
							{
								val15 = weapon_Tertiary.ListOverride[Random.Range(0, weapon_Tertiary.ListOverride.Count)];
							}
							else
							{
								ObjectTableDef val16 = weapon_Tertiary.TableDefs[Random.Range(0, weapon_Tertiary.TableDefs.Count)];
								ObjectTable val17 = new ObjectTable();
								val17.Initialize(val16);
								val15 = val17.GetRandomObject();
							}
							GameObject val18 = Object.Instantiate<GameObject>(((AnvilAsset)val15).GetGameObject(), val5 + Vector3.up * 0.5f, Random.rotation);
							tNH_Manager.AddObjectToTrackedList(val18);
						}
						num++;
						if (c.Has_Item_Primary)
						{
							LoadoutEntry item_Primary = c.Item_Primary;
							FVRObject val19;
							if (item_Primary.ListOverride != null && item_Primary.ListOverride.Count > 0)
							{
								val19 = item_Primary.ListOverride[Random.Range(0, item_Primary.ListOverride.Count)];
							}
							else
							{
								ObjectTableDef val20 = item_Primary.TableDefs[Random.Range(0, item_Primary.TableDefs.Count)];
								ObjectTable val21 = new ObjectTable();
								val21.Initialize(val20);
								val19 = val21.GetRandomObject();
							}
							GameObject val22 = Object.Instantiate<GameObject>(((AnvilAsset)val19).GetGameObject(), val4 + Vector3.up * 0.3f + Vector3.left * 0.3f, Random.rotation);
							tNH_Manager.AddObjectToTrackedList(val22);
						}
						num++;
						if (c.Has_Item_Secondary)
						{
							LoadoutEntry item_Secondary = c.Item_Secondary;
							FVRObject val23;
							if (item_Secondary.ListOverride != null && item_Secondary.ListOverride.Count > 0)
							{
								val23 = item_Secondary.ListOverride[Random.Range(0, item_Secondary.ListOverride.Count)];
							}
							else
							{
								ObjectTableDef val24 = item_Secondary.TableDefs[Random.Range(0, item_Secondary.TableDefs.Count)];
								ObjectTable val25 = new ObjectTable();
								val25.Initialize(val24);
								val23 = val25.GetRandomObject();
							}
							GameObject val26 = Object.Instantiate<GameObject>(((AnvilAsset)val23).GetGameObject(), val4 + Vector3.up * 0.3f + Vector3.right * 0.3f, Random.rotation);
							tNH_Manager.AddObjectToTrackedList(val26);
						}
						num++;
						if (c.Has_Item_Tertiary)
						{
							LoadoutEntry item_Tertiary = c.Item_Tertiary;
							FVRObject val27;
							if (item_Tertiary.ListOverride != null && item_Tertiary.ListOverride.Count > 0)
							{
								val27 = item_Tertiary.ListOverride[Random.Range(0, item_Tertiary.ListOverride.Count)];
							}
							else
							{
								ObjectTableDef val28 = item_Tertiary.TableDefs[Random.Range(0, item_Tertiary.TableDefs.Count)];
								ObjectTable val29 = new ObjectTable();
								val29.Initialize(val28);
								val27 = val29.GetRandomObject();
							}
							GameObject val30 = Object.Instantiate<GameObject>(((AnvilAsset)val27).GetGameObject(), val4 + Vector3.up * 0.3f, Random.rotation);
							tNH_Manager.AddObjectToTrackedList(val30);
						}
						num++;
						if (c.Has_Item_Shield)
						{
							LoadoutEntry item_Shield = c.Item_Shield;
							FVRObject val31;
							if (item_Shield.ListOverride != null && item_Shield.ListOverride.Count > 0)
							{
								val31 = item_Shield.ListOverride[Random.Range(0, item_Shield.ListOverride.Count)];
							}
							else
							{
								ObjectTableDef val32 = item_Shield.TableDefs[Random.Range(0, item_Shield.TableDefs.Count)];
								ObjectTable val33 = new ObjectTable();
								val33.Initialize(val32);
								val31 = val33.GetRandomObject();
							}
							GameObject val34 = Object.Instantiate<GameObject>(((AnvilAsset)val31).GetGameObject(), val6, Quaternion.Euler(Vector3.up));
							tNH_Manager.AddObjectToTrackedList(val34);
						}
						num++;
					}
					else
					{
						num++;
						LogInfo("\tSpawning init equip as TNH tweaker char", debug: false);
						object obj = ((IDictionary)PatchController.TNHTweaker_LoadedTemplateManager_LoadedCharactersDict.GetValue(PatchController.TNHTweaker_LoadedTemplateManager))[c];
						num++;
						if ((bool)PatchController.TNHTweaker_CustomCharacter_HasPrimaryWeapon.GetValue(obj))
						{
							object value = PatchController.TNHTweaker_LoadoutEntry_PrimaryGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_PrimaryWeapon.GetValue(obj));
							if (value == null)
							{
								value = PatchController.TNHTweaker_LoadoutEntry_BackupGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_PrimaryWeapon.GetValue(obj));
							}
							if (value != null)
							{
								IList list = (IList)PatchController.TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups.Invoke(value, null);
								value = list[Random.Range(0, list.Count)];
								list = (IList)PatchController.TNHTweaker_EquipmentGroup_GetObjects.Invoke(value, null);
								FVRObject val35 = IM.OD[(string)list[Random.Range(0, list.Count)]];
								GameObject val36 = tNH_Manager.SpawnWeaponCase(tNH_Manager.Prefab_WeaponCaseLarge, val4, -val, val35, (int)PatchController.TNHTweaker_EquipmentGroup_NumMagsSpawned.GetValue(value), (int)PatchController.TNHTweaker_EquipmentGroup_NumRoundsSpawned.GetValue(value), (int)PatchController.TNHTweaker_EquipmentGroup_MinAmmoCapacity.GetValue(value), (int)PatchController.TNHTweaker_EquipmentGroup_MaxAmmoCapacity.GetValue(value), (FVRObject)null);
								val36.GetComponent<TNH_WeaponCrate>().M = tNH_Manager;
								val36.AddComponent<TimerDestroyer>();
							}
						}
						num++;
						if ((bool)PatchController.TNHTweaker_CustomCharacter_HasSecondaryWeapon.GetValue(obj))
						{
							object value2 = PatchController.TNHTweaker_LoadoutEntry_PrimaryGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_SecondaryWeapon.GetValue(obj));
							if (value2 == null)
							{
								value2 = PatchController.TNHTweaker_LoadoutEntry_BackupGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_SecondaryWeapon.GetValue(obj));
							}
							if (value2 != null)
							{
								IList list2 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups.Invoke(value2, null);
								value2 = list2[Random.Range(0, list2.Count)];
								list2 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetObjects.Invoke(value2, null);
								FVRObject val37 = IM.OD[(string)list2[Random.Range(0, list2.Count)]];
								GameObject val38 = tNH_Manager.SpawnWeaponCase(tNH_Manager.Prefab_WeaponCaseLarge, val5, -val, val37, (int)PatchController.TNHTweaker_EquipmentGroup_NumMagsSpawned.GetValue(value2), (int)PatchController.TNHTweaker_EquipmentGroup_NumRoundsSpawned.GetValue(value2), (int)PatchController.TNHTweaker_EquipmentGroup_MinAmmoCapacity.GetValue(value2), (int)PatchController.TNHTweaker_EquipmentGroup_MaxAmmoCapacity.GetValue(value2), (FVRObject)null);
								val38.GetComponent<TNH_WeaponCrate>().M = tNH_Manager;
								val38.AddComponent<TimerDestroyer>();
							}
						}
						num++;
						if ((bool)PatchController.TNHTweaker_CustomCharacter_HasTertiaryWeapon.GetValue(obj))
						{
							object value3 = PatchController.TNHTweaker_LoadoutEntry_PrimaryGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_TertiaryWeapon.GetValue(obj));
							if (value3 == null)
							{
								value3 = PatchController.TNHTweaker_LoadoutEntry_BackupGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_TertiaryWeapon.GetValue(obj));
							}
							if (value3 != null)
							{
								IList list3 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups.Invoke(value3, null);
								for (int i = 0; i < list3.Count; i++)
								{
									int num6 = (int)PatchController.TNHTweaker_EquipmentGroup_ItemsToSpawn.GetValue(value3);
									for (int j = 0; j < num6; j++)
									{
										IList list4 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetObjects.Invoke(value3, null);
										string key = (string)list4[Random.Range(0, list4.Count)];
										if (IM.OD.TryGetValue(key, out var value4))
										{
											GameObject gameObject = ((AnvilAsset)value4).GetGameObject();
											GameObject val39 = Object.Instantiate<GameObject>(gameObject, val5 + Vector3.up * 0.5f, Random.rotation);
											tNH_Manager.AddObjectToTrackedList(val39);
										}
									}
								}
							}
						}
						num++;
						if ((bool)PatchController.TNHTweaker_CustomCharacter_HasPrimaryItem.GetValue(obj))
						{
							object value5 = PatchController.TNHTweaker_LoadoutEntry_PrimaryGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_PrimaryItem.GetValue(obj));
							if (value5 == null)
							{
								value5 = PatchController.TNHTweaker_LoadoutEntry_BackupGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_PrimaryItem.GetValue(obj));
							}
							if (value5 != null)
							{
								IList list5 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups.Invoke(value5, null);
								for (int k = 0; k < list5.Count; k++)
								{
									int num7 = (int)PatchController.TNHTweaker_EquipmentGroup_ItemsToSpawn.GetValue(value5);
									for (int l = 0; l < num7; l++)
									{
										IList list6 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetObjects.Invoke(value5, null);
										string key2 = (string)list6[Random.Range(0, list6.Count)];
										if (IM.OD.TryGetValue(key2, out var value6))
										{
											GameObject gameObject2 = ((AnvilAsset)value6).GetGameObject();
											GameObject val40 = Object.Instantiate<GameObject>(gameObject2, val5 + Vector3.up * 0.5f, Random.rotation);
											tNH_Manager.AddObjectToTrackedList(val40);
										}
									}
								}
							}
						}
						num++;
						if ((bool)PatchController.TNHTweaker_CustomCharacter_HasSecondaryItem.GetValue(obj))
						{
							object value7 = PatchController.TNHTweaker_LoadoutEntry_PrimaryGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_SecondaryItem.GetValue(obj));
							if (value7 == null)
							{
								value7 = PatchController.TNHTweaker_LoadoutEntry_BackupGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_SecondaryItem.GetValue(obj));
							}
							if (value7 != null)
							{
								IList list7 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups.Invoke(value7, null);
								for (int m = 0; m < list7.Count; m++)
								{
									int num8 = (int)PatchController.TNHTweaker_EquipmentGroup_ItemsToSpawn.GetValue(value7);
									for (int n = 0; n < num8; n++)
									{
										IList list8 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetObjects.Invoke(value7, null);
										string key3 = (string)list8[Random.Range(0, list8.Count)];
										if (IM.OD.TryGetValue(key3, out var value8))
										{
											GameObject gameObject3 = ((AnvilAsset)value8).GetGameObject();
											GameObject val41 = Object.Instantiate<GameObject>(gameObject3, val5 + Vector3.up * 0.5f, Random.rotation);
											tNH_Manager.AddObjectToTrackedList(val41);
										}
									}
								}
							}
						}
						num++;
						if ((bool)PatchController.TNHTweaker_CustomCharacter_HasTertiaryItem.GetValue(obj))
						{
							object value9 = PatchController.TNHTweaker_LoadoutEntry_PrimaryGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_TertiaryItem.GetValue(obj));
							if (value9 == null)
							{
								value9 = PatchController.TNHTweaker_LoadoutEntry_BackupGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_TertiaryItem.GetValue(obj));
							}
							if (value9 != null)
							{
								IList list9 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups.Invoke(value9, null);
								for (int num9 = 0; num9 < list9.Count; num9++)
								{
									int num10 = (int)PatchController.TNHTweaker_EquipmentGroup_ItemsToSpawn.GetValue(value9);
									for (int num11 = 0; num11 < num10; num11++)
									{
										IList list10 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetObjects.Invoke(value9, null);
										string key4 = (string)list10[Random.Range(0, list10.Count)];
										if (IM.OD.TryGetValue(key4, out var value10))
										{
											GameObject gameObject4 = ((AnvilAsset)value10).GetGameObject();
											GameObject val42 = Object.Instantiate<GameObject>(gameObject4, val5 + Vector3.up * 0.5f, Random.rotation);
											tNH_Manager.AddObjectToTrackedList(val42);
										}
									}
								}
							}
						}
						num++;
						if ((bool)PatchController.TNHTweaker_CustomCharacter_HasShield.GetValue(obj))
						{
							object value11 = PatchController.TNHTweaker_LoadoutEntry_PrimaryGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_Shield.GetValue(obj));
							if (value11 == null)
							{
								value11 = PatchController.TNHTweaker_LoadoutEntry_BackupGroup.GetValue(PatchController.TNHTweaker_CustomCharacter_Shield.GetValue(obj));
							}
							if (value11 != null)
							{
								IList list11 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups.Invoke(value11, null);
								for (int num12 = 0; num12 < list11.Count; num12++)
								{
									int num13 = (int)PatchController.TNHTweaker_EquipmentGroup_ItemsToSpawn.GetValue(value11);
									for (int num14 = 0; num14 < num13; num14++)
									{
										IList list12 = (IList)PatchController.TNHTweaker_EquipmentGroup_GetObjects.Invoke(value11, null);
										string key5 = (string)list12[Random.Range(0, list12.Count)];
										if (IM.OD.TryGetValue(key5, out var value12))
										{
											GameObject gameObject5 = ((AnvilAsset)value12).GetGameObject();
											GameObject val43 = Object.Instantiate<GameObject>(gameObject5, val5 + Vector3.up * 0.5f, Random.rotation);
											tNH_Manager.AddObjectToTrackedList(val43);
										}
									}
								}
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				LogError("Error spawning initial equipment at step " + num + ": " + ex.Message + ":\n" + ex.StackTrace);
			}
			Object.Destroy((Object)(object)TNHStartEquipButton);
			TNHStartEquipButton = null;
		}

		public void OnTNHInstanceReceived(TNHInstance instance)
		{
			if (setLatestInstance)
			{
				setLatestInstance = false;
				SetTNHInstance(instance);
				if (spectatorHostWaitingForTNHInstance)
				{
					ClientSend.TNHSpectatorHostReady(GameManager.instance);
					spectatorHostWaitingForTNHInstance = false;
				}
			}
		}

		public void OnInstanceReceived(int instance)
		{
			if (setLatestInstance)
			{
				setLatestInstance = false;
				GameManager.SetInstance(instance);
			}
		}

		private static bool SetTNHInstance(TNHInstance instance)
		{
			if ((Object)(object)currentTNHUIManager != (Object)null)
			{
				currentTNHUIManager.SetOBS_Progression(instance.progressionTypeSetting);
				currentTNHUIManager.SetOBS_EquipmentMode(instance.equipmentModeSetting);
				currentTNHUIManager.SetOBS_TargetMode(instance.targetModeSetting);
				currentTNHUIManager.SetOBS_HealthMode(instance.healthModeSetting);
				currentTNHUIManager.SetOBS_RunSeed(instance.TNHSeed);
				currentTNHUIManager.SetOBS_AIDifficulty(instance.AIDifficultyModifier);
				currentTNHUIManager.SetOBS_AIRadarMode(instance.radarModeModifier);
				currentTNHUIManager.SetOBS_HealthMult(instance.healthMult);
				currentTNHUIManager.SetOBS_ItemSpawner(instance.itemSpawnerMode);
				currentTNHUIManager.SetOBS_Backpack(instance.backpackMode);
				currentTNHUIManager.SetOBS_SosiggunShakeReloading(instance.sosiggunShakeReloading);
				bool flag = false;
				for (int i = 0; i < currentTNHUIManager.Levels.Count; i++)
				{
					if (currentTNHUIManager.Levels[i].LevelID.Equals(instance.levelID))
					{
						flag = true;
						currentTNHUIManager._currentLevelIndex = i;
						currentTNHUIManager.CurrentLevel.LevelID = instance.levelID;
						currentTNHUIManager.UpdateLevelSelectUi();
						currentTNHUIManager.UpdateTableBasedOnOptions();
						currentTNHUIManager.PlayButtonSound(2);
						((Component)currentTNHSceneLoader).gameObject.SetActive(true);
						break;
					}
				}
				if (!flag)
				{
					((Component)currentTNHSceneLoader).gameObject.SetActive(false);
					LogError("Missing TNH level: " + instance.levelID + "! Make sure you have it installed.");
				}
			}
			GameManager.SetInstance(instance.instance);
			TNHInstanceTitle.text = "Instance " + instance.instance;
			if (currentTNHInstancePlayers == null)
			{
				currentTNHInstancePlayers = new Dictionary<int, GameObject>();
			}
			else
			{
				foreach (KeyValuePair<int, GameObject> currentTNHInstancePlayer in currentTNHInstancePlayers)
				{
					Object.Destroy((Object)(object)currentTNHInstancePlayer.Value);
				}
			}
			currentTNHInstancePlayers.Clear();
			for (int j = 0; j < instance.playerIDs.Count; j++)
			{
				GameObject val = Object.Instantiate<GameObject>(TNHPlayerPrefab, TNHPlayerList.transform);
				if (GameManager.players.ContainsKey(instance.playerIDs[j]))
				{
					((Component)val.transform.GetChild(0)).GetComponent<Text>().text = GameManager.players[instance.playerIDs[j]].username + ((j == 0) ? " (Host)" : "");
				}
				else
				{
					((Component)val.transform.GetChild(0)).GetComponent<Text>().text = ((object)config["Username"]).ToString() + ((j == 0) ? " (Host)" : "");
				}
				val.SetActive(true);
				currentTNHInstancePlayers.Add(instance.playerIDs[j], val);
			}
			currentTNHInstance = instance;
			return true;
		}

		public static void CreateManagerObject(bool host = false)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)managerObject == (Object)null)
			{
				managerObject = new GameObject();
				ThreadManager threadManager = managerObject.AddComponent<ThreadManager>();
				ThreadManager.host = host;
				GameManager gameManager = managerObject.AddComponent<GameManager>();
				Object.DontDestroyOnLoad((Object)(object)managerObject);
				DDOLScene = managerObject.scene;
			}
		}

		private void OnSceneLoaded(Scene loadedScene, LoadSceneMode loadedSceneMode)
		{
			if (((Scene)(ref loadedScene)).name.Equals("TakeAndHold_Lobby_2"))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"TNH lobby loaded, initializing H3MP menu if possible");
				if ((Object)(object)managerObject != (Object)null)
				{
					InitTNHMenu();
				}
			}
		}

		public static void DropAllItems()
		{
			if ((Object)(object)GM.CurrentMovementManager.Hands[0].CurrentInteractable != (Object)null)
			{
				GM.CurrentMovementManager.Hands[0].ForceSetInteractable((FVRInteractiveObject)null);
			}
			if ((Object)(object)GM.CurrentMovementManager.Hands[1].CurrentInteractable != (Object)null)
			{
				GM.CurrentMovementManager.Hands[1].ForceSetInteractable((FVRInteractiveObject)null);
			}
			foreach (FVRQuickBeltSlot quickbeltSlot in GM.CurrentPlayerBody.QuickbeltSlots)
			{
				if ((Object)(object)quickbeltSlot.CurObject != (Object)null)
				{
					quickbeltSlot.CurObject.ClearQuickbeltState();
				}
			}
			foreach (FVRQuickBeltSlot item in GM.CurrentPlayerBody.QBSlots_Internal)
			{
				if ((Object)(object)item.CurObject != (Object)null)
				{
					item.CurObject.ClearQuickbeltState();
				}
			}
			foreach (FVRQuickBeltSlot item2 in GM.CurrentPlayerBody.QBSlots_Added)
			{
				if ((Object)(object)item2.CurObject != (Object)null)
				{
					item2.CurObject.ClearQuickbeltState();
				}
			}
		}

		public static int GetBestPotentialObjectHost(int currentController, bool forUs = true, bool hasWhiteList = false, List<int> whiteList = null, string sceneOverride = null, int instanceOverride = -1)
		{
			if (hasWhiteList && whiteList == null)
			{
				whiteList = new List<int>();
			}
			int bestPotentialObjectHost = -1;
			if (Mod.OnGetBestPotentialObjectHost != null)
			{
				Mod.OnGetBestPotentialObjectHost(currentController, forUs, hasWhiteList, whiteList, sceneOverride, instanceOverride, ref bestPotentialObjectHost);
			}
			if (bestPotentialObjectHost != -1)
			{
				return bestPotentialObjectHost;
			}
			if (forUs)
			{
				if (currentTNHInstance != null)
				{
					if (currentController == -1)
					{
						foreach (int playerID in currentTNHInstance.playerIDs)
						{
							if (currentTNHInstance.currentlyPlaying.Contains(playerID) && (!hasWhiteList || whiteList.Contains(playerID)))
							{
								return playerID;
							}
						}
					}
					else
					{
						foreach (int playerID2 in currentTNHInstance.playerIDs)
						{
							if (playerID2 != currentController && currentTNHInstance.currentlyPlaying.Contains(playerID2) && (!hasWhiteList || whiteList.Contains(playerID2)))
							{
								return playerID2;
							}
						}
					}
				}
				else
				{
					string key = ((sceneOverride != null) ? sceneOverride : (GameManager.sceneLoading ? GameManager.sceneAtSceneLoadStart : GameManager.scene));
					int key2 = ((instanceOverride != -1) ? instanceOverride : (GameManager.sceneLoading ? GameManager.instanceAtSceneLoadStart : GameManager.instance));
					Dictionary<int, List<int>> value3;
					List<int> value4;
					if (currentController == -1)
					{
						if (GameManager.playersByInstanceByScene.TryGetValue(key, out var value) && value.TryGetValue(key2, out var value2))
						{
							if (value2.Count == 0)
							{
								return GameManager.ID;
							}
							bool flag = false;
							int num = int.MaxValue;
							for (int i = 0; i < value2.Count; i++)
							{
								if (value2[i] < num && (!hasWhiteList || whiteList.Contains(value2[i])))
								{
									flag = true;
									num = value2[i];
								}
							}
							if (GameManager.ID < num && (!hasWhiteList || whiteList.Contains(GameManager.ID)))
							{
								flag = true;
								num = GameManager.ID;
							}
							return flag ? num : (-1);
						}
					}
					else if (GameManager.playersByInstanceByScene.TryGetValue(key, out value3) && value3.TryGetValue(key2, out value4) && value4.Count > 0)
					{
						for (int j = 0; j < value4.Count; j++)
						{
							if (!hasWhiteList || whiteList.Contains(value4[j]))
							{
								return value4[j];
							}
						}
					}
				}
			}
			else if (ThreadManager.host)
			{
				string scene = Server.clients[currentController].player.scene;
				int instance = Server.clients[currentController].player.instance;
				if (scene.Equals(GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene) && instance == GameManager.instance && (!hasWhiteList || whiteList.Contains(0)))
				{
					return 0;
				}
				if (GameManager.playersByInstanceByScene.TryGetValue(scene, out var value5) && value5.TryGetValue(instance, out var value6) && value6.Count > 0)
				{
					bool flag2 = false;
					int num2 = int.MaxValue;
					for (int k = 0; k < value6.Count; k++)
					{
						if (value6[k] < num2 && (!hasWhiteList || whiteList.Contains(value6[k])))
						{
							flag2 = true;
							num2 = value6[k];
						}
					}
					return flag2 ? num2 : (-1);
				}
			}
			return -1;
		}

		public static void SetKinematicRecursive(Transform root, bool value)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			if (((Component)root).gameObject.activeSelf)
			{
				Rigidbody component = ((Component)root).GetComponent<Rigidbody>();
				if ((Object)(object)component != (Object)null)
				{
					KinematicMarker component2 = ((Component)component).GetComponent<KinematicMarker>();
					if (value)
					{
						if ((Object)(object)component2 == (Object)null)
						{
							component2 = ((Component)component).gameObject.AddComponent<KinematicMarker>();
						}
						KinematicPatch.skip++;
						component.isKinematic = value;
						KinematicPatch.skip--;
					}
					else if ((Object)(object)component2 != (Object)null)
					{
						KinematicPatch.skip++;
						component.isKinematic = value;
						KinematicPatch.skip--;
						Object.Destroy((Object)(object)component2);
					}
				}
			}
			foreach (Transform item in ((Component)root).transform)
			{
				Transform root2 = item;
				SetKinematicRecursive(root2, value);
			}
		}

		public static void RemovePlayerFromLists(int playerID)
		{
			PlayerManager playerManager = GameManager.players[playerID];
			if (GameManager.activeInstances.ContainsKey(playerManager.instance))
			{
				Dictionary<int, int> activeInstances = GameManager.activeInstances;
				int instance = playerManager.instance;
				int value = activeInstances[instance] - 1;
				activeInstances[instance] = value;
				if (GameManager.activeInstances[playerManager.instance] == 0)
				{
					GameManager.activeInstances.Remove(playerManager.instance);
				}
			}
			GameManager.playersByInstanceByScene[playerManager.scene][playerManager.instance].Remove(playerManager.ID);
			if (GameManager.playersByInstanceByScene[playerManager.scene][playerManager.instance].Count == 0)
			{
				GameManager.playersByInstanceByScene[playerManager.scene].Remove(playerManager.instance);
			}
			if (GameManager.playersByInstanceByScene[playerManager.scene].Count == 0)
			{
				GameManager.playersByInstanceByScene.Remove(playerManager.scene);
			}
			if (playerManager.scene.Equals(GameManager.scene) && !GameManager.nonSynchronizedScenes.ContainsKey(playerManager.scene) && GameManager.instance == playerManager.instance)
			{
				GameManager.playersPresent.Remove(playerID);
			}
			RemovePlayerFromSpecificLists(playerManager);
			Object.Destroy((Object)(object)((Component)GameManager.players[playerID]).gameObject);
			GameManager.players.Remove(playerID);
			if (ISClient.isConnected && ISClient.listed)
			{
				LogInfo("Player removed from lists, sending new playercount: " + (GameManager.players.Count + 1), debug: false);
				ISClientSend.PlayerCount(GameManager.players.Count + 1);
			}
			if (Mod.OnPlayerRemoved != null)
			{
				Mod.OnPlayerRemoved(playerManager);
			}
		}

		public static void RemovePlayerFromSpecificLists(PlayerManager player)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.TNHInstances.TryGetValue(player.instance, out var value))
			{
				int num = value.playerIDs[0];
				value.playerIDs.Remove(player.ID);
				if (value.playerIDs.Count == 0)
				{
					GameManager.TNHInstances.Remove(player.instance);
					if ((Object)(object)TNHInstanceList != (Object)null && joinTNHInstances.ContainsKey(player.instance))
					{
						Object.Destroy((Object)(object)joinTNHInstances[player.instance]);
						joinTNHInstances.Remove(player.instance);
					}
					if (currentTNHInstance != null && currentTNHInstance.instance == player.instance)
					{
						TNHSpectating = false;
						if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
						{
							GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
							if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
							{
								((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
								((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
							}
						}
					}
				}
				else
				{
					if ((Object)(object)TNHMenu != (Object)null && (Object)(object)TNHPlayerList != (Object)null && (Object)(object)TNHPlayerPrefab != (Object)null && currentTNHInstancePlayers != null && currentTNHInstancePlayers.ContainsKey(player.ID))
					{
						Object.Destroy((Object)(object)currentTNHInstancePlayers[player.ID]);
						currentTNHInstancePlayers.Remove(player.ID);
						if (num != value.playerIDs[0])
						{
							Text component = ((Component)currentTNHInstancePlayers[value.playerIDs[0]].transform.GetChild(0)).GetComponent<Text>();
							component.text += " (Host)";
						}
					}
					value.currentlyPlaying.Remove(player.ID);
					value.played.Remove(player.ID);
					value.dead.Remove(player.ID);
				}
			}
			if (Mod.OnRemovePlayerFromSpecificLists != null)
			{
				Mod.OnRemovePlayerFromSpecificLists(player);
			}
		}

		public static string GetSHA256Hash(string input)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] bytes = Encoding.ASCII.GetBytes(input);
			byte[] ba = sHA.ComputeHash(bytes);
			return ByteArrayToString(ba);
		}

		public static string ByteArrayToString(byte[] ba)
		{
			return BitConverter.ToString(ba).Replace("-", "");
		}

		public static void LogInfo(string message, bool debug = true)
		{
			if (debug)
			{
				((BaseUnityPlugin)modInstance).Logger.LogInfo((object)message);
			}
			else
			{
				((BaseUnityPlugin)modInstance).Logger.LogInfo((object)message);
			}
		}

		public static void LogWarning(string message)
		{
			((BaseUnityPlugin)modInstance).Logger.LogWarning((object)message);
		}

		public static void LogError(string message)
		{
			((BaseUnityPlugin)modInstance).Logger.LogError((object)message);
		}
	}
}
namespace H3MP.Patches
{
	public class ActionPatches
	{
		public static void DoPatching(Harmony harmony, ref int patchIndex)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0082: Expected O, but got Unknown
			//IL_0082: Expected O, but got Unknown
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Expected O, but got Unknown
			//IL_04fb: Expected O, but got Unknown
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: Expected O, but got Unknown
			//IL_0515: Expected O, but got Unknown
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Expected O, but got Unknown
			//IL_052f: Expected O, but got Unknown
			//IL_0535: Unknown result type (might be due to invalid IL or missing references)
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Expected O, but got Unknown
			//IL_0549: Expected O, but got Unknown
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Expected O, but got Unknown
			//IL_0563: Expected O, but got Unknown
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d5: Expected O, but got Unknown
			//IL_05d5: Expected O, but got Unknown
			//IL_0633: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0647: Expected O, but got Unknown
			//IL_0647: Expected O, but got Unknown
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Expected O, but got Unknown
			//IL_06b9: Expected O, but got Unknown
			//IL_0720: Unknown result type (might be due to invalid IL or missing references)
			//IL_0727: Unknown result type (might be due to invalid IL or missing references)
			//IL_0734: Expected O, but got Unknown
			//IL_0734: Expected O, but got Unknown
			//IL_0792: Unknown result type (might be due to invalid IL or missing references)
			//IL_0799: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a6: Expected O, but got Unknown
			//IL_07a6: Expected O, but got Unknown
			//IL_0834: Unknown result type (might be due to invalid IL or missing references)
			//IL_083b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0848: Expected O, but got Unknown
			//IL_0848: Expected O, but got Unknown
			//IL_08a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ba: Expected O, but got Unknown
			//IL_08ba: Expected O, but got Unknown
			//IL_0aa5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab9: Expected O, but got Unknown
			//IL_0ab9: Expected O, but got Unknown
			//IL_0b86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b94: Expected O, but got Unknown
			//IL_0cbc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cca: Expected O, but got Unknown
			//IL_0d10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d1e: Expected O, but got Unknown
			//IL_0d64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d72: Expected O, but got Unknown
			//IL_0db8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc6: Expected O, but got Unknown
			//IL_0e0c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e1a: Expected O, but got Unknown
			//IL_0e90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e9e: Expected O, but got Unknown
			//IL_0ea4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eb2: Expected O, but got Unknown
			//IL_0ef8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f06: Expected O, but got Unknown
			//IL_1455: Unknown result type (might be due to invalid IL or missing references)
			//IL_145c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1469: Expected O, but got Unknown
			//IL_1469: Expected O, but got Unknown
			//IL_146f: Unknown result type (might be due to invalid IL or missing references)
			//IL_147d: Expected O, but got Unknown
			//IL_151e: Unknown result type (might be due to invalid IL or missing references)
			//IL_152c: Expected O, but got Unknown
			//IL_1532: Unknown result type (might be due to invalid IL or missing references)
			//IL_1540: Expected O, but got Unknown
			//IL_1546: Unknown result type (might be due to invalid IL or missing references)
			//IL_1554: Expected O, but got Unknown
			//IL_155a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1561: Unknown result type (might be due to invalid IL or missing references)
			//IL_156e: Expected O, but got Unknown
			//IL_156e: Expected O, but got Unknown
			//IL_1574: Unknown result type (might be due to invalid IL or missing references)
			//IL_157b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1588: Expected O, but got Unknown
			//IL_1588: Expected O, but got Unknown
			//IL_158f: Unknown result type (might be due to invalid IL or missing references)
			//IL_159c: Expected O, but got Unknown
			//IL_15a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b0: Expected O, but got Unknown
			//IL_15b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_15c4: Expected O, but got Unknown
			//IL_176e: Unknown result type (might be due to invalid IL or missing references)
			//IL_177c: Expected O, but got Unknown
			//IL_1782: Unknown result type (might be due to invalid IL or missing references)
			//IL_1790: Expected O, but got Unknown
			//IL_1796: Unknown result type (might be due to invalid IL or missing references)
			//IL_179d: Unknown result type (might be due to invalid IL or missing references)
			//IL_17aa: Expected O, but got Unknown
			//IL_17aa: Expected O, but got Unknown
			//IL_182a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1838: Expected O, but got Unknown
			//IL_183e: Unknown result type (might be due to invalid IL or missing references)
			//IL_184c: Expected O, but got Unknown
			//IL_1892: Unknown result type (might be due to invalid IL or missing references)
			//IL_18a0: Expected O, but got Unknown
			//IL_18fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_190c: Expected O, but got Unknown
			//IL_1912: Unknown result type (might be due to invalid IL or missing references)
			//IL_1920: Expected O, but got Unknown
			//IL_1966: Unknown result type (might be due to invalid IL or missing references)
			//IL_1974: Expected O, but got Unknown
			//IL_19f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a02: Expected O, but got Unknown
			//IL_1a08: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a16: Expected O, but got Unknown
			//IL_1a5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a6a: Expected O, but got Unknown
			//IL_1c24: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c32: Expected O, but got Unknown
			//IL_1d05: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d13: Expected O, but got Unknown
			//IL_1d71: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d78: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d85: Expected O, but got Unknown
			//IL_1d85: Expected O, but got Unknown
			//IL_1e76: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e83: Expected O, but got Unknown
			//IL_1e8a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e97: Expected O, but got Unknown
			//IL_1e9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1eab: Expected O, but got Unknown
			//IL_1eb2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ebf: Expected O, but got Unknown
			//IL_1ec6: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ed3: Expected O, but got Unknown
			//IL_1eda: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ee7: Expected O, but got Unknown
			//IL_1f2d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f3b: Expected O, but got Unknown
			//IL_2066: Unknown result type (might be due to invalid IL or missing references)
			//IL_2074: Expected O, but got Unknown
			//IL_211f: Unknown result type (might be due to invalid IL or missing references)
			//IL_2126: Unknown result type (might be due to invalid IL or missing references)
			//IL_2133: Expected O, but got Unknown
			//IL_2133: Expected O, but got Unknown
			//IL_21b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_21c1: Expected O, but got Unknown
			//IL_21c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_21d5: Expected O, but got Unknown
			//IL_2255: Unknown result type (might be due to invalid IL or missing references)
			//IL_2263: Expected O, but got Unknown
			//IL_2269: Unknown result type (might be due to invalid IL or missing references)
			//IL_2277: Expected O, but got Unknown
			//IL_24d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_24e4: Expected O, but got Unknown
			//IL_24ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_24f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_24fe: Expected O, but got Unknown
			//IL_24fe: Expected O, but got Unknown
			//IL_2505: Unknown result type (might be due to invalid IL or missing references)
			//IL_2512: Expected O, but got Unknown
			//IL_2565: Unknown result type (might be due to invalid IL or missing references)
			//IL_2573: Expected O, but got Unknown
			//IL_257a: Unknown result type (might be due to invalid IL or missing references)
			//IL_2587: Expected O, but got Unknown
			//IL_258e: Unknown result type (might be due to invalid IL or missing references)
			//IL_259b: Expected O, but got Unknown
			//IL_261b: Unknown result type (might be due to invalid IL or missing references)
			//IL_2629: Expected O, but got Unknown
			//IL_26bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_26ca: Expected O, but got Unknown
			//IL_2710: Unknown result type (might be due to invalid IL or missing references)
			//IL_271e: Expected O, but got Unknown
			//IL_2764: Unknown result type (might be due to invalid IL or missing references)
			//IL_2772: Expected O, but got Unknown
			//IL_283f: Unknown result type (might be due to invalid IL or missing references)
			//IL_284d: Expected O, but got Unknown
			//IL_2aaf: Unknown result type (might be due to invalid IL or missing references)
			//IL_2abd: Expected O, but got Unknown
			//IL_2ac3: Unknown result type (might be due to invalid IL or missing references)
			//IL_2ad1: Expected O, but got Unknown
			//IL_2ad7: Unknown result type (might be due to invalid IL or missing references)
			//IL_2ae5: Expected O, but got Unknown
			//IL_2c9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_2ca8: Expected O, but got Unknown
			//IL_2cee: Unknown result type (might be due to invalid IL or missing references)
			//IL_2cfc: Expected O, but got Unknown
			//IL_2d42: Unknown result type (might be due to invalid IL or missing references)
			//IL_2d50: Expected O, but got Unknown
			//IL_2e75: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e83: Expected O, but got Unknown
			//IL_2e89: Unknown result type (might be due to invalid IL or missing references)
			//IL_2e97: Expected O, but got Unknown
			//IL_2e9d: Unknown result type (might be due to invalid IL or missing references)
			//IL_2eab: Expected O, but got Unknown
			//IL_300e: Unknown result type (might be due to invalid IL or missing references)
			//IL_301c: Expected O, but got Unknown
			//IL_3076: Unknown result type (might be due to invalid IL or missing references)
			//IL_3084: Expected O, but got Unknown
			//IL_30de: Unknown result type (might be due to invalid IL or missing references)
			//IL_30ec: Expected O, but got Unknown
			//IL_3329: Unknown result type (might be due to invalid IL or missing references)
			//IL_3337: Expected O, but got Unknown
			//IL_3489: Unknown result type (might be due to invalid IL or missing references)
			//IL_3496: Expected O, but got Unknown
			//IL_34a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_34b2: Expected O, but got Unknown
			//IL_34c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_34ce: Expected O, but got Unknown
			//IL_3529: Unknown result type (might be due to invalid IL or missing references)
			//IL_3536: Expected O, but got Unknown
			//IL_3590: Unknown result type (might be due to invalid IL or missing references)
			//IL_359e: Expected O, but got Unknown
			//IL_35f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_3606: Expected O, but got Unknown
			//IL_3661: Unknown result type (might be due to invalid IL or missing references)
			//IL_366e: Expected O, but got Unknown
			//IL_36c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_36d6: Expected O, but got Unknown
			//IL_3848: Unknown result type (might be due to invalid IL or missing references)
			//IL_3856: Expected O, but got Unknown
			//IL_3864: Unknown result type (might be due to invalid IL or missing references)
			//IL_3872: Expected O, but got Unknown
			//IL_3880: Unknown result type (might be due to invalid IL or missing references)
			//IL_388e: Expected O, but got Unknown
			//IL_389c: Unknown result type (might be due to invalid IL or missing references)
			//IL_38aa: Expected O, but got Unknown
			//IL_38b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_38c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_38d0: Expected O, but got Unknown
			//IL_38d0: Expected O, but got Unknown
			//IL_3a42: Unknown result type (might be due to invalid IL or missing references)
			//IL_3a50: Expected O, but got Unknown
			//IL_3a5e: Unknown result type (might be due to invalid IL or missing references)
			//IL_3a6c: Expected O, but got Unknown
			//IL_3a7a: Unknown result type (might be due to invalid IL or missing references)
			//IL_3a88: Expected O, but got Unknown
			//IL_3a96: Unknown result type (might be due to invalid IL or missing references)
			//IL_3aa4: Expected O, but got Unknown
			//IL_3ab2: Unknown result type (might be due to invalid IL or missing references)
			//IL_3ac0: Expected O, but got Unknown
			//IL_3ba6: Unknown result type (might be due to invalid IL or missing references)
			//IL_3bb4: Expected O, but got Unknown
			//IL_3bc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_3bd0: Expected O, but got Unknown
			//IL_3bde: Unknown result type (might be due to invalid IL or missing references)
			//IL_3bec: Expected O, but got Unknown
			//IL_3c8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_3c9a: Expected O, but got Unknown
			//IL_3ca8: Unknown result type (might be due to invalid IL or missing references)
			//IL_3cb6: Expected O, but got Unknown
			//IL_3dd4: Unknown result type (might be due to invalid IL or missing references)
			//IL_3ddf: Unknown result type (might be due to invalid IL or missing references)
			//IL_3dec: Expected O, but got Unknown
			//IL_3dec: Expected O, but got Unknown
			//IL_3dfa: Unknown result type (might be due to invalid IL or missing references)
			//IL_3e08: Expected O, but got Unknown
			//IL_3f07: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f15: Expected O, but got Unknown
			//IL_3f23: Unknown result type (might be due to invalid IL or missing references)
			//IL_3f31: Expected O, but got Unknown
			//IL_4018: Unknown result type (might be due to invalid IL or missing references)
			//IL_4025: Expected O, but got Unknown
			//IL_4033: Unknown result type (might be due to invalid IL or missing references)
			//IL_4041: Expected O, but got Unknown
			//IL_404f: Unknown result type (might be due to invalid IL or missing references)
			//IL_405d: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_014b: Expected O, but got Unknown
			//IL_014b: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0214: Expected O, but got Unknown
			//IL_0214: Expected O, but got Unknown
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Expected O, but got Unknown
			//IL_099b: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b5: Expected O, but got Unknown
			//IL_09b5: Expected O, but got Unknown
			//IL_09b5: Expected O, but got Unknown
			//IL_09f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a03: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0f: Expected O, but got Unknown
			//IL_0a0f: Expected O, but got Unknown
			//IL_0a0f: Expected O, but got Unknown
			//IL_0b3c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b48: Expected O, but got Unknown
			//IL_0c64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c6b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c72: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c7e: Expected O, but got Unknown
			//IL_0c7e: Expected O, but got Unknown
			//IL_0c7e: Expected O, but got Unknown
			//IL_1486: Unknown result type (might be due to invalid IL or missing references)
			//IL_1492: Expected O, but got Unknown
			//IL_14d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_14e0: Expected O, but got Unknown
			//IL_1ac9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ad1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1add: Expected O, but got Unknown
			//IL_1add: Expected O, but got Unknown
			//IL_1b8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b93: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ba6: Expected O, but got Unknown
			//IL_1ba6: Expected O, but got Unknown
			//IL_1ba6: Expected O, but got Unknown
			//IL_1c7b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c87: Expected O, but got Unknown
			//IL_200e: Unknown result type (might be due to invalid IL or missing references)
			//IL_2015: Unknown result type (might be due to invalid IL or missing references)
			//IL_201c: Unknown result type (might be due to invalid IL or missing references)
			//IL_2028: Expected O, but got Unknown
			//IL_2028: Expected O, but got Unknown
			//IL_2028: Expected O, but got Unknown
			//IL_207d: Unknown result type (might be due to invalid IL or missing references)
			//IL_2089: Expected O, but got Unknown
			//IL_2484: Unknown result type (might be due to invalid IL or missing references)
			//IL_248c: Unknown result type (might be due to invalid IL or missing references)
			//IL_2498: Expected O, but got Unknown
			//IL_2498: Expected O, but got Unknown
			//IL_251b: Unknown result type (might be due to invalid IL or missing references)
			//IL_2527: Expected O, but got Unknown
			//IL_2632: Unknown result type (might be due to invalid IL or missing references)
			//IL_263e: Expected O, but got Unknown
			//IL_27f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_2801: Expected O, but got Unknown
			//IL_2a17: Unknown result type (might be due to invalid IL or missing references)
			//IL_2a23: Expected O, but got Unknown
			//IL_2a65: Unknown result type (might be due to invalid IL or missing references)
			//IL_2a71: Expected O, but got Unknown
			//IL_2c02: Unknown result type (might be due to invalid IL or missing references)
			//IL_2c0e: Expected O, but got Unknown
			//IL_2c50: Unknown result type (might be due to invalid IL or missing references)
			//IL_2c5c: Expected O, but got Unknown
			//IL_2f2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_2f3a: Expected O, but got Unknown
			//IL_2f7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_2f88: Expected O, but got Unknown
			//IL_3149: Unknown result type (might be due to invalid IL or missing references)
			//IL_3155: Expected O, but got Unknown
			//IL_31ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_31f6: Expected O, but got Unknown
			//IL_328b: Unknown result type (might be due to invalid IL or missing references)
			//IL_3297: Expected O, but got Unknown
			//IL_3e17: Unknown result type (might be due to invalid IL or missing references)
			//IL_3e23: Unknown result type (might be due to invalid IL or missing references)
			//IL_3e2f: Expected O, but got Unknown
			//IL_3e2f: Expected O, but got Unknown
			//IL_40c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_40ce: Expected O, but got Unknown
			//IL_41e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_41f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_41ff: Expected O, but got Unknown
			//IL_41ff: Expected O, but got Unknown
			//IL_420d: Unknown result type (might be due to invalid IL or missing references)
			//IL_4218: Unknown result type (might be due to invalid IL or missing references)
			//IL_4225: Expected O, but got Unknown
			//IL_4225: Expected O, but got Unknown
			//IL_4233: Unknown result type (might be due to invalid IL or missing references)
			//IL_423e: Unknown result type (might be due to invalid IL or missing references)
			//IL_424b: Expected O, but got Unknown
			//IL_424b: Expected O, but got Unknown
			//IL_4259: Unknown result type (might be due to invalid IL or missing references)
			//IL_4264: Unknown result type (might be due to invalid IL or missing references)
			//IL_4271: Expected O, but got Unknown
			//IL_4271: Expected O, but got Unknown
			//IL_427f: Unknown result type (might be due to invalid IL or missing references)
			//IL_428a: Unknown result type (might be due to invalid IL or missing references)
			//IL_4297: Expected O, but got Unknown
			//IL_4297: Expected O, but got Unknown
			//IL_42a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_42b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_42bd: Expected O, but got Unknown
			//IL_42bd: Expected O, but got Unknown
			//IL_42cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_42d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_42e3: Expected O, but got Unknown
			//IL_42e3: Expected O, but got Unknown
			MethodInfo method = typeof(FVRFireArm).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method2 = typeof(FirePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method3 = typeof(FirePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method4 = typeof(FirePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method, new HarmonyMethod(method2), new HarmonyMethod(method4), new HarmonyMethod(method3), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Mod.LogError("Exception caught applying ActionPatches.FirePatch: " + ex.Message + ":\n" + ex.StackTrace);
			}
			patchIndex++;
			MethodInfo method5 = typeof(SosigWeapon).GetMethod("FireGun", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method6 = typeof(FireSosigWeaponPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method7 = typeof(FireSosigWeaponPatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method8 = typeof(FireSosigWeaponPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method5, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method5, new HarmonyMethod(method6), new HarmonyMethod(method8), new HarmonyMethod(method7), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex2)
			{
				Mod.LogError("Exception caught applying ActionPatches.FireSosigWeaponPatch: " + ex2.Message + ":\n" + ex2.StackTrace);
			}
			patchIndex++;
			MethodInfo method9 = typeof(LAPD2019).GetMethod("Fire", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method10 = typeof(FireLAPD2019Patch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method11 = typeof(FireLAPD2019Patch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method12 = typeof(FireLAPD2019Patch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method9, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method9, new HarmonyMethod(method10), new HarmonyMethod(method12), new HarmonyMethod(method11), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex3)
			{
				Mod.LogError("Exception caught applying ActionPatches.FireLAPD2019Patch: " + ex3.Message + ":\n" + ex3.StackTrace);
			}
			patchIndex++;
			MethodInfo method13 = typeof(AttachableFirearm).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method14 = typeof(FireAttachableFirearmPatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method15 = typeof(AttachableBreakActions).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(bool) }, null);
			MethodInfo method16 = typeof(FireAttachableFirearmPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method17 = typeof(FireAttachableFirearmPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method18 = typeof(AttachableClosedBoltWeapon).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(bool) }, null);
			MethodInfo method19 = typeof(FireAttachableFirearmPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method20 = typeof(FireAttachableFirearmPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method21 = typeof(AttachableTubeFed).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(bool) }, null);
			MethodInfo method22 = typeof(FireAttachableFirearmPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method23 = typeof(FireAttachableFirearmPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method24 = typeof(GP25).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(bool) }, null);
			MethodInfo method25 = typeof(FireAttachableFirearmPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method26 = typeof(FireAttachableFirearmPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method27 = typeof(M203).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(bool) }, null);
			MethodInfo method28 = typeof(FireAttachableFirearmPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method29 = typeof(FireAttachableFirearmPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method13, harmony, breaking: false);
			PatchController.Verify(method15, harmony, breaking: false);
			PatchController.Verify(method18, harmony, breaking: false);
			PatchController.Verify(method21, harmony, breaking: false);
			PatchController.Verify(method24, harmony, breaking: false);
			PatchController.Verify(method27, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method13, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method14), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex4)
			{
				Mod.LogError("Exception caught applying ActionPatches.FireAttachableFirearmPatch: " + ex4.Message + ":\n" + ex4.StackTrace);
			}
			harmony.Patch((MethodBase)method15, new HarmonyMethod(method16), new HarmonyMethod(method17), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method18, new HarmonyMethod(method19), new HarmonyMethod(method20), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method21, new HarmonyMethod(method22), new HarmonyMethod(method23), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method24, new HarmonyMethod(method25), new HarmonyMethod(method26), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method27, new HarmonyMethod(method28), new HarmonyMethod(method29), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method30 = typeof(RevolvingShotgun).GetMethod("Fire", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method31 = typeof(FireRevolvingShotgunPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method32 = typeof(FireRevolvingShotgunPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method30, harmony, breaking: false);
			harmony.Patch((MethodBase)method30, new HarmonyMethod(method31), new HarmonyMethod(method32), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method33 = typeof(Revolver).GetMethod("Fire", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method34 = typeof(FireRevolverPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method35 = typeof(FireRevolverPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method33, harmony, breaking: false);
			harmony.Patch((MethodBase)method33, new HarmonyMethod(method34), new HarmonyMethod(method35), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method36 = typeof(SingleActionRevolver).GetMethod("Fire", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method37 = typeof(FireSingleActionRevolverPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method38 = typeof(FireSingleActionRevolverPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method36, harmony, breaking: false);
			harmony.Patch((MethodBase)method36, new HarmonyMethod(method37), new HarmonyMethod(method38), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method39 = typeof(GrappleGun).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[0], null);
			MethodInfo method40 = typeof(FireGrappleGunPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method41 = typeof(FireGrappleGunPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method39, harmony, breaking: false);
			harmony.Patch((MethodBase)method39, new HarmonyMethod(method40), new HarmonyMethod(method41), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method42 = typeof(Derringer).GetMethod("FireBarrel", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method43 = typeof(FireDerringerPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method44 = typeof(FireDerringerPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method42, harmony, breaking: false);
			harmony.Patch((MethodBase)method42, new HarmonyMethod(method43), new HarmonyMethod(method44), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method45 = typeof(BreakActionWeapon).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[3]
			{
				typeof(int),
				typeof(bool),
				typeof(int)
			}, null);
			MethodInfo method46 = typeof(FireBreakActionWeaponPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method47 = typeof(FireBreakActionWeaponPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method45, harmony, breaking: false);
			harmony.Patch((MethodBase)method45, new HarmonyMethod(method46), new HarmonyMethod(method47), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method48 = typeof(LeverActionFirearm).GetMethod("Fire", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method49 = typeof(FireLeverActionFirearmPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method50 = typeof(FireLeverActionFirearmPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method48, harmony, breaking: false);
			harmony.Patch((MethodBase)method48, new HarmonyMethod(method49), new HarmonyMethod(method50), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method51 = typeof(FlintlockBarrel).GetMethod("BurnOffOuter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method52 = typeof(FireFlintlockWeaponPatch).GetMethod("BurnOffOuterPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method53 = typeof(FireFlintlockWeaponPatch).GetMethod("BurnOffOuterTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method54 = typeof(FireFlintlockWeaponPatch).GetMethod("BurnOffOuterPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method55 = typeof(FlintlockBarrel).GetMethod("Fire", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method56 = typeof(FireFlintlockWeaponPatch).GetMethod("FirePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method57 = typeof(FireFlintlockWeaponPatch).GetMethod("FireTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method58 = typeof(FireFlintlockWeaponPatch).GetMethod("FirePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method51, harmony, breaking: false);
			PatchController.Verify(method55, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method51, new HarmonyMethod(method52), new HarmonyMethod(method54), new HarmonyMethod(method53), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex5)
			{
				Mod.LogError("Exception caught applying ActionPatches.FireFlintlockWeaponPatch to fireFlintlockWeaponPatchBurnOffOuterOriginal: " + ex5.Message + ":\n" + ex5.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method55, new HarmonyMethod(method56), new HarmonyMethod(method58), new HarmonyMethod(method57), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex6)
			{
				Mod.LogError("Exception caught applying ActionPatches.FireFlintlockWeaponPatch to fireFlintlockWeaponFireOriginal: " + ex6.Message + ":\n" + ex6.StackTrace);
			}
			patchIndex++;
			MethodInfo method59 = typeof(HCB).GetMethod("ReleaseSled", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method60 = typeof(FireHCBPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method61 = typeof(FireHCBPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method59, harmony, breaking: false);
			harmony.Patch((MethodBase)method59, new HarmonyMethod(method60), new HarmonyMethod(method61), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method62 = typeof(SimpleLauncher).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method63 = typeof(SimpleLauncherPatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method64 = typeof(SimpleLauncherFireOnDamage).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method65 = typeof(SimpleLauncherPatch).GetMethod("DamagePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method62, harmony, breaking: false);
			PatchController.Verify(method64, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method62, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method63), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex7)
			{
				Mod.LogError("Exception caught applying ActionPatches.SimpleLauncherPatch: " + ex7.Message + ":\n" + ex7.StackTrace);
			}
			harmony.Patch((MethodBase)method64, new HarmonyMethod(method65), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method66 = typeof(StingerLauncher).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[0], null);
			MethodInfo method67 = typeof(FireStingerLauncherPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method68 = typeof(FireStingerLauncherPatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method69 = typeof(FireStingerLauncherPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method70 = typeof(StingerMissile).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(AIEntity) }, null);
			MethodInfo method71 = typeof(FireStingerLauncherPatch).GetMethod("MissileFirePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method66, harmony, breaking: false);
			PatchController.Verify(method70, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method66, new HarmonyMethod(method67), new HarmonyMethod(method69), new HarmonyMethod(method68), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex8)
			{
				Mod.LogError("Exception caught applying ActionPatches.FireStingerLauncherPatch: " + ex8.Message + ":\n" + ex8.StackTrace);
			}
			harmony.Patch((MethodBase)method70, new HarmonyMethod(method71), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method72 = typeof(RemoteMissile).GetMethod("Detonante", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method73 = typeof(RemoteMissileDetonatePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method72, harmony, breaking: false);
			harmony.Patch((MethodBase)method72, new HarmonyMethod(method73), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method74 = typeof(StingerMissile).GetMethod("Explode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method75 = typeof(StingerMissileExplodePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method74, harmony, breaking: false);
			harmony.Patch((MethodBase)method74, new HarmonyMethod(method75), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method76 = typeof(SosigWeapon).GetMethod("Shatter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method77 = typeof(SosigWeaponShatterPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method76, harmony, breaking: false);
			harmony.Patch((MethodBase)method76, new HarmonyMethod(method77), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method78 = typeof(Sosig).GetMethod("Configure", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method79 = typeof(SosigConfigurePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method78, harmony, breaking: false);
			harmony.Patch((MethodBase)method78, new HarmonyMethod(method79), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method80 = typeof(Sosig).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method81 = typeof(SosigUpdatePatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method82 = typeof(Sosig).GetMethod("HandPhysUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method83 = typeof(SosigUpdatePatch).GetMethod("HandPhysUpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method80, harmony, breaking: true);
			harmony.Patch((MethodBase)method80, new HarmonyMethod(method81), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method82, new HarmonyMethod(method83), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method84 = typeof(SosigInventory).GetMethod("PhysHold", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method85 = typeof(SosigInvUpdatePatch).GetMethod("PhysHoldPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method84, harmony, breaking: false);
			harmony.Patch((MethodBase)method84, new HarmonyMethod(method85), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method86 = typeof(Sosig).GetMethod("SosigDies", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method87 = typeof(SosigPatch).GetMethod("SosigDiesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method88 = typeof(SosigPatch).GetMethod("SosigDiesPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method89 = typeof(Sosig).GetMethod("SetBodyState", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method90 = typeof(SosigPatch).GetMethod("SetBodyStatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method91 = typeof(Sosig).GetMethod("BodyUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method92 = typeof(SosigPatch).GetMethod("FootStepTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method93 = typeof(Sosig).GetMethod("SpeechUpdate_State", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method94 = typeof(SosigPatch).GetMethod("SpeechUpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method95 = typeof(Sosig).GetMethod("SetCurrentOrder", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method96 = typeof(SosigPatch).GetMethod("SetCurrentOrderPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method97 = typeof(Sosig).GetMethod("Vaporize", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method98 = typeof(SosigPatch).GetMethod("SosigVaporizePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method99 = typeof(SosigPatch).GetMethod("SosigVaporizePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method100 = typeof(Sosig).GetMethod("RequestHitDecal", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[4]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(float),
				typeof(SosigLink)
			}, null);
			MethodInfo method101 = typeof(SosigPatch).GetMethod("RequestHitDecalPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method102 = typeof(Sosig).GetMethod("RequestHitDecal", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[5]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(Vector3),
				typeof(float),
				typeof(SosigLink)
			}, null);
			MethodInfo method103 = typeof(SosigPatch).GetMethod("RequestHitDecalEdgePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method104 = typeof(Sosig).GetMethod("CommandGuardPoint", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method105 = typeof(SosigPatch).GetMethod("CommandGuardPointPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method106 = typeof(SosigPatch).GetMethod("CommandGuardPointPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method107 = typeof(Sosig).GetMethod("CommandAssaultPoint", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method108 = typeof(SosigPatch).GetMethod("CommandAssaultPointPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method109 = typeof(SosigPatch).GetMethod("CommandAssaultPointPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method110 = typeof(Sosig).GetMethod("CommandIdle", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method111 = typeof(SosigPatch).GetMethod("CommandIdlePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method112 = typeof(SosigPatch).GetMethod("CommandIdlePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method113 = typeof(Sosig).GetMethod("CommandPathTo", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[11]
			{
				typeof(List<Transform>),
				typeof(float),
				typeof(Vector2),
				typeof(float),
				typeof(SosigMoveSpeed),
				typeof(PathLoopType),
				typeof(List<Sosig>),
				typeof(float),
				typeof(float),
				typeof(bool),
				typeof(float)
			}, null);
			MethodInfo method114 = typeof(Sosig).GetMethod("CommandPathTo", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[12]
			{
				typeof(List<Vector3>),
				typeof(List<Vector3>),
				typeof(float),
				typeof(Vector2),
				typeof(float),
				typeof(SosigMoveSpeed),
				typeof(PathLoopType),
				typeof(List<Sosig>),
				typeof(float),
				typeof(float),
				typeof(bool),
				typeof(float)
			}, null);
			MethodInfo method115 = typeof(SosigPatch).GetMethod("CommandPathToPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method116 = typeof(Sosig).GetMethod("ProcessCollision", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method117 = typeof(SosigPatch).GetMethod("ProcessCollisionPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method86, harmony, breaking: false);
			PatchController.Verify(method89, harmony, breaking: false);
			PatchController.Verify(method91, harmony, breaking: true);
			PatchController.Verify(method93, harmony, breaking: false);
			PatchController.Verify(method95, harmony, breaking: false);
			PatchController.Verify(method100, harmony, breaking: false);
			PatchController.Verify(method102, harmony, breaking: false);
			PatchController.Verify(method104, harmony, breaking: false);
			PatchController.Verify(method107, harmony, breaking: false);
			PatchController.Verify(method113, harmony, breaking: false);
			PatchController.Verify(method114, harmony, breaking: false);
			PatchController.Verify(method116, harmony, breaking: false);
			harmony.Patch((MethodBase)method86, new HarmonyMethod(method87), new HarmonyMethod(method88), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method89, new HarmonyMethod(method90), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			try
			{
				harmony.Patch((MethodBase)method91, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method92), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex9)
			{
				Mod.LogError("Exception caught applying ActionPatches.SosigActionPatch to sosigBodyUpdatePatchOriginal: " + ex9.Message + ":\n" + ex9.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method93, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method94), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex10)
			{
				Mod.LogError("Exception caught applying ActionPatches.SosigActionPatch to sosigSpeechUpdatePatchOriginal: " + ex10.Message + ":\n" + ex10.StackTrace);
			}
			harmony.Patch((MethodBase)method95, new HarmonyMethod(method96), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method100, new HarmonyMethod(method101), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method102, new HarmonyMethod(method103), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method104, new HarmonyMethod(method105), new HarmonyMethod(method106), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method107, new HarmonyMethod(method108), new HarmonyMethod(method109), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method113, (HarmonyMethod)null, new HarmonyMethod(method115), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method114, (HarmonyMethod)null, new HarmonyMethod(method115), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method116, new HarmonyMethod(method117), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method118 = typeof(SosigLink).GetMethod("RegisterWearable", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method119 = typeof(SosigLinkActionPatch).GetMethod("RegisterWearablePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method120 = typeof(SosigLink).GetMethod("DeRegisterWearable", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method121 = typeof(SosigLinkActionPatch).GetMethod("DeRegisterWearablePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method122 = typeof(SosigLink).GetMethod("LinkExplodes", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method123 = typeof(SosigLinkActionPatch).GetMethod("LinkExplodesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method124 = typeof(SosigLinkActionPatch).GetMethod("LinkExplodesPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method125 = typeof(SosigLink).GetMethod("BreakJoint", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method126 = typeof(SosigLinkActionPatch).GetMethod("LinkBreakPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method127 = typeof(SosigLinkActionPatch).GetMethod("LinkBreakPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method128 = typeof(SosigLink).GetMethod("SeverJoint", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method129 = typeof(SosigLinkActionPatch).GetMethod("LinkSeverPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method130 = typeof(SosigLinkActionPatch).GetMethod("LinkSeverPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method131 = typeof(SosigLink).GetMethod("Vaporize", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method132 = typeof(SosigLinkActionPatch).GetMethod("LinkVaporizePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method133 = typeof(SosigLinkActionPatch).GetMethod("LinkVaporizePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method118, harmony, breaking: false);
			PatchController.Verify(method120, harmony, breaking: false);
			PatchController.Verify(method125, harmony, breaking: false);
			harmony.Patch((MethodBase)method118, new HarmonyMethod(method119), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method120, new HarmonyMethod(method121), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method125, new HarmonyMethod(method126), new HarmonyMethod(method127), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method134 = typeof(Sosig).GetMethod("SetIFF", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method135 = typeof(SosigIFFPatch).GetMethod("SetIFFPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method136 = typeof(Sosig).GetMethod("SetOriginalIFFTeam", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method137 = typeof(SosigIFFPatch).GetMethod("SetOriginalIFFPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method134, harmony, breaking: false);
			PatchController.Verify(method136, harmony, breaking: false);
			harmony.Patch((MethodBase)method134, new HarmonyMethod(method135), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method136, new HarmonyMethod(method137), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method138 = typeof(Sosig).GetMethod("EventReceive", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method139 = typeof(SosigEventReceivePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method138, harmony, breaking: false);
			harmony.Patch((MethodBase)method138, new HarmonyMethod(method139), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method140 = typeof(AutoMeater).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method141 = typeof(AutoMeater).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method142 = typeof(AutoMeaterUpdatePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method140, harmony, breaking: false);
			harmony.Patch((MethodBase)method140, new HarmonyMethod(method142), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method141, new HarmonyMethod(method142), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method143 = typeof(AutoMeater).GetMethod("EventReceive", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method144 = typeof(AutoMeaterEventPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method143, harmony, breaking: false);
			harmony.Patch((MethodBase)method143, new HarmonyMethod(method144), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method145 = typeof(LAPD2019).GetMethod("LoadBattery", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method146 = typeof(LAPD2019ActionPatch).GetMethod("LoadBatteryPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method147 = typeof(LAPD2019).GetMethod("ExtractBattery", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method148 = typeof(LAPD2019ActionPatch).GetMethod("ExtractBatteryPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method145, harmony, breaking: false);
			PatchController.Verify(method147, harmony, breaking: false);
			harmony.Patch((MethodBase)method145, new HarmonyMethod(method146), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method147, new HarmonyMethod(method148), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method149 = typeof(AutoMeater).GetMethod("SetState", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method150 = typeof(AutoMeaterSetStatePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method149, harmony, breaking: false);
			harmony.Patch((MethodBase)method149, (HarmonyMethod)null, new HarmonyMethod(method150), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method151 = typeof(AutoMeater).GetMethod("UpdateFlight", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method152 = typeof(AutoMeaterUpdateFlightPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method153 = typeof(AutoMeaterUpdateFlightPatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method151, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method151, new HarmonyMethod(method152), (HarmonyMethod)null, new HarmonyMethod(method153), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex11)
			{
				Mod.LogError("Exception caught applying ActionPatches.AutoMeaterUpdateFlightPatch: " + ex11.Message + ":\n" + ex11.StackTrace);
			}
			patchIndex++;
			MethodInfo method154 = typeof(AutoMeaterFirearm).GetMethod("FireShot", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method155 = typeof(AutoMeaterFirearmFireShotPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method156 = typeof(AutoMeaterFirearmFireShotPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method157 = typeof(AutoMeaterFirearmFireShotPatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method154, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method154, new HarmonyMethod(method155), new HarmonyMethod(method156), new HarmonyMethod(method157), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex12)
			{
				Mod.LogError("Exception caught applying ActionPatches.AutoMeaterFirearmFireShotPatch: " + ex12.Message + ":\n" + ex12.StackTrace);
			}
			patchIndex++;
			MethodInfo method158 = typeof(AutoMeaterFirearm).GetMethod("SetFireAtWill", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method159 = typeof(AutoMeaterFirearmFireAtWillPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method158, harmony, breaking: false);
			harmony.Patch((MethodBase)method158, new HarmonyMethod(method159), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method160 = typeof(TNH_EncryptionTarget).GetMethod("RespawnRandomSubTarg", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method161 = typeof(EncryptionRespawnRandSubPatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method160, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method160, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method161), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex13)
			{
				Mod.LogError("Exception caught applying ActionPatches.EncryptionRespawnRandSubPatch: " + ex13.Message + ":\n" + ex13.StackTrace);
			}
			patchIndex++;
			MethodInfo method162 = typeof(TNH_EncryptionTarget).GetMethod("ResetGrowth", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method163 = typeof(EncryptionResetGrowthPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method162, harmony, breaking: false);
			harmony.Patch((MethodBase)method162, new HarmonyMethod(method163), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method164 = typeof(TNH_EncryptionTarget).GetMethod("DisableSubtarg", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method165 = typeof(EncryptionDisableSubtargPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method166 = typeof(EncryptionDisableSubtargPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method164, harmony, breaking: false);
			harmony.Patch((MethodBase)method164, new HarmonyMethod(method165), new HarmonyMethod(method166), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method167 = typeof(SosigTargetPrioritySystem).GetMethod("SetDefaultIFFChart", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method168 = typeof(SosigTargetPrioritySystem).GetMethod("MakeEnemy", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method169 = typeof(SosigTargetPrioritySystem).GetMethod("MakeFriendly", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method170 = typeof(SosigTargetPrioritySystem).GetMethod("SetAllEnemy", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method171 = typeof(SosigTargetPrioritySystem).GetMethod("SetAllFriendly", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method172 = typeof(SosigTargetPrioritySystem).GetMethod("SetAllyMatrix", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method173 = typeof(SosigTargetPrioritySystemPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method167, harmony, breaking: false);
			PatchController.Verify(method168, harmony, breaking: false);
			PatchController.Verify(method169, harmony, breaking: false);
			PatchController.Verify(method170, harmony, breaking: false);
			PatchController.Verify(method171, harmony, breaking: false);
			PatchController.Verify(method172, harmony, breaking: false);
			harmony.Patch((MethodBase)method167, (HarmonyMethod)null, new HarmonyMethod(method173), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method168, (HarmonyMethod)null, new HarmonyMethod(method173), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method169, (HarmonyMethod)null, new HarmonyMethod(method173), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method170, (HarmonyMethod)null, new HarmonyMethod(method173), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method171, (HarmonyMethod)null, new HarmonyMethod(method173), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method172, (HarmonyMethod)null, new HarmonyMethod(method173), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method174 = typeof(SimpleLauncher2).GetMethod("CycleMode", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method175 = typeof(SimpleLauncher2CycleModePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method174, harmony, breaking: false);
			harmony.Patch((MethodBase)method174, new HarmonyMethod(method175), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method176 = typeof(PinnedGrenade).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method177 = typeof(PinnedGrenade).GetMethod("FVRFixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method178 = typeof(PinnedGrenadePatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method179 = typeof(PinnedGrenadePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method180 = typeof(PinnedGrenadePatch).GetMethod("UpdatePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method181 = typeof(PinnedGrenade).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method182 = typeof(PinnedGrenadePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method176, harmony, breaking: false);
			PatchController.Verify(method177, harmony, breaking: false);
			PatchController.Verify(method181, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method176, new HarmonyMethod(method178), new HarmonyMethod(method180), new HarmonyMethod(method179), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex14)
			{
				Mod.LogError("Exception caught applying ActionPatches.PinnedGrenadePatch on pinnedGrenadePatchUpdateOriginal: " + ex14.Message + ":\n" + ex14.StackTrace);
			}
			harmony.Patch((MethodBase)method177, new HarmonyMethod(method178), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			try
			{
				harmony.Patch((MethodBase)method181, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method182), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex15)
			{
				Mod.LogError("Exception caught applying ActionPatches.PinnedGrenadePatch on pinnedGrenadePatchCollisionOriginal: " + ex15.Message + ":\n" + ex15.StackTrace);
			}
			patchIndex++;
			MethodInfo method183 = typeof(FVRGrenade).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method184 = typeof(FVRGrenadePatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method185 = typeof(FVRGrenadePatch).GetMethod("UpdatePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method183, harmony, breaking: false);
			harmony.Patch((MethodBase)method183, new HarmonyMethod(method184), new HarmonyMethod(method185), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method186 = typeof(FVRFuse).GetMethod("Ignite", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method187 = typeof(FusePatch).GetMethod("IgnitePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method188 = typeof(FVRFuse).GetMethod("Boom", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method189 = typeof(FusePatch).GetMethod("BoomPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method186, harmony, breaking: false);
			PatchController.Verify(method188, harmony, breaking: false);
			harmony.Patch((MethodBase)method186, (HarmonyMethod)null, new HarmonyMethod(method187), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method188, new HarmonyMethod(method189), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method190 = typeof(Molotov).GetMethod("Shatter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method191 = typeof(MolotovPatch).GetMethod("ShatterPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method192 = typeof(Molotov).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method193 = typeof(MolotovPatch).GetMethod("DamagePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method190, harmony, breaking: false);
			PatchController.Verify(method192, harmony, breaking: false);
			harmony.Patch((MethodBase)method190, new HarmonyMethod(method191), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method192, new HarmonyMethod(method193), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method194 = typeof(TNH_EncryptionTarget).GetMethod("Update", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method195 = typeof(EncryptionPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method196 = typeof(EncryptionPatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method197 = typeof(TNH_EncryptionTarget).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method198 = typeof(EncryptionPatch).GetMethod("FixedUpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method199 = typeof(TNH_EncryptionTarget).GetMethod("Start", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method200 = typeof(EncryptionPatch).GetMethod("StartPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method201 = typeof(EncryptionPatch).GetMethod("StartPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method202 = typeof(TNH_EncryptionTarget).GetMethod("UpdateDisplay", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method203 = typeof(EncryptionPatch).GetMethod("UpdateDisplayPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method204 = typeof(TNH_EncryptionTarget).GetMethod("Destroy", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method205 = typeof(EncryptionPatch).GetMethod("DestroyTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method206 = typeof(TNH_EncryptionTarget).GetMethod("FireGun", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method207 = typeof(EncryptionPatch).GetMethod("FireGunPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method208 = typeof(TNH_EncryptionTarget).GetMethod("SetNextPos", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method209 = typeof(EncryptionPatch).GetMethod("SetNextPosPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method210 = typeof(TNH_EncryptionTarget).GetMethod("WarpToNextPosition", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method211 = typeof(EncryptionPatch).GetMethod("WarpToNextPositionPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method194, harmony, breaking: true);
			PatchController.Verify(method197, harmony, breaking: true);
			PatchController.Verify(method199, harmony, breaking: true);
			PatchController.Verify(method202, harmony, breaking: true);
			PatchController.Verify(method204, harmony, breaking: true);
			PatchController.Verify(method206, harmony, breaking: true);
			PatchController.Verify(method208, harmony, breaking: true);
			PatchController.Verify(method210, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method194, new HarmonyMethod(method195), (HarmonyMethod)null, new HarmonyMethod(method196), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex16)
			{
				Mod.LogError("Exception caught applying ActionPatches.EncryptionPatch on EncryptionPatchUpdateOriginal: " + ex16.Message + ":\n" + ex16.StackTrace);
			}
			harmony.Patch((MethodBase)method197, new HarmonyMethod(method198), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method199, new HarmonyMethod(method200), new HarmonyMethod(method201), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method202, (HarmonyMethod)null, new HarmonyMethod(method203), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			try
			{
				harmony.Patch((MethodBase)method204, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method205), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex17)
			{
				Mod.LogError("Exception caught applying ActionPatches.EncryptionPatch on EncryptionPatchDestroyOriginal: " + ex17.Message + ":\n" + ex17.StackTrace);
			}
			harmony.Patch((MethodBase)method206, new HarmonyMethod(method207), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method208, (HarmonyMethod)null, new HarmonyMethod(method209), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method210, (HarmonyMethod)null, new HarmonyMethod(method211), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method212 = typeof(BangSnap).GetMethod("Splode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method213 = typeof(BangSnapPatch).GetMethod("SplodePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method214 = typeof(BangSnap).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method215 = typeof(BangSnapPatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method212, harmony, breaking: false);
			PatchController.Verify(method214, harmony, breaking: false);
			harmony.Patch((MethodBase)method212, new HarmonyMethod(method213), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			try
			{
				harmony.Patch((MethodBase)method214, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method215), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex18)
			{
				Mod.LogError("Exception caught applying ActionPatches.BangSnapPatch: " + ex18.Message + ":\n" + ex18.StackTrace);
			}
			patchIndex++;
			MethodInfo method216 = typeof(C4).GetMethod("Detonate", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method217 = typeof(C4DetonatePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method216, harmony, breaking: false);
			harmony.Patch((MethodBase)method216, new HarmonyMethod(method217), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method218 = typeof(ClaymoreMine).GetMethod("Detonate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method219 = typeof(ClaymoreMineDetonatePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method218, harmony, breaking: false);
			harmony.Patch((MethodBase)method218, new HarmonyMethod(method219), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method220 = typeof(SLAM).GetMethod("Detonate", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method221 = typeof(SLAMDetonatePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method220, harmony, breaking: false);
			harmony.Patch((MethodBase)method220, new HarmonyMethod(method221), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method222 = typeof(FVRFireArmRound).GetMethod("FVRFixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method223 = typeof(RoundPatch).GetMethod("FixedUpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method224 = typeof(FVRFireArmRound).GetMethod("Splode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method225 = typeof(RoundPatch).GetMethod("SplodePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method222, harmony, breaking: false);
			PatchController.Verify(method224, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method222, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method223), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex19)
			{
				Mod.LogError("Exception caught applying ActionPatches.RoundPatch: " + ex19.Message + ":\n" + ex19.StackTrace);
			}
			harmony.Patch((MethodBase)method224, new HarmonyMethod(method225), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method226 = typeof(FVRFireArmMagazine).GetMethod("AddRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[3]
			{
				typeof(FireArmRoundClass),
				typeof(bool),
				typeof(bool)
			}, null);
			MethodInfo method227 = typeof(MagazinePatch).GetMethod("AddRoundClassTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method228 = typeof(FVRFireArmMagazine).GetMethod("AddRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[4]
			{
				typeof(FVRFireArmRound),
				typeof(bool),
				typeof(bool),
				typeof(bool)
			}, null);
			MethodInfo method229 = typeof(MagazinePatch).GetMethod("AddRoundRoundTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method230 = typeof(FVRFireArmMagazine).GetMethod("Load", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(FVRFireArm) }, null);
			MethodInfo method231 = typeof(MagazinePatch).GetMethod("LoadFireArmPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method232 = typeof(FVRFireArmMagazine).GetMethod("LoadIntoSecondary", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method233 = typeof(MagazinePatch).GetMethod("LoadIntoSecondaryPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method234 = typeof(FVRFireArmMagazine).GetMethod("Load", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(AttachableFirearm) }, null);
			MethodInfo method235 = typeof(MagazinePatch).GetMethod("LoadAttachablePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method226, harmony, breaking: false);
			PatchController.Verify(method228, harmony, breaking: false);
			PatchController.Verify(method230, harmony, breaking: false);
			PatchController.Verify(method232, harmony, breaking: false);
			PatchController.Verify(method234, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method226, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method227), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex20)
			{
				Mod.LogError("Exception caught applying ActionPatches.MagazinePatch on magAddRoundClassOriginal: " + ex20.Message + ":\n" + ex20.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method228, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method229), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex21)
			{
				Mod.LogError("Exception caught applying ActionPatches.MagazinePatch on magAddRoundRoundOriginal: " + ex21.Message + ":\n" + ex21.StackTrace);
			}
			harmony.Patch((MethodBase)method230, new HarmonyMethod(method231), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method232, new HarmonyMethod(method233), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method234, new HarmonyMethod(method235), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method236 = typeof(FVRFireArmClip).GetMethod("AddRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[3]
			{
				typeof(FireArmRoundClass),
				typeof(bool),
				typeof(bool)
			}, null);
			MethodInfo method237 = typeof(ClipPatch).GetMethod("AddRoundClassTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method238 = typeof(FVRFireArmClip).GetMethod("AddRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[3]
			{
				typeof(FVRFireArmRound),
				typeof(bool),
				typeof(bool)
			}, null);
			MethodInfo method239 = typeof(ClipPatch).GetMethod("AddRoundRoundTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method240 = typeof(FVRFireArmClip).GetMethod("Load", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method241 = typeof(ClipPatch).GetMethod("LoadPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method236, harmony, breaking: false);
			PatchController.Verify(method238, harmony, breaking: false);
			PatchController.Verify(method240, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method236, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method237), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex22)
			{
				Mod.LogError("Exception caught applying ActionPatches.ClipPatch on clipAddRoundClassOriginal: " + ex22.Message + ":\n" + ex22.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method238, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method239), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex23)
			{
				Mod.LogError("Exception caught applying ActionPatches.ClipPatch on clipAddRoundRoundOriginal: " + ex23.Message + ":\n" + ex23.StackTrace);
			}
			harmony.Patch((MethodBase)method240, new HarmonyMethod(method241), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method242 = typeof(SpeedloaderChamber).GetMethod("Load", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method243 = typeof(SpeedloaderChamberPatch).GetMethod("AddRoundPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method242, harmony, breaking: false);
			harmony.Patch((MethodBase)method242, new HarmonyMethod(method243), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method244 = typeof(RemoteGun).GetMethod("ChamberCartridge", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method245 = typeof(RemoteGunPatch).GetMethod("ChamberCartridgePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method244, harmony, breaking: false);
			harmony.Patch((MethodBase)method244, new HarmonyMethod(method245), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method246 = typeof(FVRFireArmChamber).GetMethod("SetRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[3]
			{
				typeof(FireArmRoundClass),
				typeof(Vector3),
				typeof(Quaternion)
			}, null);
			MethodInfo method247 = typeof(ChamberPatch).GetMethod("SetRoundClassPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method248 = typeof(FVRFireArmChamber).GetMethod("SetRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[3]
			{
				typeof(FVRFireArmRound),
				typeof(Vector3),
				typeof(Quaternion)
			}, null);
			MethodInfo method249 = typeof(FVRFireArmChamber).GetMethod("SetRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[2]
			{
				typeof(FVRFireArmRound),
				typeof(bool)
			}, null);
			MethodInfo method250 = typeof(ChamberPatch).GetMethod("SetRoundRoundPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method246, harmony, breaking: false);
			PatchController.Verify(method248, harmony, breaking: false);
			PatchController.Verify(method249, harmony, breaking: false);
			harmony.Patch((MethodBase)method246, new HarmonyMethod(method247), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method248, new HarmonyMethod(method250), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method249, new HarmonyMethod(method250), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method251 = typeof(Speedloader).GetMethod("FVRFixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method252 = typeof(SpeedloaderPatch).GetMethod("FixedUpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method253 = typeof(Speedloader).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method254 = typeof(SpeedloaderPatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method251, harmony, breaking: false);
			PatchController.Verify(method253, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method251, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method252), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex24)
			{
				Mod.LogError("Exception caught applying ActionPatches.SpeedloaderPatch on speedLoaderFixedUpdateOriginal: " + ex24.Message + ":\n" + ex24.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method253, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method254), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex25)
			{
				Mod.LogError("Exception caught applying ActionPatches.SpeedloaderPatch on speedLoaderUpdateOriginal: " + ex25.Message + ":\n" + ex25.StackTrace);
			}
			patchIndex++;
			MethodInfo method255 = typeof(RevolverCylinder).GetMethod("LoadFromSpeedLoader", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method256 = typeof(RevolverCylinderPatch).GetMethod("LoadFromSpeedLoaderPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method255, harmony, breaking: false);
			harmony.Patch((MethodBase)method255, new HarmonyMethod(method256), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method257 = typeof(RevolvingShotgun).GetMethod("LoadCylinder", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method258 = typeof(RevolvingShotgunPatch).GetMethod("LoadCylinderPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method257, harmony, breaking: false);
			harmony.Patch((MethodBase)method257, new HarmonyMethod(method258), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method259 = typeof(GrappleGun).GetMethod("LoadCylinder", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method260 = typeof(GrappleGunPatch).GetMethod("LoadCylinderPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method259, harmony, breaking: false);
			harmony.Patch((MethodBase)method259, new HarmonyMethod(method260), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method261 = typeof(CarlGustafLatch).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method262 = typeof(CarlGustafLatchPatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method261, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method261, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method262), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex26)
			{
				Mod.LogError("Exception caught applying ActionPatches.CarlGustafLatchPatch: " + ex26.Message + ":\n" + ex26.StackTrace);
			}
			patchIndex++;
			MethodInfo method263 = typeof(CarlGustafShellInsertEject).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method264 = typeof(CarlGustafShellInsertEjectPatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method263, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method263, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method264), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex27)
			{
				Mod.LogError("Exception caught applying ActionPatches.CarlGustafShellInsertEjectPatch: " + ex27.Message + ":\n" + ex27.StackTrace);
			}
			patchIndex++;
			MethodInfo method265 = typeof(GrappleThrowable).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method266 = typeof(GrappleThrowablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method265, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method265, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method266), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex28)
			{
				Mod.LogError("Exception caught applying ActionPatches.GrappleThrowablePatch: " + ex28.Message + ":\n" + ex28.StackTrace);
			}
			patchIndex++;
			MethodInfo method267 = typeof(TNH_EncryptionTarget).GetMethod("SpawnGrowth", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method268 = typeof(EncryptionSpawnGrowthPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method267, harmony, breaking: false);
			harmony.Patch((MethodBase)method267, new HarmonyMethod(method268), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method269 = typeof(FVRFireArm).GetMethod("Awake", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method270 = typeof(FireArmPatch).GetMethod("AwakePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method271 = typeof(FVRFireArm).GetMethod("PlayAudioGunShot", BindingFlags.Instance | BindingFlags.Public, null, new Type[3]
			{
				typeof(FVRFireArmRound),
				typeof(FVRSoundEnvironment),
				typeof(float)
			}, null);
			MethodInfo method272 = typeof(FireArmPatch).GetMethod("PlayAudioGunShotRoundPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method273 = typeof(FVRFireArm).GetMethod("PlayAudioGunShot", BindingFlags.Instance | BindingFlags.Public, null, new Type[4]
			{
				typeof(bool),
				typeof(FVRTailSoundClass),
				typeof(FVRTailSoundClass),
				typeof(FVRSoundEnvironment)
			}, null);
			MethodInfo method274 = typeof(FireArmPatch).GetMethod("PlayAudioGunShotBoolPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method269, harmony, breaking: false);
			PatchController.Verify(method271, harmony, breaking: false);
			PatchController.Verify(method273, harmony, breaking: false);
			harmony.Patch((MethodBase)method269, (HarmonyMethod)null, new HarmonyMethod(method270), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method271, new HarmonyMethod(method272), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method273, new HarmonyMethod(method274), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method275 = typeof(SteelPopTarget).GetMethod("Start", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method276 = typeof(SteelPopTargetPatch).GetMethod("StartPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method275, harmony, breaking: false);
			harmony.Patch((MethodBase)method275, (HarmonyMethod)null, new HarmonyMethod(method276), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method277 = typeof(FlameThrower).GetMethod("UpdateControls", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method278 = typeof(FlameThrowerPatch).GetMethod("UpdateControlsPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method277, harmony, breaking: false);
			harmony.Patch((MethodBase)method277, new HarmonyMethod(method278), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method279 = typeof(AR15HandleSightFlipper).GetMethod("SimpleInteraction", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method280 = typeof(AR15SightFlipperPatch).GetMethod("InteractPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method279, harmony, breaking: false);
			harmony.Patch((MethodBase)method279, (HarmonyMethod)null, new HarmonyMethod(method280), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method281 = typeof(AR15HandleSightRaiser).GetMethod("SimpleInteraction", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method282 = typeof(AR15SightRaiserPatch).GetMethod("InteractPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method281, harmony, breaking: false);
			harmony.Patch((MethodBase)method281, (HarmonyMethod)null, new HarmonyMethod(method282), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method283 = typeof(wwGatlingGun).GetMethod("FireShot", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method284 = typeof(GatlingGunPatch).GetMethod("FireShotPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method283, harmony, breaking: false);
			harmony.Patch((MethodBase)method283, (HarmonyMethod)null, new HarmonyMethod(method284), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method285 = typeof(Brut_GasCuboid).GetMethod("GenerateGout", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method286 = typeof(GasCuboidPatch).GetMethod("GenerateGoutPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method287 = typeof(Brut_GasCuboid).GetMethod("DamageHandle", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method288 = typeof(GasCuboidPatch).GetMethod("DamageHandlePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method289 = typeof(Brut_GasCuboid).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method290 = typeof(Brut_GasCuboid).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method291 = typeof(GasCuboidPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method292 = typeof(Brut_GasCuboid).GetMethod("Explode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method293 = typeof(GasCuboidPatch).GetMethod("ExplodePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method294 = typeof(GasCuboidPatch).GetMethod("ExplodePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method285, harmony, breaking: false);
			PatchController.Verify(method287, harmony, breaking: false);
			PatchController.Verify(method289, harmony, breaking: false);
			PatchController.Verify(method290, harmony, breaking: false);
			PatchController.Verify(method292, harmony, breaking: false);
			harmony.Patch((MethodBase)method285, new HarmonyMethod(method286), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method287, new HarmonyMethod(method288), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method289, new HarmonyMethod(method291), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method290, new HarmonyMethod(method291), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method292, new HarmonyMethod(method293), new HarmonyMethod(method294), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method295 = typeof(Construct_Floater).GetMethod("BeginExploding", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method296 = typeof(FloaterPatch).GetMethod("BeginExplodingPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method297 = typeof(Construct_Floater).GetMethod("BeginDefusing", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method298 = typeof(FloaterPatch).GetMethod("BeginDefusingPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method299 = typeof(Construct_Floater).GetMethod("Explode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method300 = typeof(FloaterPatch).GetMethod("ExplodePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method301 = typeof(Construct_Floater).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method302 = typeof(FloaterPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method303 = typeof(Construct_Floater).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method304 = typeof(FloaterPatch).GetMethod("FixedUpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method295, harmony, breaking: false);
			PatchController.Verify(method297, harmony, breaking: false);
			PatchController.Verify(method299, harmony, breaking: false);
			PatchController.Verify(method301, harmony, breaking: false);
			PatchController.Verify(method303, harmony, breaking: false);
			harmony.Patch((MethodBase)method295, new HarmonyMethod(method296), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method297, new HarmonyMethod(method298), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method299, new HarmonyMethod(method300), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method301, new HarmonyMethod(method302), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method303, new HarmonyMethod(method304), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method305 = typeof(Construct_Iris).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method306 = typeof(IrisPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method307 = typeof(Construct_Iris).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method308 = typeof(IrisPatch).GetMethod("FixedUpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method309 = typeof(Construct_Iris).GetMethod("SetState", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method310 = typeof(IrisPatch).GetMethod("SetStatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method305, harmony, breaking: false);
			PatchController.Verify(method309, harmony, breaking: false);
			PatchController.Verify(method307, harmony, breaking: false);
			harmony.Patch((MethodBase)method305, new HarmonyMethod(method306), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method307, new HarmonyMethod(method308), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method309, new HarmonyMethod(method310), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method311 = typeof(BrutBlockSystem).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method312 = typeof(BrutBlockSystemPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method313 = typeof(BrutBlockSystem).GetMethod("TryToStartBlock", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method314 = typeof(BrutBlockSystemPatch).GetMethod("TryToStartBlockPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method311, harmony, breaking: false);
			PatchController.Verify(method313, harmony, breaking: false);
			harmony.Patch((MethodBase)method311, new HarmonyMethod(method312), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method313, new HarmonyMethod(method314), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method315 = typeof(Construct_Node).GetMethod("Init", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method316 = typeof(NodePatch).GetMethod("InitPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method317 = typeof(NodePatch).GetMethod("InitPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method318 = typeof(Construct_Node).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method319 = typeof(NodePatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method320 = typeof(Construct_Node).GetMethod("FVRFixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method321 = typeof(NodePatch).GetMethod("FixedUpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method322 = typeof(NodePatch).GetMethod("FixedUpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method315, harmony, breaking: false);
			PatchController.Verify(method318, harmony, breaking: false);
			PatchController.Verify(method320, harmony, breaking: false);
			harmony.Patch((MethodBase)method315, new HarmonyMethod(method316), new HarmonyMethod(method317), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method318, new HarmonyMethod(method319), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			try
			{
				harmony.Patch((MethodBase)method320, new HarmonyMethod(method321), (HarmonyMethod)null, new HarmonyMethod(method322), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex29)
			{
				Mod.LogError("Exception caught applying ActionPatches.NodePatch: " + ex29.Message + ":\n" + ex29.StackTrace);
			}
			patchIndex++;
			MethodInfo method323 = typeof(Construct_Haze).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method324 = typeof(HazePatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method325 = typeof(Construct_Haze).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method326 = typeof(HazePatch).GetMethod("FixedUpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method323, harmony, breaking: false);
			PatchController.Verify(method325, harmony, breaking: false);
			harmony.Patch((MethodBase)method323, new HarmonyMethod(method324), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method325, new HarmonyMethod(method326), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method327 = typeof(Construct_Sentinel).GetMethod("Awake", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method328 = typeof(SentinelPatch).GetMethod("AwakePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method329 = typeof(Construct_Sentinel).GetMethod("Init", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method330 = typeof(SentinelPatch).GetMethod("InitPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method331 = typeof(Construct_Sentinel).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method332 = typeof(SentinelPatch).GetMethod("FixedUpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method329, harmony, breaking: false);
			PatchController.Verify(method327, harmony, breaking: false);
			PatchController.Verify(method331, harmony, breaking: false);
			harmony.Patch((MethodBase)method329, (HarmonyMethod)null, new HarmonyMethod(method330), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method327, new HarmonyMethod(method328), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method331, new HarmonyMethod(method332), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			if (PatchController.MWAsmIdx != -1)
			{
				MethodInfo mW_ModularWeaponPart_EnablePart = PatchController.MW_ModularWeaponPart_EnablePart;
				MethodInfo method333 = typeof(ModularWeaponPartPatch).GetMethod("EnablePrefix", BindingFlags.Static | BindingFlags.NonPublic);
				PatchController.Verify(mW_ModularWeaponPart_EnablePart, harmony, breaking: true);
				harmony.Patch((MethodBase)mW_ModularWeaponPart_EnablePart, new HarmonyMethod(method333), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			patchIndex++;
			if (PatchController.MWAsmIdx != -1)
			{
				MethodInfo mW_ModularBoltActionRifle_ApplySkin = PatchController.MW_ModularBoltActionRifle_ApplySkin;
				MethodInfo mW_ModularBreakActionWeapon_ApplySkin = PatchController.MW_ModularBreakActionWeapon_ApplySkin;
				MethodInfo mW_ModularClosedBoltWeapon_ApplySkin = PatchController.MW_ModularClosedBoltWeapon_ApplySkin;
				MethodInfo mW_ModularHandgun_ApplySkin = PatchController.MW_ModularHandgun_ApplySkin;
				MethodInfo mW_ModularOpenBoltReceiver_ApplySkin = PatchController.MW_ModularOpenBoltReceiver_ApplySkin;
				MethodInfo mW_ModularRevolver_ApplySkin = PatchController.MW_ModularRevolver_ApplySkin;
				MethodInfo mW_ModularTubeFedShotgun_ApplySkin = PatchController.MW_ModularTubeFedShotgun_ApplySkin;
				MethodInfo method334 = typeof(IModularWeaponPatch).GetMethod("ApplySkinPrefix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method335 = typeof(IModularWeaponPatch).GetMethod("ApplySkinPostfix", BindingFlags.Static | BindingFlags.NonPublic);
				PatchController.Verify(mW_ModularBoltActionRifle_ApplySkin, harmony, breaking: true);
				PatchController.Verify(mW_ModularBreakActionWeapon_ApplySkin, harmony, breaking: true);
				PatchController.Verify(mW_ModularClosedBoltWeapon_ApplySkin, harmony, breaking: true);
				PatchController.Verify(mW_ModularHandgun_ApplySkin, harmony, breaking: true);
				PatchController.Verify(mW_ModularOpenBoltReceiver_ApplySkin, harmony, breaking: true);
				PatchController.Verify(mW_ModularRevolver_ApplySkin, harmony, breaking: true);
				PatchController.Verify(mW_ModularTubeFedShotgun_ApplySkin, harmony, breaking: true);
				harmony.Patch((MethodBase)mW_ModularBoltActionRifle_ApplySkin, new HarmonyMethod(method334), new HarmonyMethod(method335), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)mW_ModularBreakActionWeapon_ApplySkin, new HarmonyMethod(method334), new HarmonyMethod(method335), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)mW_ModularClosedBoltWeapon_ApplySkin, new HarmonyMethod(method334), new HarmonyMethod(method335), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)mW_ModularHandgun_ApplySkin, new HarmonyMethod(method334), new HarmonyMethod(method335), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)mW_ModularOpenBoltReceiver_ApplySkin, new HarmonyMethod(method334), new HarmonyMethod(method335), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)mW_ModularRevolver_ApplySkin, new HarmonyMethod(method334), new HarmonyMethod(method335), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)mW_ModularTubeFedShotgun_ApplySkin, new HarmonyMethod(method334), new HarmonyMethod(method335), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}
	}
	internal class ModularWeaponPartPatch
	{
		public static int skip;

		private static void EnablePrefix(MonoBehaviour __instance)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0)
			{
				return;
			}
			MonoBehaviour[] componentsInParent = ((Component)__instance).GetComponentsInParent<MonoBehaviour>();
			MonoBehaviour val = null;
			for (int i = 0; i < componentsInParent.Length; i++)
			{
				Type[] interfaces = ((object)componentsInParent[i]).GetType().GetInterfaces();
				for (int j = 0; j < interfaces.Length; j++)
				{
					if ((object)interfaces[j] == PatchController.MW_IModularWeapon)
					{
						val = componentsInParent[i];
						break;
					}
				}
			}
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			IDictionary dictionary = PatchController.MW_IModularWeapon_get_AllAttachmentPoints.Invoke(val, null) as IDictionary;
			foreach (DictionaryEntry item in dictionary)
			{
				if (!((Object)(Transform)PatchController.MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint.GetValue(item.Value) == (Object)(object)((Component)__instance).transform))
				{
					continue;
				}
				string text = (string)item.Key;
				string text2 = (string)PatchController.MW_ModularWeaponPartsAttachmentPoint_SelectedModularWeaponPart.GetValue(item.Value);
				Transform val2 = (Transform)PatchController.MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint.GetValue(item.Value);
				MonoBehaviour[] components = ((Component)val2).GetComponents<MonoBehaviour>();
				MonoBehaviour val3 = null;
				for (int k = 0; k < components.Length; k++)
				{
					if ((object)((object)components[k]).GetType() == PatchController.MW_ModularWeaponPart || ((object)components[k]).GetType().IsSubclassOf(PatchController.MW_ModularWeaponPart))
					{
						val3 = components[k];
						break;
					}
				}
				string text3 = null;
				if ((Object)(object)val3 != (Object)null)
				{
					text3 = (string)PatchController.MW_ModularWeaponPart_SelectedModularWeaponPartSkinID.GetValue(val3);
				}
				TrackedItem component = ((Component)val).GetComponent<TrackedItem>();
				if (!((Object)(object)component != (Object)null))
				{
					break;
				}
				List<byte> list = new List<byte>();
				list.AddRange(BitConverter.GetBytes(dictionary.Count));
				foreach (DictionaryEntry item2 in dictionary)
				{
					list.AddRange(BitConverter.GetBytes(text.Length));
					list.AddRange(Encoding.ASCII.GetBytes(text));
					list.AddRange(BitConverter.GetBytes(text2.Length));
					list.AddRange(Encoding.ASCII.GetBytes(text2));
					if (text3 == null)
					{
						list.AddRange(BitConverter.GetBytes(0));
					}
					else
					{
						list.AddRange(BitConverter.GetBytes(text3.Length));
						list.AddRange(Encoding.ASCII.GetBytes(text3));
					}
					List<byte> list2 = new List<byte>();
					TrackedItem.AddModulPartDataInvoke(list, text, text2, dictionary, component);
					list.AddRange(BitConverter.GetBytes(list2.Count));
					list.AddRange(list2);
				}
				component.itemData.additionalData = list.ToArray();
				if (ThreadManager.host)
				{
					ServerSend.SetModulWeaponPart(component.itemData.trackedID, text, text2, text3);
				}
				else
				{
					ClientSend.SetModulWeaponPart(component.itemData.trackedID, text, text2, text3);
				}
				break;
			}
		}
	}
	internal class IModularWeaponPatch
	{
		public static string preSkin;

		private static void ApplySkinPrefix(object __instance, string ModularPartsGroupID, string SkinName)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			if ((Object)(object)Mod.managerObject == (Object)null || ModularWeaponPartPatch.skip > 0)
			{
				return;
			}
			preSkin = null;
			IDictionary dictionary = PatchController.MW_IModularWeapon_get_AllAttachmentPoints.Invoke(__instance, null) as IDictionary;
			object obj = dictionary[ModularPartsGroupID];
			Transform val = (Transform)PatchController.MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint.GetValue(obj);
			MonoBehaviour[] components = ((Component)val).GetComponents<MonoBehaviour>();
			MonoBehaviour val2 = null;
			for (int i = 0; i < components.Length; i++)
			{
				if ((object)((object)components[i]).GetType() == PatchController.MW_ModularWeaponPart || ((object)components[i]).GetType().IsSubclassOf(PatchController.MW_ModularWeaponPart))
				{
					val2 = components[i];
					break;
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				preSkin = (string)PatchController.MW_ModularWeaponPart_SelectedModularWeaponPartSkinID.GetValue(val2);
			}
		}

		private static void ApplySkinPostfix(object __instance, string ModularPartsGroupID, string SkinName)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || ModularWeaponPartPatch.skip > 0)
			{
				return;
			}
			IDictionary dictionary = PatchController.MW_IModularWeapon_get_AllAttachmentPoints.Invoke(__instance, null) as IDictionary;
			object obj = dictionary[ModularPartsGroupID];
			Transform val = (Transform)PatchController.MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint.GetValue(obj);
			MonoBehaviour[] components = ((Component)val).GetComponents<MonoBehaviour>();
			MonoBehaviour val2 = null;
			for (int i = 0; i < components.Length; i++)
			{
				if ((object)((object)components[i]).GetType() == PatchController.MW_ModularWeaponPart || ((object)components[i]).GetType().IsSubclassOf(PatchController.MW_ModularWeaponPart))
				{
					val2 = components[i];
					break;
				}
			}
			string text = null;
			if ((Object)(object)val2 != (Object)null)
			{
				text = (string)PatchController.MW_ModularWeaponPart_SelectedModularWeaponPartSkinID.GetValue(val2);
			}
			if ((text == null || preSkin != null) && (text != null || preSkin == null) && text != null && text.Equals(preSkin))
			{
				return;
			}
			string text2 = (string)PatchController.MW_ModularWeaponPartsAttachmentPoint_SelectedModularWeaponPart.GetValue(obj);
			TrackedItem component = ((Component)(MonoBehaviour)__instance).GetComponent<TrackedItem>();
			if (!((Object)(object)component != (Object)null))
			{
				return;
			}
			List<byte> list = new List<byte>();
			list.AddRange(BitConverter.GetBytes(dictionary.Count));
			foreach (DictionaryEntry item in dictionary)
			{
				list.AddRange(BitConverter.GetBytes(ModularPartsGroupID.Length));
				list.AddRange(Encoding.ASCII.GetBytes(ModularPartsGroupID));
				list.AddRange(BitConverter.GetBytes(text2.Length));
				list.AddRange(Encoding.ASCII.GetBytes(text2));
				if (text == null)
				{
					list.AddRange(BitConverter.GetBytes(0));
				}
				else
				{
					list.AddRange(BitConverter.GetBytes(text.Length));
					list.AddRange(Encoding.ASCII.GetBytes(text));
				}
				List<byte> list2 = new List<byte>();
				TrackedItem.AddModulPartDataInvoke(list, ModularPartsGroupID, text2, dictionary, component);
				list.AddRange(BitConverter.GetBytes(list2.Count));
				list.AddRange(list2);
			}
			component.itemData.additionalData = list.ToArray();
			if (ThreadManager.host)
			{
				ServerSend.SetModulWeaponPart(component.itemData.trackedID, ModularPartsGroupID, text2, text);
			}
			else
			{
				ClientSend.SetModulWeaponPart(component.itemData.trackedID, ModularPartsGroupID, text2, text);
			}
		}
	}
	internal class FirePatch
	{
		public static int skipSending;

		public static bool overriden;

		public static List<Vector3> positions;

		public static List<Vector3> directions;

		public static bool fireSuccessful;

		public static FireArmRoundClass roundClass;

		public static FireArmRoundType roundType;

		private static void Prefix(FVRFireArmChamber chamber)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at firepatch prefix, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			FVRFireArmRound round = chamber.GetRound();
			if ((Object)(object)round == (Object)null)
			{
				fireSuccessful = false;
				return;
			}
			fireSuccessful = true;
			roundClass = round.RoundClass;
			roundType = round.RoundType;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FirePatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FirePatch), "GetDirection", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Call && val.operand.ToString().Contains("op_Subtraction"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("get_forward"))
				{
					if (num == 2)
					{
						list.InsertRange(i + 1, list3);
						flag2 = true;
					}
					else
					{
						num++;
					}
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("FirePatch Transpiler not applied!");
			}
			return list;
		}

		public static Vector3 GetPosition(Vector3 position, int index)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (positions != null && positions.Count > index)
				{
					return positions[index];
				}
				return position;
			}
			AddFirePos(position);
			return position;
		}

		public static Vector3 GetDirection(Vector3 direction, int index, GameObject gameObject)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (directions != null && directions.Count > index)
				{
					gameObject.transform.rotation = Quaternion.LookRotation(directions[index]);
					return directions[index];
				}
				return direction;
			}
			AddFireDir(direction);
			return direction;
		}

		private static void AddFirePos(Vector3 pos)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				positions.Add(pos);
			}
		}

		private static void AddFireDir(Vector3 dir)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				directions.Add(dir);
			}
		}

		private static void Postfix(ref FVRFireArm __instance, FVRFireArmChamber chamber)
		{
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates--;
			if (skipSending > 0)
			{
				return;
			}
			overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				positions = null;
				directions = null;
				return;
			}
			if (!fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				positions = null;
				directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						int chamberIndex = -1;
						for (int i = 0; i < __instance.GetChambers().Count; i++)
						{
							if ((Object)(object)__instance.GetChambers()[i] == (Object)(object)chamber)
							{
								chamberIndex = i;
								break;
							}
						}
						ServerSend.WeaponFire(0, trackedItem.data.trackedID, roundType, roundClass, positions, directions, chamberIndex);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					int chamberIndex2 = 0;
					for (int j = 0; j < __instance.GetChambers().Count; j++)
					{
						if ((Object)(object)__instance.GetChambers()[j] == (Object)(object)chamber)
						{
							chamberIndex2 = j;
							break;
						}
					}
					ClientSend.WeaponFire(trackedItem.data.trackedID, roundType, roundClass, positions, directions, chamberIndex2);
				}
			}
			positions = null;
			directions = null;
		}
	}
	internal class FireSosigWeaponPatch
	{
		public static bool overriden;

		public static List<Vector3> positions;

		public static List<Vector3> directions;

		private static bool fireSuccessful;

		private static void Prefix(ref SosigWeapon __instance, int ___m_shotsLeft)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at sosig weapon fire patch, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			fireSuccessful = ___m_shotsLeft > 0 && (int)__instance.MechaState == 0;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireSosigWeaponPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireSosigWeaponPatch), "GetDirection", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldloc_1)
				{
					if (flag3)
					{
						list.InsertRange(i + 1, list2);
						flag = true;
					}
					else
					{
						flag3 = true;
					}
				}
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("get_forward"))
				{
					if (flag4)
					{
						list.InsertRange(i + 1, list3);
						flag2 = true;
						break;
					}
					flag4 = true;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("FireSosigWeaponPatch Transpiler not applied!");
			}
			return list;
		}

		public static Vector3 GetPosition(Vector3 position, int index)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (positions != null && positions.Count > index)
				{
					return positions[index];
				}
				return position;
			}
			AddFirePos(position);
			return position;
		}

		public static Vector3 GetDirection(Vector3 direction, int index, GameObject gameObject)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (directions != null && directions.Count > index)
				{
					gameObject.transform.rotation = Quaternion.LookRotation(directions[index]);
					return directions[index];
				}
				return direction;
			}
			AddFireDir(direction);
			return direction;
		}

		private static void AddFirePos(Vector3 pos)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				positions.Add(pos);
			}
		}

		private static void AddFireDir(Vector3 dir)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				directions.Add(dir);
			}
		}

		private static void Postfix(ref SosigWeapon __instance, float recoilMult)
		{
			Mod.skipAllInstantiates--;
			overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				positions = null;
				directions = null;
				return;
			}
			if (!fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				positions = null;
				directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemBySosigWeapon.ContainsKey(__instance) ? GameManager.trackedItemBySosigWeapon[__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.trackedID != -1)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.SosigWeaponFire(0, trackedItem.data.trackedID, recoilMult, positions, directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.SosigWeaponFire(trackedItem.data.trackedID, recoilMult, positions, directions);
				}
			}
			positions = null;
			directions = null;
		}
	}
	internal class FireLAPD2019Patch
	{
		public static bool overriden;

		public static List<Vector3> positions;

		public static List<Vector3> directions;

		private static bool fireSucessful;

		private static int curChamber;

		private static FireArmRoundClass roundClass;

		private static FireArmRoundType roundType;

		private static void Prefix(ref LAPD2019 __instance, bool ___m_isCapacitorCharged)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at FireLAPD2019Patch, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			curChamber = __instance.CurChamber;
			if ((Object)(object)__instance.Chambers[__instance.CurChamber].GetRound() != (Object)null)
			{
				roundType = __instance.Chambers[__instance.CurChamber].GetRound().RoundType;
				roundClass = __instance.Chambers[__instance.CurChamber].GetRound().RoundClass;
				fireSucessful = true;
			}
			else
			{
				fireSucessful = false;
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireLAPD2019Patch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)8));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireLAPD2019Patch), "GetDirection", (Type[])null, (Type[])null)));
			List<CodeInstruction> list4 = new List<CodeInstruction>();
			list4.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)14));
			list4.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireLAPD2019Patch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list5 = new List<CodeInstruction>();
			list5.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)14));
			list5.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)15));
			list5.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireLAPD2019Patch), "GetDirection", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			bool flag6 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if ((val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("GetMuzzle") && (list[i + 1].opcode == OpCodes.Callvirt || list[i + 1].opcode == OpCodes.Call) && list[i + 1].operand.ToString().Contains("get_position"))
				{
					if (flag5)
					{
						list.InsertRange(i + 2, list4);
						flag2 = true;
					}
					else
					{
						list.InsertRange(i + 2, list2);
						flag = true;
						flag5 = true;
					}
				}
				if ((val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_transform") && (list[i + 1].opcode == OpCodes.Callvirt || list[i + 1].opcode == OpCodes.Call) && list[i + 1].operand.ToString().Contains("get_forward"))
				{
					if (flag6)
					{
						list.InsertRange(i + 2, list5);
						flag4 = true;
						break;
					}
					list.InsertRange(i + 2, list3);
					flag3 = true;
					flag6 = true;
				}
			}
			if (!flag || !flag2 || !flag3 || !flag4)
			{
				Mod.LogError("FireLAPD2019Patch Transpiler not applied!");
			}
			return list;
		}

		public static Vector3 GetPosition(Vector3 position, int index)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (positions != null && positions.Count > index)
				{
					return positions[index];
				}
				return position;
			}
			AddFirePos(position);
			return position;
		}

		public static Vector3 GetDirection(Vector3 direction, int index, GameObject gameObject)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (directions != null && directions.Count > index)
				{
					gameObject.transform.rotation = Quaternion.LookRotation(directions[index]);
					return directions[index];
				}
				return direction;
			}
			AddFireDir(direction);
			return direction;
		}

		private static void AddFirePos(Vector3 pos)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				positions.Add(pos);
			}
		}

		private static void AddFireDir(Vector3 dir)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				directions.Add(dir);
			}
		}

		private static void Postfix(ref LAPD2019 __instance)
		{
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates--;
			overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				positions = null;
				directions = null;
				return;
			}
			if (!fireSucessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				positions = null;
				directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.LAPD2019Fire(0, trackedItem.data.trackedID, curChamber, roundType, roundClass, positions, directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.LAPD2019Fire(trackedItem.data.trackedID, curChamber, roundType, roundClass, positions, directions);
				}
			}
			positions = null;
			directions = null;
		}
	}
	internal class FireAttachableFirearmPatch
	{
		public static bool overriden;

		public static List<Vector3> positions;

		public static List<Vector3> directions;

		private static bool fireSuccessful;

		private static FireArmRoundType roundType;

		private static FireArmRoundClass roundClass;

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireAttachableFirearmPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireAttachableFirearmPatch), "GetDirection", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				_ = val.opcode;
				if (val.operand != null)
				{
					if (val.operand.ToString().Contains("op_Subtraction"))
					{
						list.InsertRange(i + 1, list2);
						flag = true;
					}
					if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("get_transform") && list[i + 1].opcode == OpCodes.Callvirt && list[i + 1].operand.ToString().Contains("get_forward"))
					{
						list.InsertRange(i + 2, list3);
						flag2 = true;
						break;
					}
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("FireAttachableFirearmPatch Transpiler not applied!");
			}
			return list;
		}

		public static Vector3 GetPosition(Vector3 position, int index)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (positions != null && positions.Count > index)
				{
					return positions[index];
				}
				return position;
			}
			AddFirePos(position);
			return position;
		}

		public static Vector3 GetDirection(Vector3 direction, int index, GameObject gameObject)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (directions != null && directions.Count > index)
				{
					gameObject.transform.rotation = Quaternion.LookRotation(directions[index]);
					return directions[index];
				}
				return direction;
			}
			AddFireDir(direction);
			return direction;
		}

		private static void AddFirePos(Vector3 pos)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				positions.Add(pos);
			}
		}

		private static void AddFireDir(Vector3 dir)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				directions.Add(dir);
			}
		}

		private static void Prefix(ref AttachableFirearm __instance)
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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)
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at FireAttachableFirearmPatch, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			if ((Object)(object)__instance.Attachment == (Object)null)
			{
				if (Object.op_Implicit((Object)(object)__instance.OverrideFA))
				{
					TrackedItem value;
					TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance.OverrideFA, out value) ? value : ((Component)__instance.OverrideFA).GetComponent<TrackedItem>());
					if ((Object)(object)trackedItem != (Object)null && (Object)(object)trackedItem.attachableFirearmGetChamberFunc().GetRound() != (Object)null)
					{
						fireSuccessful = true;
						roundType = trackedItem.attachableFirearmGetChamberFunc().GetRound().RoundType;
						roundClass = trackedItem.attachableFirearmGetChamberFunc().GetRound().RoundClass;
					}
					else
					{
						fireSuccessful = false;
					}
				}
			}
			else
			{
				TrackedItem value2;
				TrackedItem trackedItem2 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance.Attachment, out value2) ? value2 : ((Component)__instance.Attachment).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem2 != (Object)null && (Object)(object)trackedItem2.attachableFirearmGetChamberFunc().GetRound() != (Object)null)
				{
					fireSuccessful = true;
					roundType = trackedItem2.attachableFirearmGetChamberFunc().GetRound().RoundType;
					roundClass = trackedItem2.attachableFirearmGetChamberFunc().GetRound().RoundClass;
				}
				else
				{
					fireSuccessful = false;
				}
			}
		}

		private static void Postfix(ref AttachableFirearm __instance, bool firedFromInterface)
		{
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates--;
			overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				positions = null;
				directions = null;
				return;
			}
			if (!fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				positions = null;
				directions = null;
				return;
			}
			TrackedItem trackedItem = null;
			if ((Object)(object)__instance.Attachment != (Object)null)
			{
				trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance.Attachment) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance.Attachment] : ((Component)__instance.Attachment).GetComponent<TrackedItem>());
			}
			if ((Object)(object)trackedItem == (Object)null)
			{
				trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance.OverrideFA) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance.OverrideFA] : ((Component)__instance.OverrideFA).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem != (Object)null)
				{
					if (ThreadManager.host)
					{
						if (trackedItem.data.controller == 0)
						{
							ServerSend.IntegratedFirearmFire(0, trackedItem.data.trackedID, roundType, roundClass, positions, directions);
						}
					}
					else if (trackedItem.data.controller == Client.singleton.ID)
					{
						ClientSend.IntegratedFirearmFire(trackedItem.data.trackedID, roundType, roundClass, positions, directions);
					}
				}
			}
			else if (ThreadManager.host)
			{
				if (trackedItem.data.controller == 0)
				{
					ServerSend.AttachableFirearmFire(0, trackedItem.data.trackedID, roundType, roundClass, firedFromInterface, positions, directions);
				}
			}
			else if (trackedItem.data.controller == Client.singleton.ID)
			{
				ClientSend.AttachableFirearmFire(trackedItem.data.trackedID, roundType, roundClass, firedFromInterface, positions, directions);
			}
			positions = null;
			directions = null;
		}
	}
	internal class FireRevolvingShotgunPatch
	{
		private static void Prefix()
		{
			FirePatch.skipSending++;
		}

		private static void Postfix(ref RevolvingShotgun __instance)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			FirePatch.skipSending--;
			FirePatch.overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			if (!FirePatch.fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.RevolvingShotgunFire(0, trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, __instance.CurChamber, FirePatch.positions, FirePatch.directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.RevolvingShotgunFire(trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, __instance.CurChamber, FirePatch.positions, FirePatch.directions);
				}
			}
			FirePatch.positions = null;
			FirePatch.directions = null;
		}
	}
	internal class FireRevolverPatch
	{
		private static void Prefix()
		{
			FirePatch.skipSending++;
		}

		private static void Postfix(ref Revolver __instance)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			FirePatch.skipSending--;
			FirePatch.overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			if (!FirePatch.fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.RevolverFire(0, trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, __instance.CurChamber, FirePatch.positions, FirePatch.directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.RevolverFire(trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, __instance.CurChamber, FirePatch.positions, FirePatch.directions);
				}
			}
			FirePatch.positions = null;
			FirePatch.directions = null;
		}
	}
	internal class FireSingleActionRevolverPatch
	{
		private static void Prefix(SingleActionRevolver __instance)
		{
			FirePatch.skipSending++;
			FVRFireArmChamber val = __instance.Cylinder.Chambers[__instance.CurChamber];
			FirePatch.fireSuccessful = val.IsFull && (Object)(object)val.GetRound() != (Object)null && !val.IsSpent;
		}

		private static void Postfix(ref SingleActionRevolver __instance)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			FirePatch.skipSending--;
			FirePatch.overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			if (!FirePatch.fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.SingleActionRevolverFire(0, trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, __instance.CurChamber, FirePatch.positions, FirePatch.directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.SingleActionRevolverFire(trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, __instance.CurChamber, FirePatch.positions, FirePatch.directions);
				}
			}
			FirePatch.positions = null;
			FirePatch.directions = null;
		}
	}
	internal class FireGrappleGunPatch
	{
		private static int preChamber;

		private static void Prefix(GrappleGun __instance, int ___m_curChamber)
		{
			FirePatch.skipSending++;
			FVRFireArmChamber val = __instance.Chambers[___m_curChamber];
			FirePatch.fireSuccessful = val.IsFull && (Object)(object)val.GetRound() != (Object)null && !val.IsSpent;
			preChamber = ___m_curChamber;
		}

		private static void Postfix(ref GrappleGun __instance)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			FirePatch.skipSending--;
			FirePatch.overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			if (!FirePatch.fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.GrappleGunFire(0, trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, preChamber, FirePatch.positions, FirePatch.directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.GrappleGunFire(trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, preChamber, FirePatch.positions, FirePatch.directions);
				}
			}
			FirePatch.positions = null;
			FirePatch.directions = null;
		}
	}
	internal class FireDerringerPatch
	{
		private static void Prefix(Derringer __instance, HingeState ___m_hingeState, int ___m_curBarrel)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			FirePatch.skipSending++;
			FVRFireArmChamber chamber = __instance.Barrels[___m_curBarrel].Chamber;
			FirePatch.fireSuccessful = (int)___m_hingeState == 0 && chamber.IsFull && (Object)(object)chamber.GetRound() != (Object)null && !chamber.IsSpent;
		}

		private static void Postfix(ref Derringer __instance, int i)
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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)
			FirePatch.skipSending--;
			FirePatch.overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			if (!FirePatch.fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.DerringerFire(0, trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, i, FirePatch.positions, FirePatch.directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.DerringerFire(trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, i, FirePatch.positions, FirePatch.directions);
				}
			}
			FirePatch.positions = null;
			FirePatch.directions = null;
		}
	}
	internal class FireBreakActionWeaponPatch
	{
		private static void Prefix(BreakActionWeapon __instance, int b)
		{
			FirePatch.skipSending++;
			FVRFireArmChamber chamber = __instance.Barrels[b].Chamber;
			FirePatch.fireSuccessful = chamber.IsFull && (Object)(object)chamber.GetRound() != (Object)null && !chamber.IsSpent;
		}

		private static void Postfix(ref BreakActionWeapon __instance, int b)
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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)
			FirePatch.skipSending--;
			FirePatch.overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			if (!FirePatch.fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.BreakActionWeaponFire(0, trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, b, FirePatch.positions, FirePatch.directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.BreakActionWeaponFire(trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, b, FirePatch.positions, FirePatch.directions);
				}
			}
			FirePatch.positions = null;
			FirePatch.directions = null;
		}
	}
	internal class FireLeverActionFirearmPatch
	{
		private static bool hammer1Cocked;

		private static bool hammer2Cocked;

		private static void Prefix(bool ___m_isHammerCocked, bool ___m_isHammerCocked2)
		{
			FirePatch.skipSending++;
			hammer1Cocked = ___m_isHammerCocked;
			hammer2Cocked = ___m_isHammerCocked2;
		}

		private static void Postfix(ref LeverActionFirearm __instance, bool ___m_isHammerCocked, bool ___m_isHammerCocked2)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			FirePatch.skipSending--;
			FirePatch.overriden = false;
			if (Mod.skipNextFires > 0)
			{
				Mod.skipNextFires--;
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			if (!FirePatch.fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				FirePatch.positions = null;
				FirePatch.directions = null;
				return;
			}
			bool hammer = true;
			if (!___m_isHammerCocked2 && hammer2Cocked)
			{
				hammer = false;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.LeverActionFirearmFire(0, trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, hammer, FirePatch.positions, FirePatch.directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.LeverActionFirearmFire(trackedItem.data.trackedID, FirePatch.roundType, FirePatch.roundClass, hammer, FirePatch.positions, FirePatch.directions);
				}
			}
			FirePatch.positions = null;
			FirePatch.directions = null;
		}
	}
	internal class FireFlintlockWeaponPatch
	{
		public static bool overriden;

		public static List<Vector3> positions;

		public static List<Vector3> directions;

		public static int burnSkip;

		public static int fireSkip;

		public static bool fireSuccessful;

		public static LoadedElementType[] loadedElementTypes;

		public static float[] loadedElementPositions;

		public static int powderAmount;

		public static bool ramRod;

		public static float num2;

		public static int[] loadedElementPowderAmounts;

		public static float num5;

		private static void BurnOffOuterPrefix(FlintlockBarrel __instance)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected I4, but got Unknown
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at BurnOffOuterPrefix, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			if (burnSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			fireSuccessful = __instance.LoadedElements.Count > 0 && (int)__instance.LoadedElements[__instance.LoadedElements.Count - 1].Type == 0;
			if (fireSuccessful)
			{
				loadedElementTypes = (LoadedElementType[])(object)new LoadedElementType[__instance.LoadedElements.Count];
				loadedElementPositions = new float[__instance.LoadedElements.Count];
				for (int i = 0; i < __instance.LoadedElements.Count; i++)
				{
					loadedElementTypes[i] = (LoadedElementType)(int)__instance.LoadedElements[i].Type;
					loadedElementPositions[i] = __instance.LoadedElements[i].Position;
				}
				powderAmount = __instance.LoadedElements[__instance.LoadedElements.Count - 1].PowderAmount;
				ramRod = (Object)(object)__instance.GetWeapon().RamRod.GetCurBarrel() == (Object)(object)__instance;
			}
		}

		private static IEnumerable<CodeInstruction> BurnOffOuterTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)6));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetDirection", (Type[])null, (Type[])null)));
			List<CodeInstruction> list4 = new List<CodeInstruction>();
			list4.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			list4.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list5 = new List<CodeInstruction>();
			list5.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			list5.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)10));
			list5.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetDirection", (Type[])null, (Type[])null)));
			List<CodeInstruction> list6 = new List<CodeInstruction>();
			list6.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list6.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetNum2", (Type[])null, (Type[])null)));
			list6.Add(new CodeInstruction(OpCodes.Stloc_S, (object)4));
			bool[] array = new bool[5];
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (!flag4 && val.opcode == OpCodes.Stloc_S && val.operand.ToString().Contains("4"))
				{
					list.InsertRange(i + 1, list6);
					array[0] = true;
					flag4 = true;
				}
				else if (!flag && (val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_position"))
				{
					list.InsertRange(i + 1, list2);
					array[1] = true;
					flag = true;
				}
				else if (flag && (val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_position"))
				{
					list.InsertRange(i + 1, list4);
					array[2] = true;
				}
				else if (!flag3 && (val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_forward"))
				{
					list.InsertRange(i + 1, list3);
					array[3] = true;
					flag3 = true;
				}
				else if (flag3 && !flag2 && (val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_forward"))
				{
					flag2 = true;
				}
				else if (flag3 && flag2 && (val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_forward"))
				{
					list.InsertRange(i + 1, list5);
					array[4] = true;
					break;
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (!array[j])
				{
					Mod.LogError("FireFlintlockWeaponPatch BurnOffOuterTranspiler not applied!");
					break;
				}
			}
			return list;
		}

		public static float GetNum2(float num2)
		{
			if (overriden)
			{
				return FireFlintlockWeaponPatch.num2;
			}
			FireFlintlockWeaponPatch.num2 = num2;
			return num2;
		}

		public static float GetNum5(float num5)
		{
			if (overriden)
			{
				return FireFlintlockWeaponPatch.num5;
			}
			FireFlintlockWeaponPatch.num5 = num5;
			return num5;
		}

		public static Vector3 GetPosition(Vector3 position, int index)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (positions != null && positions.Count > index)
				{
					return positions[index];
				}
				return position;
			}
			AddFirePos(position);
			return position;
		}

		public static Vector3 GetDirection(Vector3 direction, int index, GameObject gameObject)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				if (directions != null && directions.Count > index)
				{
					gameObject.transform.rotation = Quaternion.LookRotation(directions[index]);
					return directions[index];
				}
				return direction;
			}
			AddFireDir(direction);
			return direction;
		}

		private static void AddFirePos(Vector3 pos)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				positions.Add(pos);
			}
		}

		private static void AddFireDir(Vector3 dir)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.skipNextFires <= 0 && !((Object)(object)Mod.managerObject == (Object)null) && GameManager.playersPresent.Count != 0)
			{
				if (positions == null)
				{
					positions = new List<Vector3>();
					directions = new List<Vector3>();
				}
				directions.Add(dir);
			}
		}

		private static void BurnOffOuterPostfix(ref FlintlockBarrel __instance)
		{
			Mod.skipAllInstantiates--;
			overriden = false;
			if (burnSkip > 0)
			{
				positions = null;
				directions = null;
				return;
			}
			if (!fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				positions = null;
				directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance.GetWeapon()) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance.GetWeapon()] : ((Component)__instance.GetWeapon()).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.FlintlockWeaponBurnOffOuter(0, trackedItem.data.trackedID, loadedElementTypes, loadedElementPositions, powderAmount, ramRod, num2, positions, directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.FlintlockWeaponBurnOffOuter(trackedItem.data.trackedID, loadedElementTypes, loadedElementPositions, powderAmount, ramRod, num2, positions, directions);
				}
			}
			positions = null;
			directions = null;
		}

		private static void FirePrefix(FlintlockBarrel __instance)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected I4, but got Unknown
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at flint lock FirePrefix, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			if (fireSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			fireSuccessful = __instance.LoadedElements.Count > 0 && (int)__instance.LoadedElements[__instance.LoadedElements.Count - 1].Type == 0;
			if (fireSuccessful)
			{
				loadedElementTypes = (LoadedElementType[])(object)new LoadedElementType[__instance.LoadedElements.Count];
				loadedElementPositions = new float[__instance.LoadedElements.Count];
				loadedElementPowderAmounts = new int[__instance.LoadedElements.Count];
				for (int i = 0; i < __instance.LoadedElements.Count; i++)
				{
					loadedElementTypes[i] = (LoadedElementType)(int)__instance.LoadedElements[i].Type;
					loadedElementPositions[i] = __instance.LoadedElements[i].Position;
					loadedElementPowderAmounts[i] = __instance.LoadedElements[i].PowderAmount;
				}
				ramRod = (Object)(object)__instance.GetWeapon().RamRod.GetCurBarrel() == (Object)(object)__instance;
			}
		}

		private static IEnumerable<CodeInstruction> FireTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)11));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetDirection", (Type[])null, (Type[])null)));
			List<CodeInstruction> list4 = new List<CodeInstruction>();
			list4.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)12));
			list4.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list5 = new List<CodeInstruction>();
			list5.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)12));
			list5.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)15));
			list5.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetDirection", (Type[])null, (Type[])null)));
			List<CodeInstruction> list6 = new List<CodeInstruction>();
			list6.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)9));
			list6.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetNum5", (Type[])null, (Type[])null)));
			list6.Add(new CodeInstruction(OpCodes.Stloc_S, (object)9));
			List<CodeInstruction> list7 = new List<CodeInstruction>();
			list7.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)20));
			list7.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list8 = new List<CodeInstruction>();
			list8.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)20));
			list8.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)22));
			list8.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireFlintlockWeaponPatch), "GetDirection", (Type[])null, (Type[])null)));
			bool[] array = new bool[7];
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (!flag3 && val.opcode == OpCodes.Stloc_S && val.operand.ToString().Contains("System.Single (9)"))
				{
					list.InsertRange(i + 1, list6);
					array[0] = true;
					flag3 = true;
				}
				else if (!flag && val.opcode == OpCodes.Ldfld && val.operand.ToString().Contains("Muzzle") && (list[i + 1].opcode == OpCodes.Callvirt || list[i + 1].opcode == OpCodes.Call) && list[i + 1].operand.ToString().Contains("get_position"))
				{
					list.InsertRange(i + 2, list2);
					array[1] = true;
					flag = true;
				}
				else if (val.opcode == OpCodes.Ldloc_S && val.operand.ToString().Equals("UnityEngine.Vector3 (13)"))
				{
					list.InsertRange(i + 1, list4);
					array[2] = true;
				}
				else if (val.opcode == OpCodes.Ldloc_S && val.operand.ToString().Equals("UnityEngine.Vector3 (21)"))
				{
					list.InsertRange(i + 1, list7);
					array[3] = true;
				}
				else if (!flag2 && val.opcode == OpCodes.Ldfld && val.operand.ToString().Contains("Muzzle") && (list[i + 1].opcode == OpCodes.Callvirt || list[i + 1].opcode == OpCodes.Call) && list[i + 1].operand.ToString().Contains("get_forward"))
				{
					list.InsertRange(i + 2, list3);
					array[4] = true;
					flag2 = true;
				}
				else if (val.opcode == OpCodes.Ldloc_S && val.operand.ToString().Equals("UnityEngine.GameObject (15)") && (list[i + 1].opcode == OpCodes.Callvirt || list[i + 1].opcode == OpCodes.Call) && list[i + 1].operand.ToString().Contains("get_transform") && (list[i + 2].opcode == OpCodes.Callvirt || list[i + 2].opcode == OpCodes.Call) && list[i + 2].operand.ToString().Contains("get_forward"))
				{
					list.InsertRange(i + 3, list5);
					array[5] = true;
				}
				else if (val.opcode == OpCodes.Ldloc_S && val.operand.ToString().Equals("UnityEngine.GameObject (22)") && (list[i + 1].opcode == OpCodes.Callvirt || list[i + 1].opcode == OpCodes.Call) && list[i + 1].operand.ToString().Contains("get_transform") && (list[i + 2].opcode == OpCodes.Callvirt || list[i + 2].opcode == OpCodes.Call) && list[i + 2].operand.ToString().Contains("get_forward"))
				{
					list.InsertRange(i + 3, list8);
					array[6] = true;
					break;
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (!array[j])
				{
					Mod.LogError("FireFlintlockWeaponPatch FireTranspiler not applied!");
					break;
				}
			}
			return list;
		}

		private static void FirePostfix(ref FlintlockBarrel __instance)
		{
			Mod.skipAllInstantiates--;
			overriden = false;
			if (fireSkip > 0)
			{
				positions = null;
				directions = null;
				return;
			}
			if (!fireSuccessful || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				positions = null;
				directions = null;
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance.GetWeapon()) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance.GetWeapon()] : ((Component)__instance.GetWeapon()).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						ServerSend.FlintlockWeaponFire(0, trackedItem.data.trackedID, loadedElementTypes, loadedElementPositions, loadedElementPowderAmounts, ramRod, num5, positions, directions);
					}
				}
				else if (trackedItem.data.controller == Client.singleton.ID)
				{
					ClientSend.FlintlockWeaponFire(trackedItem.data.trackedID, loadedElementTypes, loadedElementPositions, loadedElementPowderAmounts, ramRod, num5, positions, directions);
				}
			}
			positions = null;
			directions = null;
		}
	}
	internal class FireHCBPatch
	{
		public static bool overriden;

		public static Vector3 position;

		public static Vector3 direction;

		public static int releaseSledSkip;

		private static bool Prefix(HCB __instance, ref SledState ___m_sledState, ref float ___m_cookedAmount)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at FireHCBPatch, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			___m_sledState = (SledState)0;
			__instance.Sled.localPosition = __instance.SledPos_Forward.localPosition;
			__instance.UpdateStrings();
			if (__instance.Chamber.IsFull)
			{
				GameObject val = Object.Instantiate<GameObject>(__instance.BoltPrefab, GetPos(((FVRFireArm)__instance).MuzzlePos.position), ((FVRFireArm)__instance).MuzzlePos.rotation);
				HCBBolt component = val.GetComponent<HCBBolt>();
				component.Fire(GetDir(((FVRFireArm)__instance).MuzzlePos.forward), GetPos(((FVRFireArm)__instance).MuzzlePos.position), 1f);
				component.SetCookedAmount(___m_cookedAmount);
				__instance.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			((FVRFireArm)__instance).PlayAudioAsHandling(__instance.AudEvent_Fire, ((Component)__instance.Sled).transform.position);
			if (releaseSledSkip == 0)
			{
				TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem != (Object)null)
				{
					if (ThreadManager.host)
					{
						if (trackedItem.data.controller == 0)
						{
							ServerSend.HCBReleaseSled(0, trackedItem.data.trackedID, __instance.Chamber.IsFull ? ___m_cookedAmount : (-1f), position, direction);
						}
					}
					else if (trackedItem.data.controller == Client.singleton.ID)
					{
						ClientSend.HCBReleaseSled(trackedItem.data.trackedID, __instance.Chamber.IsFull ? ___m_cookedAmount : (-1f), position, direction);
					}
				}
			}
			___m_cookedAmount = 0f;
			return false;
		}

		private static Vector3 GetPos(Vector3 original)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				return position;
			}
			position = original;
			return original;
		}

		private static Vector3 GetDir(Vector3 original)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				return direction;
			}
			direction = original;
			return original;
		}

		private static void Postfix()
		{
			Mod.skipAllInstantiates--;
			overriden = false;
		}
	}
	internal class SimpleLauncherPatch
	{
		private static bool DamagePrefix(SimpleLauncher __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			return (Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID;
		}

		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if ((val.opcode == OpCodes.Call || val.opcode == OpCodes.Callvirt) && val.operand.ToString().Contains("Fire"))
				{
					list.RemoveAt(i - 1);
					list.RemoveAt(i - 1);
					list.Insert(i - 1, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					list.Insert(i, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SimpleLauncherPatch), "ConditionalFire", (Type[])null, (Type[])null)));
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("SimpleLauncherPatch CollisionTranspiler not applied!");
			}
			return list;
		}

		public static void ConditionalFire(SimpleLauncher simpleLauncher)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				simpleLauncher.Fire();
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)simpleLauncher, out trackedItem) ? trackedItem : ((Component)simpleLauncher).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID)
			{
				simpleLauncher.Fire();
			}
		}
	}
	internal class FireStingerLauncherPatch
	{
		public static bool overriden;

		public static Vector3 targetPos;

		public static Vector3 position;

		public static Quaternion rotation;

		private static TrackedItem trackedItem;

		public static int skip;

		private static void Prefix(ref StingerLauncher __instance, AIEntity ___m_targetEntity)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at FireStingerLauncherPatch, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out var value) ? value : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)___m_targetEntity != (Object)null)
			{
				targetPos = ((Component)___m_targetEntity).transform.position;
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireStingerLauncherPatch), "GetPosition", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireStingerLauncherPatch), "GetRotation", (Type[])null, (Type[])null)));
			List<CodeInstruction> list4 = new List<CodeInstruction>();
			list4.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list4.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(FireStingerLauncherPatch), "SetStingerMissile", (Type[])null, (Type[])null)));
			bool[] array = new bool[3];
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("get_position"))
				{
					list.InsertRange(i + 1, list2);
					array[0] = true;
				}
				else if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("get_rotation"))
				{
					list.InsertRange(i + 1, list3);
					array[1] = true;
				}
				else if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("Fire"))
				{
					list.InsertRange(i + 1, list4);
					array[2] = true;
					break;
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (!array[j])
				{
					Mod.LogError("FireStingerLauncherPatch Transpiler not applied!");
					break;
				}
			}
			return list;
		}

		public static void SetStingerMissile(StingerMissile missile)
		{
			Mod.LogInfo("Setting stinger missile");
			if ((Object)(object)trackedItem != (Object)null)
			{
				Mod.LogInfo("\tGot trackedItem");
				trackedItem.stingerMissile = missile;
				TrackedObjectReference trackedObjectReference = ((Component)missile).gameObject.AddComponent<TrackedObjectReference>();
				trackedObjectReference.trackedRef = trackedItem;
			}
			else
			{
				Mod.LogInfo("\tNO trackedItem");
			}
		}

		public static Vector3 GetPosition(Vector3 position)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				return FireStingerLauncherPatch.position;
			}
			FireStingerLauncherPatch.position = position;
			return position;
		}

		public static Quaternion GetRotation(Quaternion rotation)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (overriden)
			{
				return FireStingerLauncherPatch.rotation;
			}
			FireStingerLauncherPatch.rotation = rotation;
			return rotation;
		}

		private static void Postfix()
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			Mod.skipAllInstantiates--;
			overriden = false;
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0 || !((Object)(object)trackedItem != (Object)null))
			{
				return;
			}
			if (ThreadManager.host)
			{
				if (trackedItem.data.controller == 0)
				{
					ServerSend.StingerLauncherFire(0, trackedItem.data.trackedID, targetPos, position, rotation);
				}
			}
			else if (trackedItem.data.controller == Client.singleton.ID)
			{
				ClientSend.StingerLauncherFire(trackedItem.data.trackedID, targetPos, position, rotation);
			}
		}

		private static bool MissileFirePrefix(StingerMissile __instance)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null && overriden)
			{
				__instance.Fire(targetPos, 12f);
				return false;
			}
			return true;
		}
	}
	internal class RemoteMissileDetonatePatch
	{
		public static bool overriden;

		private static bool Prefix(RemoteMissile __instance, RemoteMissileLauncher ___m_launcher)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)___m_launcher, out trackedItem) ? trackedItem : ((Component)___m_launcher).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller != GameManager.ID)
				{
					if (overriden)
					{
						overriden = false;
						return true;
					}
					return false;
				}
				if (ThreadManager.host)
				{
					ServerSend.RemoteMissileDetonate(0, trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.RemoteMissileDetonate(trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
			}
			return true;
		}
	}
	internal class StingerMissileExplodePatch
	{
		public static bool overriden;

		private static bool Prefix(StingerMissile __instance)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedRef = ((Component)__instance).GetComponent<TrackedObjectReference>().trackedRef;
			if ((Object)(object)trackedRef != (Object)null)
			{
				if (trackedRef.data.controller != GameManager.ID)
				{
					if (overriden)
					{
						overriden = false;
						return true;
					}
					return false;
				}
				if (ThreadManager.host)
				{
					ServerSend.StingerMissileExplode(0, trackedRef.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.StingerMissileExplode(trackedRef.data.trackedID, ((Component)__instance).transform.position);
				}
			}
			return true;
		}
	}
	internal class SosigWeaponShatterPatch
	{
		public static int skip;

		private static void Prefix(ref SosigWeapon __instance)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemBySosigWeapon.ContainsKey(__instance) ? GameManager.trackedItemBySosigWeapon[__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if (!((Object)(object)trackedItem != (Object)null))
			{
				return;
			}
			if (ThreadManager.host)
			{
				if (trackedItem.data.controller == 0)
				{
					ServerSend.SosigWeaponShatter(0, trackedItem.data.trackedID);
				}
			}
			else if (trackedItem.data.controller == Client.singleton.ID)
			{
				ClientSend.SosigWeaponShatter(trackedItem.data.trackedID);
			}
		}
	}
	internal class SosigConfigurePatch
	{
		public static bool skipConfigure;

		private static void Prefix(ref Sosig __instance, SosigConfigTemplate t)
		{
			if (skipConfigure)
			{
				skipConfigure = false;
			}
			else
			{
				if ((Object)(object)Mod.managerObject == (Object)null)
				{
					return;
				}
				TrackedSosig component = ((Component)__instance).GetComponent<TrackedSosig>();
				if ((Object)(object)component != (Object)null)
				{
					component.sosigData.configTemplate = t;
					if (ThreadManager.host)
					{
						ServerSend.SosigConfigure(component.data.trackedID, t);
					}
					else if (component.data.trackedID != -1)
					{
						ClientSend.SosigConfigure(component.data.trackedID, t);
					}
					else if (TrackedSosig.unknownConfiguration.ContainsKey(component.data.localWaitingIndex))
					{
						TrackedSosig.unknownConfiguration[component.data.localWaitingIndex] = t;
					}
					else
					{
						TrackedSosig.unknownConfiguration.Add(component.data.localWaitingIndex, t);
					}
				}
			}
		}
	}
	internal class SosigUpdatePatch
	{
		private static bool UpdatePrefix(Sosig __instance)
		{
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (__instance.BuffSystems.Length >= 15 && (Object)(object)__instance.BuffSystems[14] != (Object)null && int.TryParse(((Object)__instance.BuffSystems[14]).name, out var result))
			{
				TrackedSosig trackedSosig = (TrackedSosig)TrackedObject.trackedReferences[result];
				if ((Object)(object)trackedSosig != (Object)null)
				{
					bool flag = trackedSosig.data.controller == GameManager.ID;
					if (!flag)
					{
						if ((Object)(object)__instance.Links[__instance.m_linkIndex] == (Object)null)
						{
							for (int i = 0; i < __instance.Links.Count; i++)
							{
								if ((Object)(object)__instance.Links[i] != (Object)null)
								{
									__instance.m_linkIndex = i;
									__instance.fakeEntityPos = ((Component)__instance.Links[__instance.m_linkIndex]).transform.position + Random.onUnitSphere * 0.2f + ((Component)__instance.Links[__instance.m_linkIndex]).transform.up * 0.25f;
									break;
								}
							}
						}
						else
						{
							__instance.fakeEntityPos = ((Component)__instance.Links[__instance.m_linkIndex]).transform.position + Random.onUnitSphere * 0.2f + ((Component)__instance.Links[__instance.m_linkIndex]).transform.up * 0.25f;
						}
						__instance.E.FakePos = __instance.fakeEntityPos;
						__instance.VaporizeUpdate();
						__instance.HeadIconUpdate();
						if (__instance.m_recoveringFromBallisticState)
						{
							__instance.UpdateJoints(__instance.m_recoveryFromBallisticLerp);
						}
					}
					return flag;
				}
			}
			return true;
		}

		private static bool HandPhysUpdatePrefix(ref Sosig __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (__instance.BuffSystems.Length >= 15 && (Object)(object)__instance.BuffSystems[14] != (Object)null && int.TryParse(((Object)__instance.BuffSystems[14]).name, out var result))
			{
				TrackedSosig trackedSosig = (TrackedSosig)TrackedObject.trackedReferences[result];
				if ((Object)(object)trackedSosig != (Object)null)
				{
					return trackedSosig.data.controller == GameManager.ID;
				}
			}
			return true;
		}
	}
	internal class SosigInvUpdatePatch
	{
		private static bool PhysHoldPrefix(ref SosigInventory __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (__instance.S.BuffSystems.Length >= 15 && (Object)(object)__instance.S.BuffSystems[14] != (Object)null && int.TryParse(((Object)__instance.S.BuffSystems[14]).name, out var result))
			{
				TrackedSosig trackedSosig = (TrackedSosig)TrackedObject.trackedReferences[result];
				if ((Object)(object)trackedSosig != (Object)null)
				{
					return trackedSosig.data.controller == GameManager.ID;
				}
			}
			return true;
		}
	}
	internal class SosigPatch
	{
		public static int sosigDiesSkip;

		public static int sosigClearSkip;

		public static int sosigSetBodyStateSkip;

		public static int sosigVaporizeSkip;

		public static int sosigSetCurrentOrderSkip;

		public static int sosigRequestHitDecalSkip;

		public static int skipSendingOrder;

		private static void SosigDiesPrefix(ref Sosig __instance, DamageClass damClass, SosigDeathType deathType)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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)
			SosigHandDropPatch.skip++;
			SosigSlotDetachPatch.skip++;
			sosigSetBodyStateSkip++;
			if (sosigDiesSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null && trackedSosig.data.trackedID != -1)
			{
				if (ThreadManager.host)
				{
					ServerSend.SosigDies(trackedSosig.data.trackedID, damClass, deathType);
				}
				else
				{
					ClientSend.SosigDies(trackedSosig.data.trackedID, damClass, deathType);
				}
			}
		}

		private static void SosigDiesPostfix()
		{
			SosigHandDropPatch.skip--;
			SosigSlotDetachPatch.skip--;
			sosigSetBodyStateSkip--;
		}

		private static void SosigClearPrefix(ref Sosig __instance)
		{
			SosigHandDropPatch.skip++;
			SosigSlotDetachPatch.skip++;
			sosigSetBodyStateSkip++;
			SosigLinkActionPatch.skipLinkExplodes++;
			if (sosigClearSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null)
			{
				trackedSosig.sendDestroy = false;
				if (ThreadManager.host)
				{
					ServerSend.SosigClear(trackedSosig.data.trackedID);
				}
				else
				{
					ClientSend.SosigClear(trackedSosig.data.trackedID);
				}
			}
		}

		private static void SosigClearPostfix()
		{
			SosigHandDropPatch.skip--;
			SosigSlotDetachPatch.skip--;
			sosigSetBodyStateSkip--;
			SosigLinkActionPatch.skipLinkExplodes--;
		}

		private static void SetBodyStatePrefix(ref Sosig __instance, SosigBodyState s)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (sosigSetBodyStateSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			if (trackedSosig.data.trackedID == -1)
			{
				if (TrackedSosig.unknownBodyStates.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownBodyStates[trackedSosig.data.localWaitingIndex] = s;
				}
				else
				{
					TrackedSosig.unknownBodyStates.Add(trackedSosig.data.localWaitingIndex, s);
				}
			}
			else if (ThreadManager.host)
			{
				ServerSend.SosigSetBodyState(trackedSosig.data.trackedID, s);
			}
			else
			{
				ClientSend.SosigSetBodyState(trackedSosig.data.trackedID, s);
			}
		}

		private static IEnumerable<CodeInstruction> FootStepTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_S, (object)10));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Component), "get_transform", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Transform), "get_position", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list2.Add(new CodeInstruction(OpCodes.Ldc_R4, (object)0.35f));
			list2.Add(new CodeInstruction(OpCodes.Mul, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list2.Add(new CodeInstruction(OpCodes.Ldc_R4, (object)0.4f));
			list2.Add(new CodeInstruction(OpCodes.Mul, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Newobj, (object)AccessTools.Constructor(typeof(Vector2), new Type[2]
			{
				typeof(float),
				typeof(float)
			}, false)));
			list2.Add(new CodeInstruction(OpCodes.Ldc_R4, (object)0.95f));
			list2.Add(new CodeInstruction(OpCodes.Ldc_R4, (object)1.05f));
			list2.Add(new CodeInstruction(OpCodes.Newobj, (object)AccessTools.Constructor(typeof(Vector2), new Type[2]
			{
				typeof(float),
				typeof(float)
			}, false)));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SosigPatch), "SendFootStepSound", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Call && val.operand.ToString().Contains("PlayCoreSoundDelayedOverrides"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("SosigActionPatch FootStepTranspiler not applied!");
			}
			return list;
		}

		public static void SendFootStepSound(Sosig sosig, FVRPooledAudioType audioType, Vector3 position, Vector2 vol, Vector2 pitch, float delay)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || sosig.BuffSystems.Length < 15 || !((Object)(object)sosig.BuffSystems[14] != (Object)null) || !int.TryParse(((Object)sosig.BuffSystems[14]).name, out var result))
			{
				return;
			}
			TrackedSosig trackedSosig = (TrackedSosig)TrackedObject.trackedReferences[result];
			if ((Object)(object)trackedSosig != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.PlaySosigFootStepSound(trackedSosig.data.trackedID, audioType, position, vol, pitch, delay);
				}
				else
				{
					ClientSend.PlaySosigFootStepSound(trackedSosig.data.trackedID, audioType, position, vol, pitch, delay);
				}
			}
		}

		private static IEnumerable<CodeInstruction> SpeechUpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Sosig), "CurrentOrder")));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Sosig), "m_speakingSource")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SosigPatch), "SendSpeakState", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				Sosig val = new Sosig();
				CodeInstruction val2 = list[i];
				if ((val2.opcode == OpCodes.Call || val2.opcode == OpCodes.Callvirt) && val2.operand.ToString().Contains("Speak_State"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("SosigActionPatch SpeechUpdateTranspiler not applied!");
			}
			return list;
		}

		public static void SendSpeakState(Sosig sosig, SosigOrder currentOrder, FVRPooledAudioSource m_speakingSource)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || (Object)(object)m_speakingSource == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(sosig) ? GameManager.trackedSosigBySosig[sosig] : ((Component)sosig).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null && trackedSosig.data.trackedID != -1)
			{
				if (ThreadManager.host)
				{
					ServerSend.SosigSpeakState(trackedSosig.data.trackedID, currentOrder);
				}
				else
				{
					ClientSend.SosigSpeakState(trackedSosig.data.trackedID, currentOrder);
				}
			}
		}

		private static void SetCurrentOrderPrefix(ref Sosig __instance, SosigOrder o)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || sosigSetCurrentOrderSkip > 0 || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null) || trackedSosig.data.controller != GameManager.ID)
			{
				return;
			}
			trackedSosig.sosigData.currentOrder = o;
			if (skipSendingOrder == 0)
			{
				if (ThreadManager.host)
				{
					ServerSend.SosigSetCurrentOrder(trackedSosig.sosigData, o);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigSetCurrentOrder(trackedSosig.sosigData, o);
				}
				else if (TrackedSosig.unknownCurrentOrder.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownCurrentOrder[trackedSosig.data.localWaitingIndex] = o;
				}
				else
				{
					TrackedSosig.unknownCurrentOrder.Add(trackedSosig.data.localWaitingIndex, o);
				}
			}
		}

		private static void CommandGuardPointPrefix()
		{
			skipSendingOrder++;
		}

		private static void CommandGuardPointPostfix(Sosig __instance, Vector3 point, bool hardguard)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			skipSendingOrder--;
			if (sosigSetCurrentOrderSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null && trackedSosig.data.controller == GameManager.ID)
			{
				trackedSosig.sosigData.guardPoint = point;
				trackedSosig.sosigData.hardGuard = hardguard;
				if (ThreadManager.host)
				{
					ServerSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)1);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)1);
				}
				else if (TrackedSosig.unknownCurrentOrder.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownCurrentOrder[trackedSosig.data.localWaitingIndex] = (SosigOrder)1;
				}
				else
				{
					TrackedSosig.unknownCurrentOrder.Add(trackedSosig.data.localWaitingIndex, (SosigOrder)1);
				}
			}
		}

		private static void CommandAssaultPointPrefix()
		{
			skipSendingOrder++;
		}

		private static void CommandAssaultPointPostfix(Sosig __instance, Vector3 point)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			skipSendingOrder--;
			if (sosigSetCurrentOrderSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null && trackedSosig.data.controller == GameManager.ID)
			{
				trackedSosig.sosigData.assaultPoint = point;
				if (ThreadManager.host)
				{
					ServerSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)7);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)7);
				}
				else if (TrackedSosig.unknownCurrentOrder.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownCurrentOrder[trackedSosig.data.localWaitingIndex] = (SosigOrder)7;
				}
				else
				{
					TrackedSosig.unknownCurrentOrder.Add(trackedSosig.data.localWaitingIndex, (SosigOrder)7);
				}
			}
		}

		private static void CommandIdlePrefix()
		{
			skipSendingOrder++;
		}

		private static void CommandIdlePostfix(Sosig __instance, Vector3 point, Vector3 dominantDir)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			skipSendingOrder--;
			if (sosigSetCurrentOrderSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null && trackedSosig.data.controller == GameManager.ID)
			{
				trackedSosig.sosigData.idleToPoint = point;
				trackedSosig.sosigData.idleDominantDir = dominantDir;
				if (ThreadManager.host)
				{
					ServerSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)9);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)9);
				}
				else if (TrackedSosig.unknownCurrentOrder.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownCurrentOrder[trackedSosig.data.localWaitingIndex] = (SosigOrder)9;
				}
				else
				{
					TrackedSosig.unknownCurrentOrder.Add(trackedSosig.data.localWaitingIndex, (SosigOrder)9);
				}
			}
		}

		private static void CommandPathToPostfix(Sosig __instance)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (sosigSetCurrentOrderSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null && trackedSosig.data.controller == GameManager.ID)
			{
				trackedSosig.sosigData.pathToPoint = trackedSosig.physicalSosig.m_pathToPoint;
				if (ThreadManager.host)
				{
					ServerSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)10);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigSetCurrentOrder(trackedSosig.sosigData, (SosigOrder)10);
				}
				else if (TrackedSosig.unknownCurrentOrder.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownCurrentOrder[trackedSosig.data.localWaitingIndex] = (SosigOrder)10;
				}
				else
				{
					TrackedSosig.unknownCurrentOrder.Add(trackedSosig.data.localWaitingIndex, (SosigOrder)10);
				}
			}
		}

		private static void SosigVaporizePrefix(ref Sosig __instance, int iff)
		{
			sosigDiesSkip++;
			SosigHandDropPatch.skip++;
			SosigSlotDetachPatch.skip++;
			sosigSetBodyStateSkip++;
			if (sosigVaporizeSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.SosigVaporize(trackedSosig.data.trackedID, iff);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigVaporize(trackedSosig.data.trackedID, iff);
				}
			}
		}

		private static void SosigVaporizePostfix()
		{
			sosigDiesSkip--;
			SosigHandDropPatch.skip--;
			SosigSlotDetachPatch.skip--;
			sosigSetBodyStateSkip--;
		}

		private static void RequestHitDecalPrefix(ref Sosig __instance, Vector3 point, Vector3 normal, float scale, SosigLink l)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (sosigRequestHitDecalSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			for (int i = 0; i < __instance.Links.Count; i++)
			{
				if ((Object)(object)__instance.Links[i] == (Object)(object)l)
				{
					TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
					if ((Object)(object)trackedSosig != (Object)null)
					{
						SendRequestHitDecal(trackedSosig.data.trackedID, point, normal, Random.onUnitSphere, scale, i);
					}
					break;
				}
			}
		}

		private static void RequestHitDecalEdgePrefix(ref Sosig __instance, Vector3 point, Vector3 normal, Vector3 edgeNormal, float scale, SosigLink l)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (sosigRequestHitDecalSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			for (int i = 0; i < __instance.Links.Count; i++)
			{
				if ((Object)(object)__instance.Links[i] == (Object)(object)l)
				{
					TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
					if ((Object)(object)trackedSosig != (Object)null)
					{
						SendRequestHitDecal(trackedSosig.data.trackedID, point, normal, edgeNormal, scale, i);
					}
					break;
				}
			}
		}

		private static void SendRequestHitDecal(int sosigTrackedID, Vector3 point, Vector3 normal, Vector3 edgeNormal, float scale, int linkIndex)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (ThreadManager.host)
			{
				ServerSend.SosigRequestHitDecal(sosigTrackedID, point, normal, edgeNormal, scale, linkIndex);
			}
			else
			{
				ClientSend.SosigRequestHitDecal(sosigTrackedID, point, normal, edgeNormal, scale, linkIndex);
			}
		}

		private static bool ProcessCollisionPrefix(Sosig __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				Mod.LogWarning("Sosig ProcessCollisionPrefix: __instance null");
				return false;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			return (Object)(object)trackedSosig == (Object)null || trackedSosig.data.controller == GameManager.ID;
		}
	}
	internal class SosigLinkActionPatch
	{
		public static string knownWearableID;

		public static int skipRegisterWearable;

		public static int skipDeRegisterWearable;

		public static int skipLinkExplodes;

		public static int sosigLinkBreakSkip;

		public static int sosigLinkSeverSkip;

		private static void RegisterWearablePrefix(ref SosigLink __instance, SosigWearable w)
		{
			if (skipRegisterWearable > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			int num = -1;
			for (int i = 0; i < __instance.S.Links.Count; i++)
			{
				if ((Object)(object)__instance.S.Links[i] == (Object)(object)__instance)
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				Mod.LogError("RegisterWearablePrefix called on link whos sosig doesn't have the link");
				return;
			}
			if (knownWearableID == null)
			{
				knownWearableID = ((Object)w).name;
				if (knownWearableID.EndsWith("(Clone)"))
				{
					knownWearableID = knownWearableID.Substring(0, knownWearableID.Length - 7);
				}
				if (!Mod.sosigWearableMap.ContainsKey(knownWearableID))
				{
					Mod.LogError("SosigWearable: " + knownWearableID + " not found in map");
					return;
				}
				knownWearableID = Mod.sosigWearableMap[knownWearableID];
			}
			if (trackedSosig.data.trackedID == -1)
			{
				if (TrackedSosig.unknownWearable.TryGetValue(trackedSosig.data.localWaitingIndex, out var value))
				{
					if (value.TryGetValue(knownWearableID, out var value2))
					{
						value2.Add(num);
					}
					else
					{
						value.Add(knownWearableID, new List<int> { num });
					}
				}
				else
				{
					Dictionary<string, List<int>> dictionary = new Dictionary<string, List<int>>();
					dictionary.Add(knownWearableID, new List<int> { num });
					TrackedSosig.unknownWearable.Add(trackedSosig.data.localWaitingIndex, dictionary);
				}
			}
			else if (ThreadManager.host)
			{
				ServerSend.SosigLinkRegisterWearable(trackedSosig.data.trackedID, num, knownWearableID);
			}
			else
			{
				ClientSend.SosigLinkRegisterWearable(trackedSosig.data.trackedID, num, knownWearableID);
			}
			trackedSosig.sosigData.wearables[num].Add(knownWearableID);
			knownWearableID = null;
		}

		private static void DeRegisterWearablePrefix(ref SosigLink __instance, SosigWearable w)
		{
			if (skipDeRegisterWearable > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			int num = -1;
			for (int i = 0; i < __instance.S.Links.Count; i++)
			{
				if ((Object)(object)__instance.S.Links[i] == (Object)(object)__instance)
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				Mod.LogError("RegisterWearablePrefix called on link whos sosig doesn't have the link");
				return;
			}
			if (knownWearableID == null)
			{
				knownWearableID = ((Object)w).name;
				if (knownWearableID.EndsWith("(Clone)"))
				{
					knownWearableID = knownWearableID.Substring(0, knownWearableID.Length - 7);
				}
				if (Mod.sosigWearableMap.ContainsKey(knownWearableID))
				{
					knownWearableID = Mod.sosigWearableMap[knownWearableID];
				}
				else
				{
					Mod.LogError("SosigWearable: " + knownWearableID + " not found in map");
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.SosigLinkDeRegisterWearable(trackedSosig.data.trackedID, num, knownWearableID);
			}
			else if (trackedSosig.data.trackedID != -1)
			{
				ClientSend.SosigLinkDeRegisterWearable(trackedSosig.data.trackedID, num, knownWearableID);
			}
			trackedSosig.sosigData.wearables[num].Remove(knownWearableID);
			knownWearableID = null;
		}

		private static void LinkExplodesPrefix(ref SosigLink __instance, DamageClass damClass)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			SosigPatch.sosigDiesSkip++;
			SosigHandDropPatch.skip++;
			SosigSlotDetachPatch.skip++;
			SosigPatch.sosigSetBodyStateSkip++;
			if (skipLinkExplodes > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			int num = -1;
			for (int i = 0; i < __instance.S.Links.Count; i++)
			{
				if ((Object)(object)__instance.S.Links[i] == (Object)(object)__instance)
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				Mod.LogError("LinkExplodesPrefix called on link whos sosig doesn't have the link");
			}
			else if (ThreadManager.host)
			{
				ServerSend.SosigLinkExplodes(trackedSosig.data.trackedID, num, damClass);
			}
			else if (trackedSosig.data.trackedID != -1)
			{
				ClientSend.SosigLinkExplodes(trackedSosig.data.trackedID, num, damClass);
			}
		}

		private static void LinkExplodesPostfix()
		{
			SosigPatch.sosigDiesSkip--;
			SosigHandDropPatch.skip--;
			SosigSlotDetachPatch.skip--;
			SosigPatch.sosigSetBodyStateSkip--;
		}

		private static bool LinkBreakPrefix(ref SosigLink __instance, bool isStart, DamageClass damClass)
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			SosigPatch.sosigDiesSkip++;
			SosigHandDropPatch.skip++;
			SosigSlotDetachPatch.skip++;
			SosigPatch.sosigSetBodyStateSkip++;
			if (sosigLinkBreakSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null)
			{
				if (trackedSosig.data.controller != GameManager.ID)
				{
					return false;
				}
				int num = -1;
				for (int i = 0; i < __instance.S.Links.Count; i++)
				{
					if ((Object)(object)__instance.S.Links[i] == (Object)(object)__instance)
					{
						num = i;
						break;
					}
				}
				if (num == -1)
				{
					Mod.LogError("LinkBreakPrefix called on link whos sosig doesn't have the link");
				}
				else if (ThreadManager.host)
				{
					ServerSend.SosigLinkBreak(trackedSosig.data.trackedID, num, isStart, (byte)damClass);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigLinkBreak(trackedSosig.data.trackedID, num, isStart, damClass);
				}
			}
			return true;
		}

		private static void LinkBreakPostfix()
		{
			SosigPatch.sosigDiesSkip--;
			SosigHandDropPatch.skip--;
			SosigSlotDetachPatch.skip--;
			SosigPatch.sosigSetBodyStateSkip--;
		}

		private static void LinkSeverPrefix(ref SosigLink __instance, DamageClass damClass, bool isPullApart)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			SosigPatch.sosigDiesSkip++;
			SosigHandDropPatch.skip++;
			SosigSlotDetachPatch.skip++;
			SosigPatch.sosigSetBodyStateSkip++;
			if (sosigLinkSeverSkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			int num = -1;
			for (int i = 0; i < __instance.S.Links.Count; i++)
			{
				if ((Object)(object)__instance.S.Links[i] == (Object)(object)__instance)
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				Mod.LogError("LinkSeverPrefix called on link whos sosig doesn't have the link");
			}
			else if (ThreadManager.host)
			{
				ServerSend.SosigLinkSever(trackedSosig.data.trackedID, num, (byte)damClass, isPullApart);
			}
			else if (trackedSosig.data.trackedID != -1)
			{
				ClientSend.SosigLinkSever(trackedSosig.data.trackedID, num, damClass, isPullApart);
			}
		}

		private static void LinkSeverPostfix()
		{
			SosigPatch.sosigDiesSkip--;
			SosigHandDropPatch.skip--;
			SosigSlotDetachPatch.skip--;
			SosigPatch.sosigSetBodyStateSkip--;
		}

		private static void LinkVaporizePrefix(ref SosigLink __instance, int IFF)
		{
			SosigPatch.sosigDiesSkip++;
			SosigHandDropPatch.skip++;
			SosigSlotDetachPatch.skip++;
			SosigPatch.sosigSetBodyStateSkip++;
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.SosigVaporize(trackedSosig.data.trackedID, IFF);
				}
				else if (trackedSosig.data.trackedID != -1)
				{
					ClientSend.SosigVaporize(trackedSosig.data.trackedID, IFF);
				}
			}
		}

		private static void LinkVaporizePostfix()
		{
			SosigPatch.sosigDiesSkip--;
			SosigHandDropPatch.skip--;
			SosigSlotDetachPatch.skip--;
			SosigPatch.sosigSetBodyStateSkip--;
		}
	}
	internal class SosigIFFPatch
	{
		public static int skip;

		private static void SetIFFPrefix(ref Sosig __instance, int i)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			if (trackedSosig.data.trackedID == -1)
			{
				TrackedSosig.unknownSetIFFs.Add(trackedSosig.data.localWaitingIndex, i);
				return;
			}
			trackedSosig.sosigData.IFF = (byte)i;
			if (ThreadManager.host)
			{
				ServerSend.SosigSetIFF(trackedSosig.data.trackedID, i);
			}
			else
			{
				ClientSend.SosigSetIFF(trackedSosig.data.trackedID, i);
			}
		}

		private static void SetOriginalIFFPrefix(ref Sosig __instance, int i)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			if (trackedSosig.data.trackedID == -1)
			{
				TrackedSosig.unknownSetOriginalIFFs.Add(trackedSosig.data.localWaitingIndex, i);
				return;
			}
			trackedSosig.sosigData.IFF = (byte)i;
			if (ThreadManager.host)
			{
				ServerSend.SosigSetOriginalIFF(trackedSosig.data.trackedID, i);
			}
			else
			{
				ClientSend.SosigSetOriginalIFF(trackedSosig.data.trackedID, i);
			}
		}
	}
	internal class SosigEventReceivePatch
	{
		private static bool Prefix(ref Sosig __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				return false;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance) ? GameManager.trackedSosigBySosig[__instance] : ((Component)__instance).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null)
			{
				return trackedSosig.data.controller == GameManager.ID;
			}
			return true;
		}
	}
	internal class AutoMeaterUpdatePatch
	{
		private static bool Prefix(ref AutoMeater __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedAutoMeater trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance) ? GameManager.trackedAutoMeaterByAutoMeater[__instance] : ((Component)__instance).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				bool flag = trackedAutoMeater.data.controller == GameManager.ID;
				if (!flag && trackedAutoMeater.physicalAutoMeater.FireControl.Firearms[0].IsFlameThrower)
				{
					trackedAutoMeater.physicalAutoMeater.FireControl.Firearms[0].Tick(Time.deltaTime);
				}
				return flag;
			}
			return true;
		}
	}
	internal class AutoMeaterEventPatch
	{
		private static bool Prefix(ref AutoMeater __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedAutoMeater trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance) ? GameManager.trackedAutoMeaterByAutoMeater[__instance] : ((Component)__instance).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				return trackedAutoMeater.data.controller == GameManager.ID;
			}
			return true;
		}
	}
	internal class AutoMeaterSetStatePatch
	{
		public static int skip;

		private static void Postfix(ref AutoMeater __instance, AutoMeaterState s)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0)
			{
				return;
			}
			TrackedAutoMeater trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance) ? GameManager.trackedAutoMeaterByAutoMeater[__instance] : ((Component)__instance).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.AutoMeaterSetState(trackedAutoMeater.data.trackedID, (byte)s);
				}
				else if (trackedAutoMeater.data.trackedID != -1)
				{
					ClientSend.AutoMeaterSetState(trackedAutoMeater.data.trackedID, (byte)s);
				}
			}
		}
	}
	internal class AutoMeaterUpdateFlightPatch
	{
		private static bool Prefix(ref AutoMeater __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedAutoMeater trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance) ? GameManager.trackedAutoMeaterByAutoMeater[__instance] : ((Component)__instance).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				return trackedAutoMeater.data.controller == GameManager.ID;
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(AutoMeaterUpdateFlightPatch), "SetAutoMeaterBladesActive", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(AutoMeaterUpdateFlightPatch), "SetAutoMeaterBladesActive", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldfld && val.operand.ToString().Contains("UsesBlades"))
				{
					list.InsertRange(i + 2, flag2 ? list2 : list3);
					flag = true;
					flag2 = !flag2;
				}
			}
			if (!flag)
			{
				Mod.LogError("AutoMeaterUpdateFlightPatch Transpiler not applied!");
			}
			return list;
		}

		public static void SetAutoMeaterBladesActive(AutoMeater autoMeater, bool active)
		{
			TrackedAutoMeater trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(autoMeater) ? GameManager.trackedAutoMeaterByAutoMeater[autoMeater] : ((Component)autoMeater).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.AutoMeaterSetBladesActive(trackedAutoMeater.data.trackedID, active);
				}
				else if (trackedAutoMeater.data.trackedID != -1)
				{
					ClientSend.AutoMeaterSetBladesActive(trackedAutoMeater.data.trackedID, active);
				}
			}
		}
	}
	internal class AutoMeaterFirearmFireShotPatch
	{
		public static int skip;

		public static bool angleOverride;

		public static Vector3 muzzleAngles;

		private static void Prefix()
		{
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at AutoMeaterFirearmFireShotPatch, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
		}

		private static void Postfix(ref AutoMeaterFirearm __instance)
		{
			//IL_00b0: 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)
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				return;
			}
			TrackedAutoMeater trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance.M) ? GameManager.trackedAutoMeaterByAutoMeater[__instance.M] : ((Component)__instance.M).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedAutoMeater.data.controller == 0)
					{
						ServerSend.AutoMeaterFirearmFireShot(0, trackedAutoMeater.data.trackedID, __instance.Muzzle.localEulerAngles);
					}
				}
				else if (trackedAutoMeater.data.controller == Client.singleton.ID && trackedAutoMeater.data.trackedID != -1)
				{
					ClientSend.AutoMeaterFirearmFireShot(trackedAutoMeater.data.trackedID, __instance.Muzzle.localEulerAngles);
				}
			}
			Mod.skipAllInstantiates--;
		}

		public static Vector3 GetMuzzleAngles(Vector3 currentAngles)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (angleOverride)
			{
				angleOverride = false;
				return muzzleAngles;
			}
			return currentAngles;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(AutoMeaterFirearm), "Muzzle")));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(AutoMeaterFirearm), "Muzzle")));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Transform), "get_localEulerAngles", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(AutoMeaterFirearmFireShotPatch), "GetMuzzleAngles", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Transform), "set_localEulerAngles", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("set_localEulerAngles"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("AutoMeaterFirearmFireShotPatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class AutoMeaterFirearmFireAtWillPatch
	{
		public static int skip;

		private static void Prefix(ref AutoMeaterFirearm __instance, bool b, float d)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0 || __instance.m_fireAtWill == b)
			{
				return;
			}
			TrackedAutoMeater trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance.M) ? GameManager.trackedAutoMeaterByAutoMeater[__instance.M] : ((Component)__instance.M).GetComponent<TrackedAutoMeater>());
			if (!((Object)(object)trackedAutoMeater != (Object)null) || trackedAutoMeater.data.controller != GameManager.ID)
			{
				return;
			}
			int firearmIndex = -1;
			for (int i = 0; i < trackedAutoMeater.physicalAutoMeater.FireControl.Firearms.Count; i++)
			{
				if (trackedAutoMeater.physicalAutoMeater.FireControl.Firearms[i] == __instance)
				{
					firearmIndex = i;
					break;
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.AutoMeaterFirearmFireAtWill(trackedAutoMeater.data.trackedID, firearmIndex, b, d);
			}
			else
			{
				ClientSend.AutoMeaterFirearmFireAtWill(trackedAutoMeater.data.trackedID, firearmIndex, b, d);
			}
		}
	}
	internal class EncryptionRespawnRandSubPatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EncryptionRespawnRandSubPatch), "RespawnSubTarg", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val != null && val.operand != null && val.operand.ToString().Contains("get_activeSelf"))
				{
					list.InsertRange(i + 2, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("EncryptionRespawnRandSubPatch Transpiler not applied!");
			}
			return list;
		}

		public static void RespawnSubTarg(TNH_EncryptionTarget encryption, int index)
		{
			if (!((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			TrackedEncryption trackedEncryption = (GameManager.trackedEncryptionByEncryption.ContainsKey(encryption) ? GameManager.trackedEncryptionByEncryption[encryption] : ((Component)encryption).GetComponent<TrackedEncryption>());
			if (!((Object)(object)trackedEncryption != (Object)null) || trackedEncryption.data.controller != GameManager.ID)
			{
				return;
			}
			trackedEncryption.encryptionData.subTargsActive[index] = true;
			if (ThreadManager.host)
			{
				ServerSend.EncryptionRespawnSubTarg(trackedEncryption.data.trackedID, index);
			}
			else if (trackedEncryption.data.trackedID == -1)
			{
				if (TrackedEncryption.unknownSpawnSubTarg.TryGetValue(trackedEncryption.data.localWaitingIndex, out var value))
				{
					value.Add(index);
					return;
				}
				TrackedEncryption.unknownSpawnSubTarg.Add(trackedEncryption.data.localWaitingIndex, new List<int> { index });
			}
			else
			{
				ClientSend.EncryptionRespawnSubTarg(trackedEncryption.data.trackedID, index);
			}
		}
	}
	internal class EncryptionSpawnGrowthPatch
	{
		public static int skip;

		private static void Prefix(ref TNH_EncryptionTarget __instance, int index, Vector3 point)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			Mod.LogInfo("EncryptionSpawnGrowthPatch prefix");
			if (skip > 0 || !((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			TrackedEncryption trackedEncryption = (GameManager.trackedEncryptionByEncryption.ContainsKey(__instance) ? GameManager.trackedEncryptionByEncryption[__instance] : ((Component)__instance).GetComponent<TrackedEncryption>());
			if (!((Object)(object)trackedEncryption != (Object)null) || trackedEncryption.data.controller != GameManager.ID)
			{
				return;
			}
			trackedEncryption.encryptionData.subTargsActive[index] = true;
			Vector3 val = point - trackedEncryption.physicalEncryption.Tendrils[index].transform.position;
			if (ThreadManager.host)
			{
				Mod.LogInfo("\rServer sending");
				ServerSend.EncryptionSpawnGrowth(trackedEncryption.data.trackedID, index, point);
			}
			else if (trackedEncryption.data.trackedID == -1)
			{
				if (TrackedEncryption.unknownSpawnGrowth.TryGetValue(trackedEncryption.data.localWaitingIndex, out var value))
				{
					value.Add(new KeyValuePair<int, Vector3>(index, point));
					return;
				}
				TrackedEncryption.unknownSpawnGrowth.Add(trackedEncryption.data.localWaitingIndex, new List<KeyValuePair<int, Vector3>>
				{
					new KeyValuePair<int, Vector3>(index, point)
				});
			}
			else
			{
				ClientSend.EncryptionSpawnGrowth(trackedEncryption.data.trackedID, index, point);
			}
		}
	}
	internal class EncryptionResetGrowthPatch
	{
		public static int skip;

		private static bool Prefix(ref TNH_EncryptionTarget __instance, int index, Vector3 point)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				TrackedEncryption trackedEncryption = (GameManager.trackedEncryptionByEncryption.ContainsKey(__instance) ? GameManager.trackedEncryptionByEncryption[__instance] : ((Component)__instance).GetComponent<TrackedEncryption>());
				if ((Object)(object)trackedEncryption != (Object)null)
				{
					if (trackedEncryption.data.controller == GameManager.ID)
					{
						Vector3 val = point - __instance.Tendrils[index].transform.position;
						if (ThreadManager.host)
						{
							ServerSend.EncryptionResetGrowth(trackedEncryption.data.trackedID, index, point);
						}
						else if (trackedEncryption.data.trackedID == -1)
						{
							if (TrackedEncryption.unknownResetGrowth.TryGetValue(trackedEncryption.data.localWaitingIndex, out var value))
							{
								value.Add(new KeyValuePair<int, Vector3>(index, point));
							}
							else
							{
								TrackedEncryption.unknownResetGrowth.Add(trackedEncryption.data.localWaitingIndex, new List<KeyValuePair<int, Vector3>>
								{
									new KeyValuePair<int, Vector3>(index, point)
								});
							}
						}
						else
						{
							ClientSend.EncryptionResetGrowth(trackedEncryption.data.trackedID, index, point);
						}
						return true;
					}
					return false;
				}
			}
			return true;
		}
	}
	internal class EncryptionDisableSubtargPatch
	{
		private static bool wasActive;

		private static bool geoWasActive;

		private static TrackedEncryption trackedEncryption;

		private static void Prefix(ref TNH_EncryptionTarget __instance, int i)
		{
			if (!((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			trackedEncryption = (GameManager.trackedEncryptionByEncryption.ContainsKey(__instance) ? GameManager.trackedEncryptionByEncryption[__instance] : ((Component)__instance).GetComponent<TrackedEncryption>());
			if ((Object)(object)trackedEncryption != (Object)null)
			{
				wasActive = __instance.SubTargs[i].activeSelf;
				if (__instance.UsesRegeneratingSubtargs)
				{
					geoWasActive = ((Component)__instance.SubTargGeo[i]).gameObject.activeSelf;
				}
			}
		}

		private static void Postfix(ref TNH_EncryptionTarget __instance, int i)
		{
			if (!((Object)(object)Mod.managerObject != (Object)null) || !((Object)(object)__instance != (Object)null) || !((Object)(object)trackedEncryption != (Object)null))
			{
				return;
			}
			bool flag = false;
			if (wasActive && !__instance.SubTargs[i].activeSelf)
			{
				trackedEncryption.encryptionData.subTargsActive[i] = false;
				flag = true;
			}
			if (__instance.UsesRegeneratingSubtargs && geoWasActive && !((Component)__instance.SubTargGeo[i]).gameObject.activeSelf)
			{
				trackedEncryption.encryptionData.subTargGeosActive[i] = false;
				flag = true;
			}
			if (!flag)
			{
				return;
			}
			if (ThreadManager.host)
			{
				ServerSend.EncryptionDisableSubtarg(trackedEncryption.data.trackedID, i);
			}
			else if (trackedEncryption.data.trackedID == -1)
			{
				if (TrackedEncryption.unknownDisableSubTarg.TryGetValue(trackedEncryption.data.localWaitingIndex, out var value))
				{
					value.Add(i);
					return;
				}
				TrackedEncryption.unknownDisableSubTarg.Add(trackedEncryption.data.localWaitingIndex, new List<int> { i });
			}
			else
			{
				ClientSend.EncryptionDisableSubtarg(trackedEncryption.data.trackedID, i);
			}
		}
	}
	internal class LAPD2019ActionPatch
	{
		public static int loadBatterySkip;

		public static int extractBatterySkip;

		private static void LoadBatteryPrefix(ref LAPD2019 __instance, LAPD2019Battery battery)
		{
			if (loadBatterySkip > 0 || !((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			TrackedItem trackedItem2 = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)battery) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)battery] : ((Component)battery).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && (Object)(object)trackedItem2 != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.LAPD2019LoadBattery(0, trackedItem.data.trackedID, trackedItem.data.trackedID);
				}
				else
				{
					ClientSend.LAPD2019LoadBattery(trackedItem.data.trackedID, trackedItem.data.trackedID);
				}
			}
		}

		private static void ExtractBatteryPrefix(ref LAPD2019 __instance)
		{
			if (extractBatterySkip > 0 || !((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)__instance) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.LAPD2019ExtractBattery(0, trackedItem.data.trackedID);
				}
				else
				{
					ClientSend.LAPD2019ExtractBattery(trackedItem.data.trackedID);
				}
			}
		}
	}
	internal class SosigTargetPrioritySystemPatch
	{
		public static int BoolArrToInt(bool[] arr)
		{
			int num = 0;
			for (int i = 0; i < arr.Length; i++)
			{
				if (arr[i])
				{
					num |= 1 << i;
				}
			}
			return num;
		}

		public static bool[] IntToBoolArr(int i)
		{
			bool[] array = new bool[32];
			for (int num = array.Length - 1; num >= 0; num--)
			{
				array[num] = ((i >> num) | 1) == 1;
			}
			return array;
		}

		private static void Postfix(ref SosigTargetPrioritySystem __instance, ref AIEntity ___E)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedSosig component = ((Component)___E).GetComponent<TrackedSosig>();
			if ((Object)(object)component != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.SosigPriorityIFFChart(0, component.data.trackedID, BoolArrToInt(__instance.IFFChart));
				}
				else if (component.data.trackedID != -1)
				{
					ClientSend.SosigPriorityIFFChart(component.data.trackedID, BoolArrToInt(__instance.IFFChart));
				}
				else if (TrackedSosig.unknownIFFChart.ContainsKey(component.data.localWaitingIndex))
				{
					TrackedSosig.unknownIFFChart[component.data.localWaitingIndex] = BoolArrToInt(__instance.IFFChart);
				}
				else
				{
					TrackedSosig.unknownIFFChart.Add(component.data.localWaitingIndex, BoolArrToInt(__instance.IFFChart));
				}
			}
		}
	}
	internal class SimpleLauncher2CycleModePatch
	{
		private static bool Prefix(SimpleLauncher2 __instance)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected I4, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if ((int)__instance.Mode == 0)
				{
					__instance.Mode = (fMode)1;
				}
				else if ((int)__instance.Mode == 1)
				{
					__instance.Mode = (fMode)0;
				}
				else if ((int)__instance.Mode == 2)
				{
					__instance.Mode = (fMode)0;
				}
				((FVRPhysicalObject)__instance).SetAnimatedComponent(__instance.ModeSwitch, ((Vector3)(ref __instance.ModeVars))[(int)__instance.Mode], __instance.ModeSwitch_Interp, __instance.ModeSwitch_Axis);
				((FVRFireArm)__instance).PlayAudioEvent((FirearmAudioEventType)15, 1f);
				return false;
			}
			return true;
		}
	}
	internal class PinnedGrenadePatch
	{
		private static bool exploded;

		private static bool UpdatePrefix(PinnedGrenade __instance, bool ___m_hasSploded, List<PinnedGrenadeRing> ___m_rings, ref bool ___m_isPinPulled)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			exploded = ___m_hasSploded;
			if (__instance.SpawnOnSplode != null && __instance.SpawnOnSplode.Count > 0 && (Object)(object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1] != (Object)null && int.TryParse(((Object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1]).name, out var result))
			{
				if (TrackedObject.trackedReferences.Length <= result || (Object)(object)TrackedObject.trackedReferences[result] == (Object)null || TrackedObject.trackedReferences[result].data.controller == GameManager.ID)
				{
					return true;
				}
				bool flag = ___m_isPinPulled;
				if (___m_rings.Count > 0)
				{
					___m_isPinPulled = true;
					for (int i = 0; i < ___m_rings.Count; i++)
					{
						if (!___m_rings[i].HasPinDetached())
						{
							___m_isPinPulled = false;
						}
					}
				}
				if ((flag != ___m_isPinPulled) & ___m_isPinPulled)
				{
					if (ThreadManager.host)
					{
						ServerSend.PinnedGrenadePullPin(TrackedObject.trackedReferences[result].data.trackedID);
					}
					else
					{
						ClientSend.PinnedGrenadePullPin(TrackedObject.trackedReferences[result].data.trackedID);
					}
				}
				return false;
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)5));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(PinnedGrenade), "SpawnOnSplode")));
			list3.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(List<GameObject>), "get_Count", (Type[])null, (Type[])null)));
			list3.Add(new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Sub, (object)null));
			Label label = il.DefineLabel();
			list3.Add(new CodeInstruction(OpCodes.Beq, (object)label));
			Label label2 = il.DefineLabel();
			CodeInstruction item = new CodeInstruction(OpCodes.Br, (object)label2);
			list3.Add(item);
			CodeInstruction val = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
			val.labels.Add(label);
			list3.Add(val);
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PinnedGrenadePatch), "SkipLast", (Type[])null, (Type[])null)));
			Label label3 = il.DefineLabel();
			list3.Add(new CodeInstruction(OpCodes.Brtrue, (object)label3));
			list3.Add(item);
			CodeInstruction val2 = new CodeInstruction(OpCodes.Ldloc_S, (object)4);
			val2.labels.Add(label3);
			list3.Add(val2);
			list3.Add(new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Add, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Stloc_S, (object)4));
			CodeInstruction val3 = new CodeInstruction(OpCodes.Br, (object)null);
			list3.Add(val3);
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val4 = list[i];
				if (!flag3 && val4.opcode == OpCodes.Ldfld && val4.operand.ToString().Contains("SpawnOnSplode"))
				{
					val3.operand = list[i - 2].operand;
					list[i - 1].labels.Add(label2);
					list.InsertRange(i - 1, list3);
					flag3 = true;
					flag = true;
				}
				if (val4.opcode == OpCodes.Stloc_S && val4.operand.ToString().Equals("UnityEngine.GameObject (5)"))
				{
					list.InsertRange(i + 1, list2);
					flag2 = true;
					break;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("PinnedGrenadePatch UpdateTranspiler not applied!");
			}
			return list;
		}

		public static bool SkipLast(PinnedGrenade grenade)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return false;
			}
			int result;
			return grenade.SpawnOnSplode != null && grenade.SpawnOnSplode.Count > 0 && ((Object)(object)grenade.SpawnOnSplode[grenade.SpawnOnSplode.Count - 1] == (Object)null || int.TryParse(((Object)grenade.SpawnOnSplode[grenade.SpawnOnSplode.Count - 1]).name, out result));
		}

		private static void UpdatePostfix(PinnedGrenade __instance, bool ___m_hasSploded)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || !(!exploded && ___m_hasSploded))
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.trackedID != -1 && trackedItem.data.controller == GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.PinnedGrenadeExplode(0, trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.PinnedGrenadeExplode(trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
			}
		}

		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PinnedGrenadePatch), "GrenadeControlled", (Type[])null, (Type[])null)));
			Label label = il.DefineLabel();
			list3.Add(new CodeInstruction(OpCodes.Brtrue, (object)label));
			list3.Add(new CodeInstruction(OpCodes.Ret, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Call && val.operand.ToString().Contains("OnCollisionEnter"))
				{
					list[i + 1].labels.Add(label);
					list.InsertRange(i + 1, list3);
					flag = true;
				}
				if (val.opcode == OpCodes.Stloc_1)
				{
					list.InsertRange(i + 1, list2);
					flag2 = true;
					break;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("PinnedGrenadePatch CollisionTranspiler not applied!");
			}
			return list;
		}

		public static bool GrenadeControlled(PinnedGrenade grenade)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (grenade.SpawnOnSplode != null && grenade.SpawnOnSplode.Count > 0 && (Object)(object)grenade.SpawnOnSplode[grenade.SpawnOnSplode.Count - 1] != (Object)null && int.TryParse(((Object)grenade.SpawnOnSplode[grenade.SpawnOnSplode.Count - 1]).name, out var result))
			{
				return TrackedObject.trackedReferences.Length <= result && (Object)(object)TrackedObject.trackedReferences[result] != (Object)null && TrackedObject.trackedReferences[result].data.controller == GameManager.ID;
			}
			return true;
		}

		public static void ExplodePinnedGrenade(PinnedGrenade grenade, Vector3 pos)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			grenade.m_hasSploded = true;
			int result;
			for (int i = 0; i < grenade.SpawnOnSplode.Count && (i != grenade.SpawnOnSplode.Count - 1 || !int.TryParse(((Object)grenade.SpawnOnSplode[i]).name, out result)); i++)
			{
				GameObject val = Object.Instantiate<GameObject>(grenade.SpawnOnSplode[i], pos, Quaternion.identity);
				Explosion component = val.GetComponent<Explosion>();
				if ((Object)(object)component != (Object)null)
				{
					component.IFF = grenade.IFF;
				}
				ExplosionSound component2 = val.GetComponent<ExplosionSound>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.IFF = grenade.IFF;
				}
				GrenadeExplosion component3 = val.GetComponent<GrenadeExplosion>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.IFF = grenade.IFF;
				}
			}
			if ((Object)(object)grenade.SmokeEmitter != (Object)null)
			{
				grenade.SmokeEmitter.Engaged = true;
				return;
			}
			if (((FVRInteractiveObject)grenade).IsHeld)
			{
				((FVRInteractiveObject)grenade).m_hand.ForceSetInteractable((FVRInteractiveObject)null);
				((FVRInteractiveObject)grenade).EndInteraction(((FVRInteractiveObject)grenade).m_hand);
			}
			Object.Destroy((Object)(object)((Component)grenade).gameObject);
		}
	}
	internal class FusePatch
	{
		public static int igniteSkip;

		private static void IgnitePostfix(FVRFuse __instance, ref bool ___m_isIgnited)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(__instance.Dynamite, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if (!((Object)(object)trackedItem != (Object)null))
			{
				return;
			}
			if (trackedItem.data.controller != GameManager.ID)
			{
				___m_isIgnited = false;
			}
			if (igniteSkip == 0)
			{
				if (ThreadManager.host)
				{
					ServerSend.FuseIgnite(trackedItem.data.trackedID);
				}
				else
				{
					ClientSend.FuseIgnite(trackedItem.data.trackedID);
				}
			}
		}

		private static void BoomPrefix(FVRFuse __instance, ref bool ___m_isIgnited)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(__instance.Dynamite, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller == GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.FuseBoom(trackedItem.data.trackedID);
				}
				else
				{
					ClientSend.FuseBoom(trackedItem.data.trackedID);
				}
			}
		}
	}
	internal class MolotovPatch
	{
		public static int shatterSkip;

		public static int damageSkip;

		private static bool ShatterPrefix(Molotov __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || shatterSkip > 0)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller != GameManager.ID)
				{
					return false;
				}
				if (ThreadManager.host)
				{
					ServerSend.MolotovShatter(trackedItem.data.trackedID, __instance.Igniteable.IsOnFire());
				}
				else
				{
					ClientSend.MolotovShatter(trackedItem.data.trackedID, __instance.Igniteable.IsOnFire());
				}
			}
			return true;
		}

		private static bool DamagePrefix(Molotov __instance, Damage d)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || damageSkip > 0)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.MolotovDamage(trackedItem.itemData, d);
				}
				else
				{
					ClientSend.MolotovDamage(trackedItem.data.trackedID, d);
				}
				return false;
			}
			return true;
		}
	}
	internal class EncryptionPatch
	{
		public static int updateDisplaySkip;

		public static bool preActive;

		public static int cascadingDestroyIndex;

		public static int cascadingDestroyDepth;

		private static TrackedEncryption trackedEncryption;

		private static bool UpdatePrefix(TNH_EncryptionTarget __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (__instance.SpawnPoints != null && __instance.SpawnPoints.Count > 0 && int.TryParse(((Object)__instance.SpawnPoints[__instance.SpawnPoints.Count - 1]).name, out var result))
			{
				return TrackedEncryption.trackedEncryptionReferences.Length <= result || (Object)(object)TrackedEncryption.trackedEncryptionReferences[result] == (Object)null || TrackedEncryption.trackedEncryptionReferences[result].data.controller == GameManager.ID;
			}
			return true;
		}

		private static bool FixedUpdatePrefix(TNH_EncryptionTarget __instance)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (__instance.SpawnPoints != null && __instance.SpawnPoints.Count > 0 && int.TryParse(((Object)__instance.SpawnPoints[__instance.SpawnPoints.Count - 1]).name, out var result))
			{
				if (TrackedEncryption.trackedEncryptionReferences.Length <= result || (Object)(object)TrackedEncryption.trackedEncryptionReferences[result] == (Object)null || TrackedEncryption.trackedEncryptionReferences[result].data.controller == GameManager.ID)
				{
					return true;
				}
				if (__instance.UseReturnToSpawnForce && (Object)(object)__instance.m_returnToSpawnLine != (Object)null)
				{
					__instance.UpdateLine();
				}
				if ((int)__instance.Type == 9 && __instance.isOrthagonalBeamFiring)
				{
					for (int i = 0; i < __instance.BeamDirs.Count; i++)
					{
						Vector3 val = ((Component)__instance).transform.rotation * __instance.BeamDirs[i];
						float num = 200f;
						if (Physics.Raycast(__instance.RB.position, val, ref __instance.m_hit, 200f, LayerMask.op_Implicit(__instance.OrthagonalBeamLM), (QueryTriggerInteraction)2))
						{
							num = ((RaycastHit)(ref __instance.m_hit)).distance;
						}
						__instance.OrthagonalBeams[i].rotation = Quaternion.LookRotation(val);
						__instance.OrthagonalBeams[i].localScale = new Vector3(0.06f, 0.06f, num);
						((Component)__instance.HitPoints[i]).transform.position = ((Component)__instance).transform.position + val * num;
					}
				}
				return false;
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Dup, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(GameObject), "get_activeSelf", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stsfld, (object)AccessTools.Field(typeof(EncryptionPatch), "preActive")));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EncryptionPatch), "ActivateSubTargGeo", (Type[])null, (Type[])null)));
			List<CodeInstruction> list4 = new List<CodeInstruction>();
			list4.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list4.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list4.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EncryptionPatch), "ActivateSubTarg", (Type[])null, (Type[])null)));
			bool[] array = new bool[4];
			bool flag = false;
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if ((val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("SetActive"))
				{
					if (flag)
					{
						list.InsertRange(i + 1, list4);
						array[0] = true;
						break;
					}
					list.InsertRange(i + 1, list3);
					array[1] = true;
					flag = true;
				}
				if ((val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_gameObject"))
				{
					list.InsertRange(i + 1, list2);
					array[2] = true;
				}
				if ((val.opcode == OpCodes.Callvirt || val.opcode == OpCodes.Call) && val.operand.ToString().Contains("get_Item"))
				{
					num++;
					if (num == 4)
					{
						list.InsertRange(i + 1, list2);
						array[3] = true;
					}
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (!array[j])
				{
					Mod.LogError("EncryptionPatch UpdateTranspiler not applied!");
					break;
				}
			}
			return list;
		}

		public static void ActivateSubTargGeo(TNH_EncryptionTarget encryption, int index)
		{
			if (!((Object)(object)Mod.managerObject != (Object)null) || preActive)
			{
				return;
			}
			TrackedEncryption trackedEncryption = (GameManager.trackedEncryptionByEncryption.TryGetValue(encryption, out trackedEncryption) ? trackedEncryption : ((Component)encryption).GetComponent<TrackedEncryption>());
			if (!((Object)(object)trackedEncryption != (Object)null))
			{
				return;
			}
			trackedEncryption.encryptionData.subTargGeosActive[index] = true;
			trackedEncryption.encryptionData.subTargsActive[index] = true;
			if (ThreadManager.host)
			{
				ServerSend.EncryptionRespawnSubTargGeo(trackedEncryption.data.trackedID, index);
			}
			else if (trackedEncryption.data.trackedID == -1)
			{
				if (TrackedEncryption.unknownSpawnSubTargGeo.TryGetValue(trackedEncryption.data.localWaitingIndex, out var value))
				{
					value.Add(index);
					return;
				}
				TrackedEncryption.unknownSpawnSubTargGeo.Add(trackedEncryption.data.localWaitingIndex, new List<int> { index });
			}
			else
			{
				ClientSend.EncryptionRespawnSubTargGeo(trackedEncryption.data.trackedID, index);
			}
		}

		public static void ActivateSubTarg(TNH_EncryptionTarget encryption, int index)
		{
			if (!((Object)(object)Mod.managerObject != (Object)null) || preActive)
			{
				return;
			}
			TrackedEncryption trackedEncryption = (GameManager.trackedEncryptionByEncryption.TryGetValue(encryption, out trackedEncryption) ? trackedEncryption : ((Component)encryption).GetComponent<TrackedEncryption>());
			if (!((Object)(object)trackedEncryption != (Object)null))
			{
				return;
			}
			trackedEncryption.encryptionData.subTargsActive[index] = true;
			if (ThreadManager.host)
			{
				ServerSend.EncryptionRespawnSubTarg(trackedEncryption.data.trackedID, index);
			}
			else if (trackedEncryption.data.trackedID == -1)
			{
				if (TrackedEncryption.unknownSpawnSubTarg.TryGetValue(trackedEncryption.data.localWaitingIndex, out var value))
				{
					value.Add(index);
					return;
				}
				TrackedEncryption.unknownSpawnSubTarg.Add(trackedEncryption.data.localWaitingIndex, new List<int> { index });
			}
			else
			{
				ClientSend.EncryptionRespawnSubTarg(trackedEncryption.data.trackedID, index);
			}
		}

		private static bool StartPrefix(TNH_EncryptionTarget __instance, ref int ___m_numHitsLeft, ref int ___m_maxHits, ref float ___m_damLeftForAHit, ref Vector3 ___initialPos, ref Quaternion ___m_fromRot, ref float ___m_timeTilWarp, ref float ___m_warpSpeed, ref List<Vector3> ___m_validAgilePos, ref int ___m_numSubTargsLeft, float ___AgileBaseSpeed, bool ___UsesRegeneratingSubtargs, ref float[] ___SubTargScales)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			EncryptionSpawnGrowthPatch.skip++;
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedEncryption = (GameManager.trackedEncryptionByEncryption.TryGetValue(__instance, out trackedEncryption) ? trackedEncryption : ((Component)__instance).GetComponent<TrackedEncryption>());
			if ((Object)(object)trackedEncryption != (Object)null && trackedEncryption.data.controller != GameManager.ID)
			{
				__instance.PrimeDics();
				___m_numHitsLeft = __instance.NumHitsTilDestroyed;
				___m_maxHits = __instance.NumHitsTilDestroyed;
				___m_damLeftForAHit = __instance.DamagePerHit;
				___initialPos = ((Component)__instance).transform.position;
				___m_fromRot = ((Component)__instance).transform.rotation;
				___m_timeTilWarp = 0f;
				___m_warpSpeed = Random.Range(4f, 5f) * ___AgileBaseSpeed;
				if (__instance.UsesAgileMovement)
				{
					___m_validAgilePos = new List<Vector3>();
				}
				if (__instance.UsesRegenerativeSubTarg)
				{
					for (int i = 0; i < __instance.Tendrils.Count; i++)
					{
						__instance.Tendrils[i].transform.SetParent((Transform)null);
						__instance.SubTargs[i].transform.SetParent((Transform)null);
					}
					___m_numSubTargsLeft = __instance.StartingRegenSubTarg;
				}
				if (__instance.UsesRefractiveTeleportation && (Object)(object)__instance.RefractivePreview != (Object)null)
				{
					__instance.RefractivePreview.SetParent((Transform)null);
				}
				if (___UsesRegeneratingSubtargs)
				{
					___SubTargScales = new float[__instance.SubTargs.Count];
				}
				if (__instance.UsesRecursiveSubTarg)
				{
					for (int j = 0; j < trackedEncryption.encryptionData.subTargsActive.Length; j++)
					{
						if (trackedEncryption.encryptionData.subTargsActive[j])
						{
							___m_numSubTargsLeft++;
						}
					}
				}
				if (__instance.UsesSubTargs && !__instance.UsesRecursiveSubTarg && !__instance.UsesRegenerativeSubTarg)
				{
					___m_numSubTargsLeft = __instance.SubTargs.Count;
				}
				return false;
			}
			return true;
		}

		private static void StartPostfix(TNH_EncryptionTarget __instance)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			EncryptionSpawnGrowthPatch.skip--;
			if (!((Object)(object)Mod.managerObject != (Object)null) || !((Object)(object)trackedEncryption != (Object)null) || trackedEncryption.data.controller != GameManager.ID)
			{
				return;
			}
			List<int> list = null;
			if ((int)__instance.Type == 3 || (int)__instance.Type == 7)
			{
				list = new List<int>();
				for (int i = 0; i < __instance.SubTargs.Count; i++)
				{
					if (__instance.SubTargs[i].activeSelf)
					{
						trackedEncryption.encryptionData.subTargsActive[i] = true;
						list.Add(i);
					}
				}
			}
			trackedEncryption.encryptionData.initialPos = trackedEncryption.physicalEncryption.initialPos;
			trackedEncryption.encryptionData.numHitsLeft = trackedEncryption.physicalEncryption.m_numHitsLeft;
			if (ThreadManager.host)
			{
				ServerSend.EncryptionInit(0, trackedEncryption.data.trackedID, list, trackedEncryption.encryptionData.initialPos, trackedEncryption.encryptionData.numHitsLeft);
			}
			else if (trackedEncryption.data.trackedID == -1)
			{
				if (TrackedEncryption.unknownInit.ContainsKey(trackedEncryption.data.localWaitingIndex))
				{
					TrackedEncryption.unknownInit[trackedEncryption.data.localWaitingIndex] = list;
				}
				else
				{
					TrackedEncryption.unknownInit.Add(trackedEncryption.data.localWaitingIndex, list);
				}
			}
			else
			{
				ClientSend.EncryptionInit(trackedEncryption.data.trackedID, list, trackedEncryption.encryptionData.initialPos, trackedEncryption.encryptionData.numHitsLeft);
			}
		}

		private static void UpdateDisplayPostfix(TNH_EncryptionTarget __instance)
		{
			if (updateDisplaySkip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedEncryption trackedEncryption = (GameManager.trackedEncryptionByEncryption.TryGetValue(__instance, out trackedEncryption) ? trackedEncryption : ((Component)__instance).GetComponent<TrackedEncryption>());
			if (!((Object)(object)trackedEncryption != (Object)null) || trackedEncryption.data.controller != GameManager.ID)
			{
				return;
			}
			trackedEncryption.encryptionData.numHitsLeft = __instance.m_numHitsLeft;
			if (ThreadManager.host)
			{
				ServerSend.UpdateEncryptionDisplay(trackedEncryption.data.trackedID, __instance.m_numHitsLeft);
			}
			else if (trackedEncryption.data.trackedID == -1)
			{
				if (TrackedEncryption.unknownUpdateDisplay.ContainsKey(trackedEncryption.data.localWaitingIndex))
				{
					TrackedEncryption.unknownUpdateDisplay[trackedEncryption.data.localWaitingIndex] = __instance.m_numHitsLeft;
				}
				else
				{
					TrackedEncryption.unknownUpdateDisplay.Add(trackedEncryption.data.localWaitingIndex, __instance.m_numHitsLeft);
				}
			}
			else
			{
				ClientSend.UpdateEncryptionDisplay(trackedEncryption.data.trackedID, __instance.m_numHitsLeft);
			}
		}

		private static IEnumerable<CodeInstruction> DestroyTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EncryptionPatch), "EncryptionSpawnOnDestroy", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Contains("4"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("EncryptionPatch DestroyTranspiler not applied!");
			}
			return list;
		}

		public static void EncryptionSpawnOnDestroy(TNH_EncryptionTarget encryption, int index, GameObject go)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				cascadingDestroyIndex = index;
				int num = ((Object)encryption).name.LastIndexOf("SubShard");
				if (num == -1)
				{
					cascadingDestroyDepth = 1;
				}
				else
				{
					cascadingDestroyDepth = 2 + ((Object)encryption).name[num + 8] - 65;
				}
				GameManager.SyncTrackedObjects(go.transform, controlEverything: true, null);
				cascadingDestroyIndex = 0;
				cascadingDestroyDepth = 0;
			}
		}

		private static bool FireGunPrefix(TNH_EncryptionTarget __instance)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || __instance.m_isDestroyed)
			{
				return true;
			}
			if (int.TryParse(((Object)__instance.SpawnPoints[__instance.SpawnPoints.Count - 1]).name, out var result))
			{
				TrackedEncryption trackedEncryption = TrackedEncryption.trackedEncryptionReferences[result];
				if ((Object)(object)trackedEncryption != (Object)null)
				{
					if (trackedEncryption.data.controller == GameManager.ID)
					{
						float[] array = new float[__instance.RefractiveMuzzles.Count];
						Vector3[] array2 = (Vector3[])(object)new Vector3[__instance.RefractiveMuzzles.Count];
						for (int i = 0; i < __instance.RefractiveMuzzles.Count; i++)
						{
							Vector3 position = __instance.RefractiveMuzzles[i].position;
							GameObject val = Object.Instantiate<GameObject>(__instance.RefractiveProjectile, position, __instance.RefractiveMuzzles[i].rotation);
							BallisticProjectile component = val.GetComponent<BallisticProjectile>();
							component.FlightVelocityMultiplier = 0.04f;
							float muzzleVelocityBase = component.MuzzleVelocityBase;
							component.Fire(muzzleVelocityBase, val.transform.forward, (FVRFireArm)null, true);
							array[i] = muzzleVelocityBase;
							array2[i] = val.transform.forward;
							if (ThreadManager.host)
							{
								ServerSend.EncryptionFireGun(trackedEncryption.data.trackedID, array, array2);
							}
							else
							{
								ClientSend.EncryptionFireGun(trackedEncryption.data.trackedID, array, array2);
							}
						}
						if ((Object)(object)__instance.GunShotProfile != (Object)null)
						{
							FVRSoundEnvironment val2 = __instance.PlayShotEvent(__instance.RefractiveMuzzles[0].position);
							float soundTravelDistanceMultByEnvironment = SM.GetSoundTravelDistanceMultByEnvironment(val2);
						}
					}
					return false;
				}
			}
			return true;
		}

		private static void SetNextPosPostfix(TNH_EncryptionTarget __instance)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || __instance.SpawnPoints == null || __instance.SpawnPoints.Count <= 0 || !int.TryParse(((Object)__instance.SpawnPoints[__instance.SpawnPoints.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedEncryption trackedEncryption = TrackedEncryption.trackedEncryptionReferences[result];
			if ((Object)(object)trackedEncryption != (Object)null)
			{
				trackedEncryption.encryptionData.refractivePreviewPos = __instance.RefractivePreview.position;
				if (ThreadManager.host)
				{
					ServerSend.EncryptionNextPos(trackedEncryption.data.trackedID, trackedEncryption.encryptionData.refractivePreviewPos);
				}
				else if (trackedEncryption.data.trackedID != -1)
				{
					ClientSend.EncryptionNextPos(trackedEncryption.data.trackedID, trackedEncryption.encryptionData.refractivePreviewPos);
				}
				else if (TrackedEncryption.unknownPreviewPos.ContainsKey(trackedEncryption.data.localWaitingIndex))
				{
					TrackedEncryption.unknownPreviewPos[trackedEncryption.data.localWaitingIndex] = trackedEncryption.encryptionData.refractivePreviewPos;
				}
				else
				{
					TrackedEncryption.unknownPreviewPos.Add(trackedEncryption.data.localWaitingIndex, trackedEncryption.encryptionData.refractivePreviewPos);
				}
			}
		}

		private static void WarpToNextPositionPostfix(TNH_EncryptionTarget __instance)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || __instance.m_isDestroyed || __instance.SpawnPoints == null || __instance.SpawnPoints.Count <= 0 || !int.TryParse(((Object)__instance.SpawnPoints[__instance.SpawnPoints.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedEncryption trackedEncryption = TrackedEncryption.trackedEncryptionReferences[result];
			if ((Object)(object)trackedEncryption != (Object)null)
			{
				trackedEncryption.encryptionData.refractiveShieldRot = __instance.RefractiveShield.rotation;
				if (ThreadManager.host)
				{
					ServerSend.EncryptionShieldRot(trackedEncryption.data.trackedID, trackedEncryption.encryptionData.refractiveShieldRot);
				}
				else if (trackedEncryption.data.trackedID != -1)
				{
					ClientSend.EncryptionShieldRot(trackedEncryption.data.trackedID, trackedEncryption.encryptionData.refractiveShieldRot);
				}
				else if (TrackedEncryption.unknownShieldRot.ContainsKey(trackedEncryption.data.localWaitingIndex))
				{
					TrackedEncryption.unknownShieldRot[trackedEncryption.data.localWaitingIndex] = trackedEncryption.encryptionData.refractiveShieldRot;
				}
				else
				{
					TrackedEncryption.unknownShieldRot.Add(trackedEncryption.data.localWaitingIndex, trackedEncryption.encryptionData.refractiveShieldRot);
				}
			}
		}
	}
	internal class FVRGrenadePatch
	{
		private static bool exploded;

		private static bool UpdatePrefix(FVRGrenade __instance, bool ___m_hasSploded, Dictionary<int, float> ___FuseTimings)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			exploded = ___m_hasSploded;
			if (___FuseTimings != null && ___FuseTimings.TryGetValue(-1, out var value))
			{
				int num = (int)value;
				return num <= 0 || TrackedObject.trackedReferences.Length <= num || (Object)(object)TrackedObject.trackedReferences[num] == (Object)null || TrackedObject.trackedReferences[num].data.controller == GameManager.ID;
			}
			return true;
		}

		private static void UpdatePostfix(FVRGrenade __instance, bool ___m_hasSploded)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || !(!exploded && ___m_hasSploded))
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller == GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.FVRGrenadeExplode(0, trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.FVRGrenadeExplode(trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
			}
		}

		public static void ExplodeGrenade(FVRGrenade grenade, Vector3 pos)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			grenade.m_hasSploded = true;
			if ((Object)(object)grenade.ExplosionFX != (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(grenade.ExplosionFX, ((Component)grenade).transform.position, Quaternion.identity);
				Explosion component = val.GetComponent<Explosion>();
				if ((Object)(object)component != (Object)null)
				{
					component.IFF = grenade.IFF;
				}
				ExplosionSound component2 = val.GetComponent<ExplosionSound>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.IFF = grenade.IFF;
				}
			}
			if ((Object)(object)grenade.ExplosionSoundFX != (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(grenade.ExplosionSoundFX, ((Component)grenade).transform.position, Quaternion.identity);
				Explosion component3 = val2.GetComponent<Explosion>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.IFF = grenade.IFF;
				}
				ExplosionSound component4 = val2.GetComponent<ExplosionSound>();
				if ((Object)(object)component4 != (Object)null)
				{
					component4.IFF = grenade.IFF;
				}
			}
			if ((Object)(object)grenade.SmokeEmitter != (Object)null)
			{
				grenade.SmokeEmitter.Engaged = true;
				return;
			}
			if (((FVRInteractiveObject)grenade).IsHeld)
			{
				((FVRInteractiveObject)grenade).m_hand.ForceSetInteractable((FVRInteractiveObject)null);
				((FVRInteractiveObject)grenade).EndInteraction(((FVRInteractiveObject)grenade).m_hand);
			}
			Object.Destroy((Object)(object)((Component)grenade).gameObject);
		}
	}
	internal class BangSnapPatch
	{
		public static int skip;

		private static void SplodePrefix(BangSnap __instance)
		{
			//IL_007f: 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)
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.BangSnapSplode(0, trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.BangSnapSplode(trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
			}
		}

		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BangSnapPatch), "Controlled", (Type[])null, (Type[])null)));
			Label label = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Brtrue, (object)label));
			list2.Add(new CodeInstruction(OpCodes.Ret, (object)null));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Brtrue)
				{
					list[i + 1].labels.Add(label);
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("BangSnapPatch CollisionTranspiler not applied!");
			}
			return list;
		}

		public static bool Controlled(BangSnap bangSnap)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)bangSnap, out trackedItem) ? trackedItem : ((Component)bangSnap).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				return trackedItem.data.controller == GameManager.ID;
			}
			return true;
		}
	}
	internal class C4DetonatePatch
	{
		public static int skip;

		private static void Prefix(C4 __instance)
		{
			//IL_007f: 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)
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.C4Detonate(0, trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.C4Detonate(trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
			}
		}
	}
	internal class ClaymoreMineDetonatePatch
	{
		public static int skip;

		private static void Prefix(ClaymoreMine __instance)
		{
			//IL_007f: 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)
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.ClaymoreMineDetonate(0, trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.ClaymoreMineDetonate(trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
			}
		}
	}
	internal class SLAMDetonatePatch
	{
		public static int skip;

		private static void Prefix(ClaymoreMine __instance)
		{
			//IL_007f: 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)
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.SLAMDetonate(0, trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
				else
				{
					ClientSend.SLAMDetonate(trackedItem.data.trackedID, ((Component)__instance).transform.position);
				}
			}
		}
	}
	internal class RoundPatch
	{
		public static int splodeSkip;

		private static IEnumerable<CodeInstruction> FixedUpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Expected O, but got Unknown
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Expected O, but got Unknown
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Expected O, but got Unknown
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Expected O, but got Unknown
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Expected O, but got Unknown
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Expected O, but got Unknown
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Expected O, but got Unknown
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Expected O, but got Unknown
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Expected O, but got Unknown
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Expected O, but got Unknown
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Expected O, but got Unknown
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Expected O, but got Unknown
			//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Expected O, but got Unknown
			//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0604: Expected O, but got Unknown
			//IL_0663: Unknown result type (might be due to invalid IL or missing references)
			//IL_066d: Expected O, but got Unknown
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0687: Expected O, but got Unknown
			//IL_0694: Unknown result type (might be due to invalid IL or missing references)
			//IL_069b: Expected O, but got Unknown
			//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Expected O, but got Unknown
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e8: Expected O, but got Unknown
			//IL_0747: Unknown result type (might be due to invalid IL or missing references)
			//IL_0751: Expected O, but got Unknown
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			//IL_076b: Expected O, but got Unknown
			//IL_0778: Unknown result type (might be due to invalid IL or missing references)
			//IL_077f: Expected O, but got Unknown
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b2: Expected O, but got Unknown
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cc: Expected O, but got Unknown
			LocalBuilder localBuilder = il.DeclareLocal(typeof(TrackedItem));
			localBuilder.SetLocalSymInfo("trackedItem");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Mod), "managerObject")));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Dup, (object)null));
			int count = list2.Count;
			Label label = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Brfalse_S, (object)label));
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameManager), "trackedItemByItem")));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloca_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Dictionary<FVRPhysicalObject, TrackedItem>), "TryGetValue", (Type[])null, (Type[])null)));
			int count2 = list2.Count;
			list2.Add(new CodeInstruction(OpCodes.Brtrue_S, (object)label));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Component), "GetComponent", (Type[])null, new Type[1] { typeof(TrackedItem) })));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)8));
			int count3 = list2.Count;
			Label label2 = il.DefineLabel();
			CodeInstruction val = new CodeInstruction(OpCodes.Brfalse_S, (object)label2);
			val.labels.Add(label);
			list2.Add(val);
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null)));
			int count4 = list2.Count;
			list2.Add(new CodeInstruction(OpCodes.Brtrue_S, (object)label2));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(TrackedItem), "data")));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(TrackedItemData), "get_controller", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameManager), "ID")));
			int count5 = list2.Count;
			Label label3 = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Bne_Un, (object)label3));
			Label label4 = il.DefineLabel();
			Label label5 = il.DefineLabel();
			Label label6 = il.DefineLabel();
			Label label7 = il.DefineLabel();
			Label label8 = il.DefineLabel();
			bool[] array = new bool[5];
			bool flag = false;
			bool flag2 = false;
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val2 = list[i];
				if (val2.opcode == OpCodes.Ldarg_0 && list[i + 1].opcode == OpCodes.Ldarg_0 && !flag)
				{
					val2.labels.Add(label2);
					list.InsertRange(i, list2);
					array[0] = true;
					i += list2.Count;
					flag = true;
				}
				if (val2.opcode == OpCodes.Ldarg_0 && list[i + 1].opcode == OpCodes.Ldnull && !flag2)
				{
					val2.labels.Add(label3);
					flag2 = true;
					Label label9 = il.DefineLabel();
					list2[count] = new CodeInstruction(OpCodes.Brfalse_S, (object)label9);
					list2[count2] = new CodeInstruction(OpCodes.Brtrue_S, (object)label9);
					CodeInstruction val3 = new CodeInstruction(OpCodes.Brfalse_S, (object)label4);
					val3.labels.Add(label9);
					list2[count3] = val3;
					list2[count4] = new CodeInstruction(OpCodes.Brtrue_S, (object)label4);
					list2[count5] = new CodeInstruction(OpCodes.Bne_Un, (object)label8);
				}
				if (val2.opcode == OpCodes.Callvirt && val2.operand.ToString().Contains("get_Count"))
				{
					switch (num)
					{
					case 1:
					{
						list[i - 2].labels.Add(label4);
						list.InsertRange(i - 2, list2);
						i += list2.Count;
						array[1] = true;
						Label label12 = il.DefineLabel();
						list2[count] = new CodeInstruction(OpCodes.Brfalse_S, (object)label12);
						list2[count2] = new CodeInstruction(OpCodes.Brtrue_S, (object)label12);
						CodeInstruction val6 = new CodeInstruction(OpCodes.Brfalse_S, (object)label5);
						val6.labels.Add(label12);
						list2[count3] = val6;
						list2[count4] = new CodeInstruction(OpCodes.Brtrue_S, (object)label5);
						list2[count5] = new CodeInstruction(OpCodes.Bne_Un, (object)label8);
						break;
					}
					case 2:
					{
						list[i - 2].labels.Add(label5);
						list.InsertRange(i - 2, list2);
						i += list2.Count;
						array[2] = true;
						Label label11 = il.DefineLabel();
						list2[count] = new CodeInstruction(OpCodes.Brfalse_S, (object)label11);
						list2[count2] = new CodeInstruction(OpCodes.Brtrue_S, (object)label11);
						CodeInstruction val5 = new CodeInstruction(OpCodes.Brfalse_S, (object)label6);
						val5.labels.Add(label11);
						list2[count3] = val5;
						list2[count4] = new CodeInstruction(OpCodes.Brtrue_S, (object)label6);
						list2[count5] = new CodeInstruction(OpCodes.Bne_Un, (object)label8);
						break;
					}
					case 3:
					{
						list[i - 2].labels.Add(label6);
						list.InsertRange(i - 2, list2);
						i += list2.Count;
						array[3] = true;
						Label label10 = il.DefineLabel();
						list2[count] = new CodeInstruction(OpCodes.Brfalse_S, (object)label10);
						list2[count2] = new CodeInstruction(OpCodes.Brtrue_S, (object)label10);
						CodeInstruction val4 = new CodeInstruction(OpCodes.Brfalse_S, (object)label7);
						val4.labels.Add(label10);
						list2[count3] = val4;
						list2[count4] = new CodeInstruction(OpCodes.Brtrue_S, (object)label7);
						list2[count5] = new CodeInstruction(OpCodes.Bne_Un, (object)label8);
						break;
					}
					case 5:
						list[i - 2].labels.Add(label7);
						list.InsertRange(i - 2, list2);
						array[4] = true;
						i += list2.Count;
						break;
					}
					num++;
				}
				if (val2.opcode == OpCodes.Ret)
				{
					val2.labels.Add(label8);
					break;
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (!array[j])
				{
					Mod.LogError("RoundPatch FixedUpdateTranspiler not applied!");
					break;
				}
			}
			return list;
		}

		private static bool SplodePrefix(FVRFireArmRound __instance, float velMultiplier, bool isRandomDir)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || splodeSkip > 0)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller != GameManager.ID)
				{
					__instance.isCookingOff = false;
					return false;
				}
				if (ThreadManager.host)
				{
					ServerSend.RoundSplode(trackedItem.data.trackedID, velMultiplier, isRandomDir);
				}
				else if (trackedItem.data.trackedID != -1)
				{
					ClientSend.RoundSplode(trackedItem.data.trackedID, velMultiplier, isRandomDir);
				}
			}
			return true;
		}
	}
	internal class MagazinePatch
	{
		public static int addRoundSkip;

		public static int loadSkip;

		private static IEnumerable<CodeInstruction> AddRoundClassTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MagazinePatch), "AddRound", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Bge)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("MagazinePatch AddRoundClassTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> AddRoundRoundTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(FVRFireArmRound), "RoundClass")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MagazinePatch), "AddRound", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Bge)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("MagazinePatch AddRoundRoundTranspiler not applied!");
			}
			return list;
		}

		public static void AddRound(FVRFireArmMagazine mag, FireArmRoundClass roundClass)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || addRoundSkip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)mag, out trackedItem) ? trackedItem : ((Component)mag).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.MagazineAddRound(trackedItem.data.trackedID, roundClass);
				}
				else
				{
					ClientSend.MagazineAddRound(trackedItem.data.trackedID, roundClass);
				}
			}
		}

		private static bool LoadFireArmPrefix(FVRFireArmMagazine __instance, FVRFireArm fireArm)
		{
			return Load(__instance, fireArm);
		}

		private static bool LoadIntoSecondaryPrefix(FVRFireArmMagazine __instance, FVRFireArm fireArm, int slot)
		{
			return Load(__instance, fireArm, slot);
		}

		private static bool Load(FVRFireArmMagazine magInstance, FVRFireArm fireArm, int slot = -1)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || loadSkip > 0)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)magInstance, out trackedItem) ? trackedItem : ((Component)magInstance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller != GameManager.ID)
				{
					return false;
				}
				TrackedItem trackedItem2 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)fireArm, out trackedItem2) ? trackedItem2 : ((Component)fireArm).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem2 != (Object)null && trackedItem2.data.controller != GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.MagazineLoad(trackedItem.data.trackedID, trackedItem2.data.trackedID, slot);
					}
					else
					{
						ClientSend.MagazineLoad(trackedItem.data.trackedID, trackedItem2.data.trackedID, slot);
					}
				}
			}
			return true;
		}

		private static bool LoadAttachablePrefix(FVRFireArmMagazine __instance, AttachableFirearm fireArm)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || loadSkip > 0)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller != GameManager.ID)
				{
					return false;
				}
				TrackedItem trackedItem2 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)fireArm.Attachment, out trackedItem2) ? trackedItem2 : ((Component)fireArm.Attachment).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem2 != (Object)null && trackedItem2.data.controller != GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.MagazineLoadAttachable(trackedItem.data.trackedID, trackedItem2.data.trackedID);
					}
					else
					{
						ClientSend.MagazineLoadAttachable(trackedItem.data.trackedID, trackedItem2.data.trackedID);
					}
				}
			}
			return true;
		}
	}
	internal class ClipPatch
	{
		public static int addRoundSkip;

		public static int loadSkip;

		private static IEnumerable<CodeInstruction> AddRoundClassTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ClipPatch), "AddRound", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Bge)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("ClipPatch AddRoundClassTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> AddRoundRoundTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(FVRFireArmRound), "RoundClass")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ClipPatch), "AddRound", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Bge)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("ClipPatch AddRoundClassTranspiler not applied!");
			}
			return list;
		}

		public static void AddRound(FVRFireArmClip clip, FireArmRoundClass roundClass)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || addRoundSkip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)clip, out trackedItem) ? trackedItem : ((Component)clip).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.ClipAddRound(trackedItem.data.trackedID, roundClass);
				}
				else
				{
					ClientSend.ClipAddRound(trackedItem.data.trackedID, roundClass);
				}
			}
		}

		private static bool LoadPrefix(FVRFireArmClip __instance, FVRFireArm fireArm)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || loadSkip > 0)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller != GameManager.ID)
				{
					return false;
				}
				TrackedItem trackedItem2 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)fireArm, out trackedItem2) ? trackedItem2 : ((Component)fireArm).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem2 != (Object)null && trackedItem2.data.controller != GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.ClipLoad(trackedItem.data.trackedID, trackedItem2.data.trackedID);
					}
					else
					{
						ClientSend.ClipLoad(trackedItem.data.trackedID, trackedItem2.data.trackedID);
					}
				}
			}
			return true;
		}
	}
	internal class SpeedloaderChamberPatch
	{
		public static int loadSkip;

		private static void AddRoundPrefix(SpeedloaderChamber __instance, FireArmRoundClass rclass)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || loadSkip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance.SpeedLoader, out trackedItem) ? trackedItem : ((Component)__instance.SpeedLoader).GetComponent<TrackedItem>());
			if (!((Object)(object)trackedItem != (Object)null) || trackedItem.data.controller == GameManager.ID)
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItem.physicalItem;
			Speedloader val = (Speedloader)(object)((physicalItem is Speedloader) ? physicalItem : null);
			int num = -1;
			for (int i = 0; i < val.Chambers.Count; i++)
			{
				if ((Object)(object)val.Chambers[i] == (Object)(object)__instance)
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				if (ThreadManager.host)
				{
					ServerSend.SpeedloaderChamberLoad(trackedItem.data.trackedID, rclass, num);
				}
				else
				{
					ClientSend.SpeedloaderChamberLoad(trackedItem.data.trackedID, rclass, num);
				}
			}
		}
	}
	internal class RemoteGunPatch
	{
		public static int chamberSkip;

		private static void ChamberCartridgePrefix(RemoteGun __instance, FVRFireArmRound round)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || chamberSkip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.RemoteGunChamber(trackedItem.data.trackedID, round.RoundClass, round.RoundType);
				}
				else
				{
					ClientSend.RemoteGunChamber(trackedItem.data.trackedID, round.RoundClass, round.RoundType);
				}
			}
		}
	}
	internal class ChamberPatch
	{
		public static int chamberSkip;

		private static void SetRoundClassPrefix(FVRFireArmChamber __instance, FireArmRoundClass rclass)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || chamberSkip > 0)
			{
				return;
			}
			TrackedItem trackedItem = null;
			Transform val = ((Component)__instance).transform;
			while ((Object)(object)val != (Object)null)
			{
				trackedItem = ((Component)val).GetComponent<TrackedItem>();
				if ((Object)(object)trackedItem != (Object)null)
				{
					break;
				}
				val = val.parent;
			}
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID && trackedItem.getChamberIndex != null)
			{
				int num = trackedItem.getChamberIndex(__instance);
				if (num == -1)
				{
					Mod.LogError("SetRound(Class) called on chamber attached to " + ((Object)trackedItem).name + " but chamber was not found on the item!");
				}
				else if (ThreadManager.host)
				{
					ServerSend.ChamberRound(trackedItem.data.trackedID, rclass, num);
				}
				else
				{
					ClientSend.ChamberRound(trackedItem.data.trackedID, rclass, num);
				}
			}
		}

		private static void SetRoundRoundPrefix(FVRFireArmChamber __instance, FVRFireArmRound round)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || chamberSkip > 0 || (Object)(object)round == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = null;
			Transform val = ((Component)__instance).transform;
			while ((Object)(object)val != (Object)null)
			{
				trackedItem = ((Component)val).GetComponent<TrackedItem>();
				if ((Object)(object)trackedItem != (Object)null)
				{
					break;
				}
				val = val.parent;
			}
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID && trackedItem.getChamberIndex != null)
			{
				int num = trackedItem.getChamberIndex(__instance);
				if (num == -1)
				{
					Mod.LogError("SetRound(Round) called on chamber attached to " + ((Object)trackedItem).name + " but chamber was not found on the item!");
				}
				else if (ThreadManager.host)
				{
					ServerSend.ChamberRound(trackedItem.data.trackedID, round.RoundClass, num);
				}
				else
				{
					ClientSend.ChamberRound(trackedItem.data.trackedID, round.RoundClass, num);
				}
			}
		}
	}
	internal class SpeedloaderPatch
	{
		private static IEnumerable<CodeInstruction> FixedUpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Expected O, but got Unknown
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Expected O, but got Unknown
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Expected O, but got Unknown
			LocalBuilder localBuilder = il.DeclareLocal(typeof(TrackedItem));
			localBuilder.SetLocalSymInfo("trackedItem");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Mod), "managerObject")));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Dup, (object)null));
			Label label = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Brfalse_S, (object)label));
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameManager), "trackedItemByItem")));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloca_S, (object)3));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Dictionary<FVRPhysicalObject, TrackedItem>), "TryGetValue", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Brtrue_S, (object)label));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Component), "GetComponent", (Type[])null, new Type[1] { typeof(TrackedItem) })));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			Label label2 = il.DefineLabel();
			CodeInstruction val = new CodeInstruction(OpCodes.Brfalse_S, (object)label2);
			val.labels.Add(label);
			list2.Add(val);
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Brtrue_S, (object)label2));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(TrackedItem), "data")));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(TrackedItemData), "get_controller", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameManager), "ID")));
			Label label3 = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Bne_Un, (object)label3));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val2 = list[i];
				if (val2.opcode == OpCodes.Stfld && val2.operand.ToString().Contains("TimeTilLoadAttempt") && !flag2)
				{
					list[i + 1].labels.Add(label2);
					list.InsertRange(i + 1, list2);
					i += list2.Count;
					flag = true;
					flag2 = true;
				}
				if (val2.opcode == OpCodes.Ret)
				{
					val2.labels.Add(label3);
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("SpeedloaderPatch FixedUpdateTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Expected O, but got Unknown
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Expected O, but got Unknown
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Expected O, but got Unknown
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Expected O, but got Unknown
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Expected O, but got Unknown
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Expected O, but got Unknown
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Expected O, but got Unknown
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Expected O, but got Unknown
			LocalBuilder localBuilder = il.DeclareLocal(typeof(TrackedItem));
			localBuilder.SetLocalSymInfo("trackedItem");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Mod), "managerObject")));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Dup, (object)null));
			int count = list2.Count;
			Label label = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Brfalse_S, (object)label));
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameManager), "trackedItemByItem")));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloca_S, (object)0));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Dictionary<FVRPhysicalObject, TrackedItem>), "TryGetValue", (Type[])null, (Type[])null)));
			int count2 = list2.Count;
			list2.Add(new CodeInstruction(OpCodes.Brtrue_S, (object)label));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Component), "GetComponent", (Type[])null, new Type[1] { typeof(TrackedItem) })));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			int count3 = list2.Count;
			Label label2 = il.DefineLabel();
			CodeInstruction val = new CodeInstruction(OpCodes.Brfalse_S, (object)label2);
			val.labels.Add(label);
			list2.Add(val);
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldnull, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null)));
			int count4 = list2.Count;
			list2.Add(new CodeInstruction(OpCodes.Brtrue_S, (object)label2));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(TrackedItem), "data")));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(TrackedItemData), "get_controller", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameManager), "ID")));
			Label label3 = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Bne_Un, (object)label3));
			Label label4 = il.DefineLabel();
			Label label5 = il.DefineLabel();
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val2 = list[i];
				if (val2.opcode == OpCodes.Callvirt && val2.operand.ToString().Contains("LoadCylinder"))
				{
					if (!flag3)
					{
						list[i - 4].labels.Add(label2);
						list.InsertRange(i - 4, list2);
						i += list2.Count;
						flag = true;
						flag3 = true;
						list2[count] = new CodeInstruction(OpCodes.Brfalse_S, (object)label4);
						list2[count3] = new CodeInstruction(OpCodes.Brfalse_S, (object)label5);
						list2[count3].labels.Add(label4);
						list2[count4] = new CodeInstruction(OpCodes.Brtrue_S, (object)label5);
						list2[count2] = new CodeInstruction(OpCodes.Brtrue_S, (object)label4);
					}
					else if (!flag4)
					{
						list[i - 4].labels.Add(label5);
						list.InsertRange(i - 4, list2);
						i += list2.Count;
						flag2 = true;
						flag4 = true;
					}
				}
				if (val2.opcode == OpCodes.Ret)
				{
					val2.labels.Add(label3);
					break;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("SpeedloaderPatch UpdateTranspiler not applied!");
			}
			return list;
		}
	}
	internal class RevolverCylinderPatch
	{
		private static void LoadFromSpeedLoaderPrefix(RevolverCylinder __instance, Speedloader loader)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance.Revolver, out trackedItem) ? trackedItem : ((Component)__instance.Revolver).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.RevolverCylinderLoad(trackedItem.data.trackedID, loader);
				}
				else
				{
					ClientSend.RevolverCylinderLoad(trackedItem.data.trackedID, loader);
				}
			}
		}
	}
	internal class RevolvingShotgunPatch
	{
		private static void LoadCylinderPrefix(RevolvingShotgun __instance, Speedloader s)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.RevolvingShotgunLoad(trackedItem.data.trackedID, s);
				}
				else
				{
					ClientSend.RevolvingShotgunLoad(trackedItem.data.trackedID, s);
				}
			}
		}
	}
	internal class GrappleGunPatch
	{
		private static void LoadCylinderPrefix(GrappleGun __instance, Speedloader s)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.GrappleGunLoad(trackedItem.data.trackedID, s);
				}
				else
				{
					ClientSend.GrappleGunLoad(trackedItem.data.trackedID, s);
				}
			}
		}
	}
	internal class CarlGustafLatchPatch
	{
		public static int skip;

		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CarlGustafLatchPatch), "SetLatchState", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("PlayAudioAsHandling"))
				{
					if (flag3)
					{
						list.InsertRange(i, list2);
						flag2 = true;
						break;
					}
					list.InsertRange(i, list2);
					i += list2.Count;
					flag = true;
					flag3 = true;
					list2[1] = new CodeInstruction(OpCodes.Ldc_I4_1, (object)null);
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("CarlGustafLatchPatch UpdateTranspiler not applied!");
			}
			return list;
		}

		public static void SetLatchState(CarlGustafLatch latch, bool open)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)latch.CG, out trackedItem) ? trackedItem : ((Component)latch.CG).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.CarlGustafLatchSate(trackedItem.data.trackedID, latch.LType, latch.LState);
				}
				else
				{
					ClientSend.CarlGustafLatchSate(trackedItem.data.trackedID, latch.LType, latch.LState);
				}
			}
		}
	}
	internal class CarlGustafShellInsertEjectPatch
	{
		public static int skip;

		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CarlGustafShellInsertEjectPatch), "SetShellSlideState", (Type[])null, (Type[])null)));
			CodeInstruction item = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CarlGustafShellInsertEjectPatch), "IncShellSlideEjectFlag", (Type[])null, (Type[])null));
			CodeInstruction item2 = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CarlGustafShellInsertEjectPatch), "DecShellSlideEjectFlag", (Type[])null, (Type[])null));
			bool[] array = new bool[3];
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("PlayAudioAsHandling"))
				{
					if (flag)
					{
						list.InsertRange(i, list2);
						array[1] = true;
						break;
					}
					list.InsertRange(i, list2);
					i += list2.Count;
					array[0] = true;
					flag = true;
					list2[1] = new CodeInstruction(OpCodes.Ldc_I4_1, (object)null);
				}
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("EjectRound"))
				{
					list.Insert(i, item);
					list.Insert(i + 2, item2);
					i += 2;
					array[2] = true;
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (!array[j])
				{
					Mod.LogError("CarlGustafShellInsertEjectPatch UpdateTranspiler not applied!");
					break;
				}
			}
			return list;
		}

		public static void SetShellSlideState(CarlGustafShellInsertEject slide, bool slideIn)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)slide.CG, out trackedItem) ? trackedItem : ((Component)slide.CG).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.CarlGustafShellSlideSate(trackedItem.data.trackedID, slide.CSState);
				}
				else
				{
					ClientSend.CarlGustafShellSlideSate(trackedItem.data.trackedID, slide.CSState);
				}
			}
		}

		public static void IncShellSlideEjectFlag()
		{
			ChamberEjectRoundPatch.overrideFlag++;
		}

		public static void DecShellSlideEjectFlag()
		{
			ChamberEjectRoundPatch.overrideFlag--;
		}
	}
	internal class GrappleThrowablePatch
	{
		private static TrackedItem trackedItem;

		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GrappleThrowablePatch), "AttachToSurface", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GrappleThrowablePatch), "CheckController", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Call && val.operand.ToString().Contains("OnCollisionEnter"))
				{
					list3.Add(list[i + 3]);
					list.InsertRange(i + 1, list3);
					flag = true;
				}
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("SetActive"))
				{
					list.InsertRange(i + 1, list2);
					flag2 = true;
					break;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("GrappleThrowablePatch CollisionTranspiler not applied!");
			}
			return list;
		}

		public static bool CheckController(GrappleThrowable grappleThrowable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)grappleThrowable, out trackedItem) ? trackedItem : ((Component)grappleThrowable).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (trackedItem.data.controller == GameManager.ID)
				{
					return true;
				}
				trackedItem = null;
				return false;
			}
			return true;
		}

		public static void AttachToSurface(GrappleThrowable grappleThrowable)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || !((Object)(object)trackedItem != (Object)null) || trackedItem.data.controller != GameManager.ID)
			{
				return;
			}
			trackedItem.itemData.additionalData = new byte[grappleThrowable.finalRopePoints.Count * 12 + 2];
			trackedItem.itemData.additionalData[0] = (byte)(grappleThrowable.m_hasLanded ? 1 : 0);
			trackedItem.itemData.additionalData[1] = (byte)grappleThrowable.finalRopePoints.Count;
			if (grappleThrowable.finalRopePoints.Count > 0)
			{
				for (int i = 0; i < grappleThrowable.finalRopePoints.Count; i++)
				{
					BitConverter.GetBytes(grappleThrowable.finalRopePoints[i].x).CopyTo(trackedItem.itemData.additionalData, i * 12 + 2);
					BitConverter.GetBytes(grappleThrowable.finalRopePoints[i].y).CopyTo(trackedItem.itemData.additionalData, i * 12 + 6);
					BitConverter.GetBytes(grappleThrowable.finalRopePoints[i].z).CopyTo(trackedItem.itemData.additionalData, i * 12 + 10);
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.GrappleAttached(trackedItem.data.trackedID, trackedItem.itemData.additionalData);
			}
			else
			{
				ClientSend.GrappleAttached(trackedItem.data.trackedID, trackedItem.itemData.additionalData);
			}
		}
	}
	internal class FireArmPatch
	{
		private static void AwakePostfix(FVRFireArm __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			if (__instance.m_pool_shot != null)
			{
				foreach (FVRPooledAudioSource item in __instance.m_pool_shot.SourceQueue_Disabled)
				{
					item.Source.maxDistance = 75f;
				}
			}
			if (__instance.m_pool_tail == null)
			{
				return;
			}
			foreach (FVRPooledAudioSource item2 in __instance.m_pool_tail.SourceQueue_Disabled)
			{
				item2.Source.maxDistance = 150f;
				item2.Source.spatialBlend = 1f;
			}
		}

		private static bool PlayAudioGunShotRoundPrefix(FVRFireArm __instance, FVRFireArmRound round, float globalLoudnessMultiplier)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Invalid comparison between Unknown and I4
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Invalid comparison between Unknown and I4
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			FVRSoundEnvironment soundEnvironment = SM.GetSoundEnvironment(((Component)__instance).transform.position);
			int num = GM.CurrentPlayerBody.GetPlayerIFF();
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				num = GameManager.players[trackedItem.data.controller].IFF;
			}
			Vector3 position = ((Component)__instance).transform.position;
			float num2 = Vector3.Distance(position, GM.CurrentPlayerBody.Head.position);
			float num3 = num2 / 343f;
			FVRTailSoundClass val = (FVRTailSoundClass)0;
			if (__instance.IsSuppressed())
			{
				__instance.m_pool_shot.PlayDelayedClip(num3, __instance.AudioClipSet.Shots_Suppressed, __instance.GetMuzzle().position, __instance.AudioClipSet.Shots_Suppressed.VolumeRange, __instance.AudioClipSet.Shots_Suppressed.PitchRange, (AudioMixerGroup)null);
				if (((FVRInteractiveObject)__instance).IsHeld)
				{
					((FVRInteractiveObject)__instance).m_hand.ForceTubeKick(__instance.AudioClipSet.FTP.Kick_Shot);
					((FVRInteractiveObject)__instance).m_hand.ForceTubeRumble(__instance.AudioClipSet.FTP.Rumble_Shot_Intensity, __instance.AudioClipSet.FTP.Rumble_Shot_Duration);
				}
				if (__instance.AudioClipSet.UsesTail_Suppressed)
				{
					val = round.TailClassSuppressed;
					AudioEvent tailSet = SM.GetTailSet(val, soundEnvironment);
					__instance.m_pool_tail.PlayDelayedClip(num3, tailSet, position, tailSet.VolumeRange * globalLoudnessMultiplier, __instance.AudioClipSet.TailPitchMod_Suppressed * tailSet.PitchRange.x, (AudioMixerGroup)null);
				}
			}
			else if (__instance.AudioClipSet.UsesLowPressureSet)
			{
				if (round.IsHighPressure)
				{
					__instance.m_pool_shot.PlayDelayedClip(num3, __instance.AudioClipSet.Shots_Main, __instance.GetMuzzle().position, __instance.AudioClipSet.Shots_Main.VolumeRange, __instance.AudioClipSet.Shots_Main.PitchRange, (AudioMixerGroup)null);
					if (__instance.AudioClipSet.UsesTail_Main)
					{
						val = round.TailClass;
						AudioEvent tailSet2 = SM.GetTailSet(val, soundEnvironment);
						__instance.m_pool_tail.PlayDelayedClip(num3, tailSet2, position, tailSet2.VolumeRange * globalLoudnessMultiplier, __instance.AudioClipSet.TailPitchMod_Main * tailSet2.PitchRange.x, (AudioMixerGroup)null);
					}
				}
				else
				{
					__instance.m_pool_shot.PlayDelayedClip(num3, __instance.AudioClipSet.Shots_LowPressure, __instance.GetMuzzle().position, __instance.AudioClipSet.Shots_LowPressure.VolumeRange, __instance.AudioClipSet.Shots_LowPressure.PitchRange, (AudioMixerGroup)null);
					if (__instance.AudioClipSet.UsesTail_Main)
					{
						val = round.TailClass;
						AudioEvent tailSet3 = SM.GetTailSet(round.TailClass, soundEnvironment);
						__instance.m_pool_tail.PlayDelayedClip(num3, tailSet3, position, tailSet3.VolumeRange * globalLoudnessMultiplier, __instance.AudioClipSet.TailPitchMod_LowPressure * tailSet3.PitchRange.x, (AudioMixerGroup)null);
					}
				}
			}
			else
			{
				__instance.m_pool_shot.PlayDelayedClip(num3, __instance.AudioClipSet.Shots_Main, __instance.GetMuzzle().position, __instance.AudioClipSet.Shots_Main.VolumeRange, __instance.AudioClipSet.Shots_Main.PitchRange, (AudioMixerGroup)null);
				if (__instance.AudioClipSet.UsesTail_Main)
				{
					val = round.TailClass;
					AudioEvent tailSet4 = SM.GetTailSet(round.TailClass, soundEnvironment);
					__instance.m_pool_tail.PlayDelayedClip(num3, tailSet4, position, tailSet4.VolumeRange * globalLoudnessMultiplier, __instance.AudioClipSet.TailPitchMod_Main * tailSet4.PitchRange.x, (AudioMixerGroup)null);
				}
			}
			float soundTravelDistanceMultByEnvironment = SM.GetSoundTravelDistanceMultByEnvironment(soundEnvironment);
			if (__instance.IsSuppressed())
			{
				GM.CurrentSceneSettings.OnPerceiveableSound(__instance.AudioClipSet.Loudness_Suppressed, __instance.AudioClipSet.Loudness_Suppressed * soundTravelDistanceMultByEnvironment * 0.5f * globalLoudnessMultiplier, position, num, GM.CurrentPlayerBody.PlayerEntities[0]);
			}
			else if (__instance.AudioClipSet.UsesLowPressureSet && !round.IsHighPressure)
			{
				GM.CurrentSceneSettings.OnPerceiveableSound(__instance.AudioClipSet.Loudness_Primary * 0.6f, __instance.AudioClipSet.Loudness_Primary * 0.6f * soundTravelDistanceMultByEnvironment * globalLoudnessMultiplier, position, num, GM.CurrentPlayerBody.PlayerEntities[0]);
			}
			else
			{
				GM.CurrentSceneSettings.OnPerceiveableSound(__instance.AudioClipSet.Loudness_Primary, __instance.AudioClipSet.Loudness_Primary * soundTravelDistanceMultByEnvironment * globalLoudnessMultiplier, position, num, GM.CurrentPlayerBody.PlayerEntities[0]);
			}
			if (!__instance.IsSuppressed())
			{
				__instance.SceneSettings.PingReceivers(__instance.MuzzlePos.position);
			}
			__instance.RattleSuppresor();
			for (int i = 0; i < __instance.MuzzleDevices.Count; i++)
			{
				__instance.MuzzleDevices[i].OnShot(__instance, val);
			}
			float num4 = 1000f;
			if (__instance.IsSuppressed())
			{
				num4 /= 6f;
			}
			if ((int)soundEnvironment >= 2 && (int)soundEnvironment <= 17)
			{
				num4 /= 3f;
			}
			if (num2 > 75f && num2 < num4)
			{
				SM.PlayCoreSoundDelayedOverrides((FVRPooledAudioType)31, Mod.distantShotSets[soundEnvironment], ((Component)__instance).transform.position, Mod.distantShotSets[soundEnvironment].VolumeRange, Mod.distantShotSets[soundEnvironment].PitchRange, num3);
			}
			return false;
		}

		private static bool PlayAudioGunShotBoolPrefix(FVRFireArm __instance, bool IsHighPressure, FVRTailSoundClass TailClass, FVRTailSoundClass TailClassSuppressed)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Invalid comparison between Unknown and I4
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Invalid comparison between Unknown and I4
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			FVRSoundEnvironment soundEnvironment = SM.GetSoundEnvironment(((Component)__instance).transform.position);
			int num = GM.CurrentPlayerBody.GetPlayerIFF();
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				num = GameManager.players[trackedItem.data.controller].IFF;
			}
			Vector3 position = ((Component)__instance).transform.position;
			float num2 = Vector3.Distance(position, GM.CurrentPlayerBody.Head.position);
			float num3 = num2 / 343f;
			FVRTailSoundClass val = (FVRTailSoundClass)0;
			if (__instance.IsSuppressed())
			{
				__instance.m_pool_shot.PlayDelayedClip(num3, __instance.AudioClipSet.Shots_Suppressed, __instance.GetMuzzle().position, __instance.AudioClipSet.Shots_Suppressed.VolumeRange, __instance.AudioClipSet.Shots_Suppressed.PitchRange, (AudioMixerGroup)null);
				if (((FVRInteractiveObject)__instance).IsHeld)
				{
					((FVRInteractiveObject)__instance).m_hand.ForceTubeKick(__instance.AudioClipSet.FTP.Kick_Shot);
					((FVRInteractiveObject)__instance).m_hand.ForceTubeRumble(__instance.AudioClipSet.FTP.Rumble_Shot_Intensity, __instance.AudioClipSet.FTP.Rumble_Shot_Duration);
				}
				if (__instance.AudioClipSet.UsesTail_Suppressed)
				{
					val = TailClassSuppressed;
					AudioEvent tailSet = SM.GetTailSet(TailClassSuppressed, soundEnvironment);
					__instance.m_pool_tail.PlayDelayedClip(num3, tailSet, position, tailSet.VolumeRange, __instance.AudioClipSet.TailPitchMod_Suppressed * tailSet.PitchRange.x, (AudioMixerGroup)null);
				}
			}
			else
			{
				float num4 = 1f;
				if (__instance.IsBraked())
				{
					num4 = 0.92f;
				}
				if (IsHighPressure)
				{
					__instance.PlayAudioEvent((FirearmAudioEventType)100, num4);
					if (__instance.AudioClipSet.UsesTail_Main)
					{
						val = TailClass;
						AudioEvent tailSet2 = SM.GetTailSet(TailClass, soundEnvironment);
						__instance.m_pool_tail.PlayDelayedClip(num3, tailSet2, position, tailSet2.VolumeRange, __instance.AudioClipSet.TailPitchMod_Main * tailSet2.PitchRange.x * num4, (AudioMixerGroup)null);
					}
				}
				else
				{
					__instance.m_pool_shot.PlayDelayedClip(num3, __instance.AudioClipSet.Shots_LowPressure, __instance.GetMuzzle().position, __instance.AudioClipSet.Shots_LowPressure.VolumeRange, __instance.AudioClipSet.Shots_LowPressure.PitchRange * num4, (AudioMixerGroup)null);
					if (__instance.AudioClipSet.UsesTail_Main)
					{
						val = TailClass;
						AudioEvent tailSet3 = SM.GetTailSet(TailClass, soundEnvironment);
						__instance.m_pool_tail.PlayDelayedClip(num3, tailSet3, position, tailSet3.VolumeRange, __instance.AudioClipSet.TailPitchMod_LowPressure * tailSet3.PitchRange.x * num4, (AudioMixerGroup)null);
					}
				}
			}
			float soundTravelDistanceMultByEnvironment = SM.GetSoundTravelDistanceMultByEnvironment(soundEnvironment);
			if (__instance.IsSuppressed())
			{
				GM.CurrentSceneSettings.OnPerceiveableSound(__instance.AudioClipSet.Loudness_Suppressed, __instance.AudioClipSet.Loudness_Suppressed * soundTravelDistanceMultByEnvironment * 0.4f, position, num, GM.CurrentPlayerBody.PlayerEntities[0]);
			}
			else if (__instance.AudioClipSet.UsesLowPressureSet && !IsHighPressure)
			{
				GM.CurrentSceneSettings.OnPerceiveableSound(__instance.AudioClipSet.Loudness_Primary * 0.6f, __instance.AudioClipSet.Loudness_Primary * 0.6f * soundTravelDistanceMultByEnvironment, position, num, GM.CurrentPlayerBody.PlayerEntities[0]);
			}
			else
			{
				GM.CurrentSceneSettings.OnPerceiveableSound(__instance.AudioClipSet.Loudness_Primary, __instance.AudioClipSet.Loudness_Primary * soundTravelDistanceMultByEnvironment, position, num, GM.CurrentPlayerBody.PlayerEntities[0]);
			}
			if (!__instance.IsSuppressed())
			{
				__instance.SceneSettings.PingReceivers(__instance.MuzzlePos.position);
			}
			__instance.RattleSuppresor();
			for (int i = 0; i < __instance.MuzzleDevices.Count; i++)
			{
				__instance.MuzzleDevices[i].OnShot(__instance, val);
			}
			float num5 = 1000f;
			if (__instance.IsSuppressed())
			{
				num5 /= 6f;
			}
			if ((int)soundEnvironment >= 2 && (int)soundEnvironment <= 17)
			{
				num5 /= 3f;
			}
			if (num2 > 75f && num2 < num5)
			{
				SM.PlayCoreSoundDelayedOverrides((FVRPooledAudioType)31, Mod.distantShotSets[soundEnvironment], ((Component)__instance).transform.position, Mod.distantShotSets[soundEnvironment].VolumeRange, Mod.distantShotSets[soundEnvironment].PitchRange, num3);
			}
			return false;
		}
	}
	internal class SteelPopTargetPatch
	{
		private static void StartPostfix(SteelPopTarget __instance)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)__instance, out trackedItem) ? trackedItem : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				for (int i = 0; i < __instance.Joints.Count; i++)
				{
					((Component)__instance.Joints[i]).transform.localEulerAngles = new Vector3(BitConverter.ToSingle(trackedItem.itemData.data, i * 12 + 1), BitConverter.ToSingle(trackedItem.itemData.data, i * 12 + 5), BitConverter.ToSingle(trackedItem.itemData.data, i * 12 + 9));
				}
			}
		}
	}
	internal class FlameThrowerPatch
	{
		private static bool UpdateControlsPrefix(FlameThrower __instance)
		{
			if ((Object)(object)Mod.managerObject != (Object)null && (Object)(object)((FVRFireArm)__instance).BeltBoxMountPos != (Object)null && int.TryParse(((Object)((FVRFireArm)__instance).BeltBoxMountPos).name, out var result))
			{
				return TrackedObject.trackedReferences.Length <= result || (Object)(object)TrackedObject.trackedReferences[result] == (Object)null || TrackedObject.trackedReferences[result].data.controller == GameManager.ID;
			}
			return true;
		}
	}
	internal class AR15SightFlipperPatch
	{
		private static void InteractPostfix(AR15HandleSightFlipper __instance)
		{
			if (!((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			Transform val = ((Component)__instance).transform;
			TrackedObject trackedObject = null;
			while ((Object)(object)val != (Object)null)
			{
				trackedObject = ((Component)val).GetComponent<TrackedObject>();
				if ((Object)(object)trackedObject != (Object)null)
				{
					break;
				}
				val = val.parent;
			}
			if (!((Object)(object)trackedObject != (Object)null))
			{
				return;
			}
			int index = 0;
			AR15HandleSightFlipper[] componentsInChildren = ((Component)trackedObject).GetComponentsInChildren<AR15HandleSightFlipper>();
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return;
			}
			if (componentsInChildren.Length > 1)
			{
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] == (Object)(object)__instance)
					{
						index = i;
						break;
					}
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.SightFlipperState(trackedObject.data.trackedID, index, __instance.m_isLargeAperture);
			}
			else if (trackedObject.data.trackedID != -1)
			{
				ClientSend.SightFlipperState(trackedObject.data.trackedID, index, __instance.m_isLargeAperture);
			}
		}
	}
	internal class AR15SightRaiserPatch
	{
		private static void InteractPostfix(AR15HandleSightRaiser __instance)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			Transform val = ((Component)__instance).transform;
			TrackedObject trackedObject = null;
			while ((Object)(object)val != (Object)null)
			{
				trackedObject = ((Component)val).GetComponent<TrackedObject>();
				if ((Object)(object)trackedObject != (Object)null)
				{
					break;
				}
				val = val.parent;
			}
			if (!((Object)(object)trackedObject != (Object)null))
			{
				return;
			}
			int index = 0;
			AR15HandleSightRaiser[] componentsInChildren = ((Component)trackedObject).GetComponentsInChildren<AR15HandleSightRaiser>();
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return;
			}
			if (componentsInChildren.Length > 1)
			{
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] == (Object)(object)__instance)
					{
						index = i;
						break;
					}
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.SightRaiserState(trackedObject.data.trackedID, index, __instance.height);
			}
			else if (trackedObject.data.trackedID != -1)
			{
				ClientSend.SightRaiserState(trackedObject.data.trackedID, index, __instance.height);
			}
		}
	}
	internal class GatlingGunPatch
	{
		private static void FireShotPostfix(wwGatlingGun __instance)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedGatlingGun trackedGatlingGun = (GameManager.trackedGatlingGunByGatlingGun.TryGetValue(__instance, out trackedGatlingGun) ? trackedGatlingGun : ((Component)__instance).GetComponent<TrackedGatlingGun>());
			if ((Object)(object)trackedGatlingGun != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.GatlingGunFire(trackedGatlingGun.data.trackedID, __instance.MuzzlePos.position, __instance.MuzzlePos.rotation, __instance.MuzzlePos.forward);
				}
				else
				{
					ClientSend.GatlingGunFire(trackedGatlingGun.data.trackedID, __instance.MuzzlePos.position, __instance.MuzzlePos.rotation, __instance.MuzzlePos.forward);
				}
			}
		}
	}
	internal class GasCuboidPatch
	{
		public static int generateGoutSkip;

		public static int explodeSkip;

		public static bool inExplode;

		public static int shatterSkip;

		private static void GenerateGoutPrefix(Brut_GasCuboid __instance, Vector3 point, Vector3 normal)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			if (generateGoutSkip > 0 || (Object)(object)Mod.managerObject == (Object)null || __instance.hasGeneratedGoutYet || __instance.m_isDestroyed || __instance.m_fuel <= 0f || !((Object)(object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1] != (Object)null) || !int.TryParse(((Object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedItem trackedItem = (TrackedItem)TrackedObject.trackedReferences[result];
			if ((Object)(object)trackedItem != (Object)null && trackedItem.itemData.additionalData[0] < byte.MaxValue)
			{
				byte[] additionalData = trackedItem.itemData.additionalData;
				trackedItem.itemData.additionalData = new byte[additionalData.Length + 24];
				for (int i = 0; i < additionalData.Length; i++)
				{
					trackedItem.itemData.additionalData[i] = additionalData[i];
				}
				trackedItem.itemData.additionalData[1]++;
				if (ThreadManager.host)
				{
					ServerSend.GasCuboidGout(trackedItem.itemData.trackedID, point, normal);
					return;
				}
				if (trackedItem.itemData.trackedID != -1)
				{
					ClientSend.GasCuboidGout(trackedItem.itemData.trackedID, point, normal);
					return;
				}
				if (TrackedItem.unknownGasCuboidGout.TryGetValue(trackedItem.data.localWaitingIndex, out var value))
				{
					value.Add(new KeyValuePair<Vector3, Vector3>(point, normal));
					return;
				}
				TrackedItem.unknownGasCuboidGout.Add(trackedItem.data.localWaitingIndex, new List<KeyValuePair<Vector3, Vector3>>
				{
					new KeyValuePair<Vector3, Vector3>(point, normal)
				});
			}
		}

		private static void DamageHandlePrefix(Brut_GasCuboid __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || __instance.m_isHandleBrokenOff || __instance.m_fuel <= 0f || !((Object)(object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1] != (Object)null) || !int.TryParse(((Object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedItem trackedItem = (TrackedItem)TrackedObject.trackedReferences[result];
			if ((Object)(object)trackedItem != (Object)null)
			{
				trackedItem.itemData.additionalData[0] = 1;
				if (ThreadManager.host)
				{
					ServerSend.GasCuboidDamageHandle(trackedItem.itemData.trackedID);
				}
				else if (trackedItem.itemData.trackedID != -1)
				{
					ClientSend.GasCuboidDamageHandle(trackedItem.itemData.trackedID);
				}
				else
				{
					TrackedItem.unknownGasCuboidDamageHandle.Add(trackedItem.data.localWaitingIndex);
				}
			}
		}

		private static bool UpdatePrefix(Brut_GasCuboid __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1] != (Object)null && int.TryParse(((Object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1]).name, out var result))
			{
				TrackedItem trackedItem = (TrackedItem)TrackedObject.trackedReferences[result];
				if ((Object)(object)trackedItem != (Object)null)
				{
					return trackedItem.itemData.controller == GameManager.ID;
				}
			}
			return true;
		}

		private static void ExplodePrefix(Brut_GasCuboid __instance, Vector3 point, Vector3 dir, bool isBig)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			inExplode = true;
			if (explodeSkip > 0 || (Object)(object)Mod.managerObject == (Object)null || __instance.m_isDestroyed || !((Object)(object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1] != (Object)null) || !int.TryParse(((Object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedItem trackedItem = (TrackedItem)TrackedObject.trackedReferences[result];
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.GasCuboidExplode(trackedItem.itemData.trackedID, point, dir, isBig);
				}
				else
				{
					ClientSend.GasCuboidExplode(trackedItem.itemData.trackedID, point, dir, isBig);
				}
			}
		}

		private static void ExplodePostfix()
		{
			inExplode = false;
		}

		private static void ShatterPrefix(Brut_GasCuboid __instance, Vector3 point, Vector3 dir)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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)
			if (shatterSkip > 0 || inExplode || (Object)(object)Mod.managerObject == (Object)null || __instance.m_isDestroyed || !((Object)(object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1] != (Object)null) || !int.TryParse(((Object)__instance.SpawnOnSplodePoints[__instance.SpawnOnSplodePoints.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedItem trackedItem = (TrackedItem)TrackedObject.trackedReferences[result];
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.GasCuboidShatter(trackedItem.itemData.trackedID, point, dir);
				}
				else
				{
					ClientSend.GasCuboidShatter(trackedItem.itemData.trackedID, point, dir);
				}
			}
		}
	}
	internal class FloaterPatch
	{
		public static bool beginExplodingOverride;

		public static int explodeSkip;

		private static bool UpdatePrefix(Construct_Floater __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || __instance.m_isExploding)
			{
				return true;
			}
			if ((Object)(object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1] != (Object)null && int.TryParse(((Object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1]).name, out var result))
			{
				TrackedFloater trackedFloater = TrackedObject.trackedReferences[result] as TrackedFloater;
				return (Object)(object)trackedFloater == (Object)null || trackedFloater.data.controller == GameManager.ID;
			}
			return true;
		}

		private static bool FixedUpdatePrefix(Construct_Floater __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1] != (Object)null && int.TryParse(((Object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1]).name, out var result))
			{
				TrackedFloater trackedFloater = TrackedObject.trackedReferences[result] as TrackedFloater;
				return (Object)(object)trackedFloater == (Object)null || trackedFloater.data.controller == GameManager.ID;
			}
			return true;
		}

		private static bool BeginExplodingPrefix(Construct_Floater __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || __instance.m_isExploding)
			{
				return true;
			}
			if ((Object)(object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1] != (Object)null && int.TryParse(((Object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1]).name, out var result))
			{
				TrackedFloater trackedFloater = TrackedObject.trackedReferences[result] as TrackedFloater;
				if ((Object)(object)trackedFloater != (Object)null)
				{
					bool flag = trackedFloater.data.controller == GameManager.ID;
					if (!beginExplodingOverride)
					{
						if (ThreadManager.host)
						{
							ServerSend.FloaterBeginExploding(trackedFloater.data.trackedID, flag, trackedFloater.data.controller);
						}
						else if (trackedFloater.data.trackedID != -1)
						{
							ClientSend.FloaterBeginExploding(trackedFloater.data.trackedID, flag);
						}
						else
						{
							TrackedFloater.unknownFloaterBeginExploding.Add(trackedFloater.data.localWaitingIndex);
						}
					}
					return beginExplodingOverride || flag;
				}
			}
			return true;
		}

		private static bool BeginDefusingPrefix(Construct_Floater __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || __instance.m_isExploding)
			{
				return true;
			}
			if ((Object)(object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1] != (Object)null && int.TryParse(((Object)__instance.SpawnOnSplode[__instance.SpawnOnSplode.Count - 1]).name, out var result))
			{
				TrackedFloater trackedFloater = TrackedObject.trackedReferences[result] as TrackedFloater;
				if ((Object)(object)trackedFloater != (Object)null)
				{
					bool flag = trackedFloater.data.controller == GameManager.ID;
					if (!beginExplodingOverride)
					{
						if (ThreadManager.host)
						{
							ServerSend.FloaterBeginDefusing(trackedFloater.data.trackedID, flag);
						}
						else if (trackedFloater.data.trackedID != -1)
						{
							ClientSend.FloaterBeginDefusing(trackedFloater.data.trackedID, flag);
						}
						else
						{
							TrackedFloater.unknownFloaterBeginDefusing.Add(trackedFloater.data.localWaitingIndex);
						}
					}
					return beginExplodingOverride || flag;
				}
			}
			return true;
		}

		private static bool ExplodePrefix(Construct_Floater __instance)
		{
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			TrackedFloater trackedFloater = (GameManager.trackedFloaterByFloater.TryGetValue(__instance, out trackedFloater) ? trackedFloater : null);
			if ((Object)(object)trackedFloater != (Object)null)
			{
				IFVRDamageable componentInChildren = (IFVRDamageable)(object)((Component)trackedFloater).GetComponentInChildren<Construct_Floater_Core>();
				if (componentInChildren != null)
				{
					GameManager.trackedObjectByDamageable.Remove(componentInChildren);
				}
				if (trackedFloater.data.controller == GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.FloaterExplode(trackedFloater.data.trackedID, __instance.isExplosionDefuse);
					}
					else if (trackedFloater.data.trackedID != -1)
					{
						ClientSend.FloaterExplode(trackedFloater.data.trackedID, __instance.isExplosionDefuse);
					}
					else
					{
						TrackedFloater.unknownFloaterBeginExploding.Remove(trackedFloater.data.localWaitingIndex);
						TrackedFloater.unknownFloaterBeginDefusing.Remove(trackedFloater.data.localWaitingIndex);
						TrackedFloater.unknownFloaterExplode.Add(trackedFloater.data.localWaitingIndex, __instance.isExplosionDefuse);
					}
				}
			}
			if (__instance.m_isExploded)
			{
				return false;
			}
			__instance.m_isExploded = true;
			if ((Object)(object)__instance.E != (Object)null)
			{
				__instance.E.AIEventReceiveEvent -= new AIEventReceive(__instance.EventReceive);
			}
			if ((Object)(object)__instance.E != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)__instance.E).gameObject);
			}
			EmissionModule emission = __instance.PSystem.emission;
			((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(0f);
			if (__instance.isExplosionDefuse)
			{
				for (int i = 0; i < __instance.SpawnOnDefuse.Count; i++)
				{
					Object.Instantiate<GameObject>(__instance.SpawnOnDefuse[i], ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
				}
				for (int j = 0; j < __instance.Shards.Count; j++)
				{
					((Component)__instance.Shards[j]).gameObject.SetActive(true);
					__instance.Shards[j].velocity = __instance.RB.velocity;
					__instance.Shards[j].angularVelocity = __instance.RB.angularVelocity;
					__instance.Shards[j].AddExplosionForce(Random.Range(__instance.ShardDefuseMag.x, __instance.ShardDefuseMag.y) * Random.Range(0.1f, 0.5f), ((Component)__instance).transform.position, 1f, 0.1f, (ForceMode)2);
					__instance.Shards[j].AddTorque(Random.onUnitSphere * 90f, (ForceMode)2);
				}
			}
			else
			{
				if ((Object)(object)GM.TNH_Manager != (Object)null)
				{
					GM.TNH_Manager.TakingBotKill();
				}
				for (int k = 0; k < __instance.SpawnOnSplode.Count - 1; k++)
				{
					Object.Instantiate<GameObject>(__instance.SpawnOnSplode[k], ((Component)__instance).transform.position, ((Component)__instance).transform.rotation);
				}
				for (int l = 0; l < __instance.Shards.Count; l++)
				{
					((Component)__instance.Shards[l]).gameObject.SetActive(true);
					__instance.Shards[l].velocity = __instance.RB.velocity;
					__instance.Shards[l].angularVelocity = __instance.RB.angularVelocity;
					__instance.Shards[l].AddExplosionForce(Random.Range(__instance.ShardExplodeMag.x, __instance.ShardExplodeMag.y) * Random.Range(0.1f, 0.5f), ((Component)__instance).transform.position, 1f, 0.1f, (ForceMode)2);
					__instance.Shards[l].AddTorque(Random.onUnitSphere * 90f, (ForceMode)2);
				}
			}
			__instance.C.enabled = false;
			__instance.m_isExploding = false;
			__instance.MainGO.SetActive(false);
			Object.Destroy((Object)(object)__instance.RB);
			return false;
		}
	}
	internal class IrisPatch
	{
		public static int stateSkip;

		private static bool UpdatePrefix(Construct_Iris __instance)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Invalid comparison between Unknown and I4
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedIris trackedIris = TrackedObject.trackedReferences[__instance.BParams[__instance.BParams.Count - 1].Pen] as TrackedIris;
			if ((Object)(object)trackedIris != (Object)null)
			{
				if (trackedIris.data.controller == GameManager.ID)
				{
					return true;
				}
				if ((int)__instance.IState != 5)
				{
					FieldInfo field = typeof(Construct_Iris).GetField("TargetLaser", BindingFlags.Instance | BindingFlags.Public);
					object? value = field.GetValue(__instance);
					Transform val = (Transform)((value is Transform) ? value : null);
					if ((Object)(object)val != (Object)null)
					{
						if ((int)__instance.IState == 1)
						{
							float num = 200f;
							Vector3 position = __instance.Muzzle.position;
							Vector3 forward = __instance.Muzzle.forward;
							if (Physics.Raycast(position, forward, ref __instance.m_hit, 200f, LayerMask.op_Implicit(__instance.LM_B)))
							{
								num = ((RaycastHit)(ref __instance.m_hit)).distance;
							}
							val.position = __instance.Muzzle.position;
							val.rotation = __instance.Muzzle.rotation;
							val.localScale = new Vector3(val.localScale.x, val.localScale.y, num);
							if (!((Component)val).gameObject.activeSelf)
							{
								((Component)val).gameObject.SetActive(true);
							}
						}
						else if (((Component)val).gameObject.activeSelf)
						{
							((Component)val).gameObject.SetActive(false);
						}
					}
					if (__instance.m_isShotEngaged)
					{
						__instance.UpdateLaser();
					}
				}
				return false;
			}
			return true;
		}

		private static bool FixedUpdatePrefix(Construct_Iris __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedIris trackedIris = TrackedObject.trackedReferences[__instance.BParams[__instance.BParams.Count - 1].Pen] as TrackedIris;
			if ((Object)(object)trackedIris != (Object)null)
			{
				if (trackedIris.data.controller == GameManager.ID)
				{
					return true;
				}
				return false;
			}
			return true;
		}

		private static bool SetStatePrefix(Construct_Iris __instance, IrisState s)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || stateSkip > 0)
			{
				return true;
			}
			TrackedIris trackedIris = TrackedObject.trackedReferences[__instance.BParams[__instance.BParams.Count - 1].Pen] as TrackedIris;
			if ((Object)(object)trackedIris != (Object)null)
			{
				if (trackedIris.data.controller == GameManager.ID)
				{
					trackedIris.irisData.state = s;
					if (ThreadManager.host)
					{
						ServerSend.IrisSetState(trackedIris.data.trackedID, s);
					}
					else if (trackedIris.data.trackedID != -1)
					{
						ClientSend.IrisSetState(trackedIris.data.trackedID, s);
					}
					else
					{
						TrackedIris.unknownIrisSetState.Add(trackedIris.data.localWaitingIndex, s);
					}
					return true;
				}
				return false;
			}
			return true;
		}
	}
	internal class BrutBlockSystemPatch
	{
		public static int startSkip;

		private static bool UpdatePrefix(BrutBlockSystem __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.BlockPointUppers[__instance.BlockPointUppers.Count - 1] != (Object)null && int.TryParse(((Object)__instance.BlockPointUppers[__instance.BlockPointUppers.Count - 1]).name, out var result))
			{
				TrackedBrutBlockSystem trackedBrutBlockSystem = TrackedObject.trackedReferences[result] as TrackedBrutBlockSystem;
				if ((Object)(object)trackedBrutBlockSystem != (Object)null)
				{
					return trackedBrutBlockSystem.data.controller == GameManager.ID;
				}
			}
			return true;
		}

		private static bool TryToStartBlockPrefix(BrutBlockSystem __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || startSkip > 0)
			{
				return true;
			}
			if ((Object)(object)__instance.BlockPointUppers[__instance.BlockPointUppers.Count - 1] != (Object)null && int.TryParse(((Object)__instance.BlockPointUppers[__instance.BlockPointUppers.Count - 1]).name, out var result))
			{
				TrackedBrutBlockSystem trackedBrutBlockSystem = TrackedObject.trackedReferences[result] as TrackedBrutBlockSystem;
				if ((Object)(object)trackedBrutBlockSystem != (Object)null)
				{
					if (trackedBrutBlockSystem.data.controller == GameManager.ID)
					{
						if (ThreadManager.host)
						{
							ServerSend.BrutBlockSystemStart(trackedBrutBlockSystem.data.trackedID, __instance.isNextBlock0);
						}
						else if (trackedBrutBlockSystem.data.trackedID != -1)
						{
							ClientSend.BrutBlockSystemStart(trackedBrutBlockSystem.data.trackedID, __instance.isNextBlock0);
						}
						return true;
					}
					return false;
				}
			}
			return true;
		}
	}
	internal class NodePatch
	{
		private static bool InitPrefix(Construct_Node __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.Stems[__instance.Stems.Count - 1] != (Object)null && int.TryParse(((Object)__instance.Stems[__instance.Stems.Count - 1]).name, out var result))
			{
				TrackedNode trackedNode = TrackedObject.trackedReferences[result] as TrackedNode;
				if ((Object)(object)trackedNode != (Object)null)
				{
					return trackedNode.data.controller == GameManager.ID;
				}
			}
			return true;
		}

		private static void InitPostfix(Construct_Node __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || !((Object)(object)__instance.Stems[__instance.Stems.Count - 1] != (Object)null) || !int.TryParse(((Object)__instance.Stems[__instance.Stems.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedNode trackedNode = TrackedObject.trackedReferences[result] as TrackedNode;
			if ((Object)(object)trackedNode != (Object)null && trackedNode.data.controller == GameManager.ID)
			{
				trackedNode.nodeData.points = trackedNode.physicalNode.Points;
				trackedNode.nodeData.ups = trackedNode.physicalNode.Ups;
				if (ThreadManager.host)
				{
					ServerSend.NodeInit(trackedNode.data.trackedID, __instance.Points, __instance.Ups);
				}
				else if (trackedNode.data.trackedID != -1)
				{
					ClientSend.NodeInit(trackedNode.data.trackedID, __instance.Points, __instance.Ups);
				}
				else if (!TrackedNode.unknownInit.Contains(trackedNode.data.localWaitingIndex))
				{
					TrackedNode.unknownInit.Add(trackedNode.data.localWaitingIndex);
				}
			}
		}

		private static bool UpdatePrefix(Construct_Node __instance)
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.Stems[__instance.Stems.Count - 1] != (Object)null && int.TryParse(((Object)__instance.Stems[__instance.Stems.Count - 1]).name, out var result))
			{
				TrackedNode trackedNode = TrackedObject.trackedReferences[result] as TrackedNode;
				if ((Object)(object)trackedNode != (Object)null && trackedNode.data.controller != GameManager.ID)
				{
					if (trackedNode.nodeData.underActiveControl || __instance.soundSilenceTimer < 3f)
					{
						if (!__instance.AudSource_Loop.isPlaying)
						{
							__instance.AudSource_Loop.Play();
						}
						AudioSource audSource_Loop = __instance.AudSource_Loop;
						Vector3 velocity = __instance.RB.velocity;
						audSource_Loop.volume = Mathf.Lerp(0f, 0.4f, ((Vector3)(ref velocity)).magnitude / 1f);
						AudioSource audSource_Loop2 = __instance.AudSource_Loop;
						velocity = __instance.RB.velocity;
						audSource_Loop2.pitch = Mathf.Lerp(0.85f, 1.15f, ((Vector3)(ref velocity)).magnitude / 1f);
					}
					else if (__instance.AudSource_Loop.isPlaying)
					{
						__instance.AudSource_Loop.Stop();
					}
					return false;
				}
			}
			return true;
		}

		private static bool FixedUpdatePrefix(Construct_Node __instance)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.Stems[__instance.Stems.Count - 1] != (Object)null && int.TryParse(((Object)__instance.Stems[__instance.Stems.Count - 1]).name, out var result))
			{
				TrackedNode trackedNode = TrackedObject.trackedReferences[result] as TrackedNode;
				if ((Object)(object)trackedNode != (Object)null && trackedNode.data.controller != GameManager.ID)
				{
					if (trackedNode.nodeData.underActiveControl)
					{
						if (__instance.damperRecoverTimer < 1f)
						{
							__instance.damperRecoverTimer += Time.deltaTime;
						}
						else
						{
							__instance.Joint.damper = 10f;
							__instance.RB.drag = 4f;
						}
						if (__instance.soundSilenceTimer < 3f)
						{
							__instance.soundSilenceTimer += Time.deltaTime;
						}
					}
					if (!trackedNode.nodeData.underActiveControl)
					{
						Vector3 velocity = __instance.RB.velocity;
						if (!(((Vector3)(ref velocity)).magnitude > 2f))
						{
							((Component)__instance.PSystem).gameObject.SetActive(false);
							goto IL_0190;
						}
					}
					((Component)__instance.PSystem).gameObject.SetActive(true);
					goto IL_0190;
				}
			}
			return true;
			IL_0190:
			__instance.UpdateCageStems();
			return false;
		}

		private static IEnumerable<CodeInstruction> FixedUpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_2, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Construct_Node), "m_firingDir")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(NodePatch), "Fire", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("Fire"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("NodePatch Transpiler not applied!");
			}
			return list;
		}

		public static void Fire(Construct_Node instance, float velMult, Vector3 firingDir)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || !((Object)(object)instance.Stems[instance.Stems.Count - 1] != (Object)null) || !int.TryParse(((Object)instance.Stems[instance.Stems.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedNode trackedNode = TrackedObject.trackedReferences[result] as TrackedNode;
			if ((Object)(object)trackedNode != (Object)null && trackedNode.data.controller == GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.NodeFire(trackedNode.data.trackedID, velMult, firingDir);
				}
				else if (trackedNode.data.trackedID != -1)
				{
					ClientSend.NodeFire(trackedNode.data.trackedID, velMult, firingDir);
				}
			}
		}
	}
	internal class HazePatch
	{
		private static bool UpdatePrefix(Construct_Haze __instance)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.PSystem2 != (Object)null && int.TryParse(((Object)__instance.PSystem2).name, out var result))
			{
				TrackedHaze trackedHaze = TrackedObject.trackedReferences[result] as TrackedHaze;
				if ((Object)(object)trackedHaze != (Object)null && trackedHaze.data.controller != GameManager.ID)
				{
					float num = Vector3.Distance(GM.CurrentPlayerBody.Head.position, ((Component)__instance).transform.position);
					if (num < 1f && (Object)(object)GM.TNH_Manager != (Object)null)
					{
						GM.TNH_Manager.TeleportToRandomHoldPoint();
					}
					if (__instance.KEBattery > 0f)
					{
						__instance.KEBattery -= Time.deltaTime * __instance.KEBatteryDecaySpeed;
						MainModule main = __instance.PSystem.main;
						((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(0.1f);
					}
					else
					{
						MainModule main2 = __instance.PSystem.main;
						((MainModule)(ref main2)).startSize = MinMaxCurve.op_Implicit(0.7f);
						if (!__instance.DamSphere.enabled)
						{
							__instance.DamSphere.enabled = true;
						}
					}
					float num2 = Mathf.InverseLerp(__instance.PSystemEnergyRange.x, __instance.PSystemEnergyRange.y, __instance.KEBattery);
					float radius = Mathf.Lerp(__instance.PSystemEmitRange.x, __instance.PSystemEmitRange.y, num2);
					((ShapeModule)(ref __instance.sh)).radius = radius;
					Vector3 val = GM.CurrentPlayerBody.Head.position - ((Component)__instance).transform.position;
					if (((Vector3)(ref val)).magnitude > __instance.MaxSoundDist)
					{
						if (__instance.AudSource_Haze.isPlaying)
						{
							__instance.AudSource_Haze.Stop();
							__instance.curLPFreq = 100f;
							__instance.tarLPFreq = 100f;
						}
					}
					else
					{
						if (Physics.Linecast(GM.CurrentPlayerBody.Head.position, ((Component)__instance).transform.position, LayerMask.op_Implicit(__instance.LM_Env), (QueryTriggerInteraction)1))
						{
							__instance.AudSource_Haze.volume = __instance.BaseVolume * __instance.OcclusionVolumeCurve.Evaluate(((Vector3)(ref val)).magnitude);
							__instance.tarLPFreq = __instance.OcclusionFactorCurve.Evaluate(((Vector3)(ref val)).magnitude);
						}
						else
						{
							__instance.AudSource_Haze.volume = __instance.BaseVolume;
							__instance.tarLPFreq = 22000f;
						}
						__instance.curLPFreq = Mathf.MoveTowards(__instance.curLPFreq, __instance.tarLPFreq, Time.deltaTime * 50000f);
						__instance.AudLowPass.cutoffFrequency = __instance.curLPFreq;
						if (!__instance.AudSource_Haze.isPlaying)
						{
							__instance.AudSource_Haze.Play();
						}
					}
					return false;
				}
			}
			return true;
		}

		private static bool FixedUpdatePrefix(Construct_Haze __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.PSystem2 != (Object)null && int.TryParse(((Object)__instance.PSystem2).name, out var result))
			{
				TrackedHaze trackedHaze = TrackedObject.trackedReferences[result] as TrackedHaze;
				if ((Object)(object)trackedHaze != (Object)null)
				{
					return trackedHaze.data.controller == GameManager.ID;
				}
			}
			return true;
		}
	}
	internal class SentinelPatch
	{
		private static bool AwakePrefix(Construct_Sentinel __instance)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			int num = __instance.PlatePoints.Count;
			if ((Object)(object)__instance.PlatePoints[__instance.PlatePoints.Count - 1] == (Object)null || int.TryParse(((Object)__instance.PlatePoints[__instance.PlatePoints.Count - 1]).name, out var _))
			{
				num--;
			}
			for (int i = 0; i < num; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(__instance.PlatePrefabs[Random.Range(0, __instance.PlatePrefabs.Count)], __instance.PlatePoints[i].position, __instance.PlatePoints[i].rotation);
				UberShatterable component = val.GetComponent<UberShatterable>();
				__instance.Plates.Add(component);
				__instance.oscils.Add(Random.Range(0f, (float)Math.PI * 2f));
			}
			for (int j = 0; j < __instance.Scanbeams.Count; j++)
			{
				__instance.Scanbeams[j].SetParent((Transform)null);
			}
			return false;
		}

		private static void InitPostfix(Construct_Sentinel __instance, List<Transform> points, int cp)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || !((Object)(object)__instance.PlatePoints[__instance.PlatePoints.Count - 1] != (Object)null) || !int.TryParse(((Object)__instance.PlatePoints[__instance.PlatePoints.Count - 1]).name, out var result))
			{
				return;
			}
			TrackedSentinel trackedSentinel = TrackedObject.trackedReferences[result] as TrackedSentinel;
			if ((Object)(object)trackedSentinel != (Object)null && trackedSentinel.data.controller == GameManager.ID)
			{
				if (trackedSentinel.sentinelData.patrolPoints == null)
				{
					trackedSentinel.sentinelData.patrolPoints = new List<Vector3>();
				}
				else
				{
					trackedSentinel.sentinelData.patrolPoints.Clear();
				}
				for (int i = 0; i < points.Count; i++)
				{
					trackedSentinel.sentinelData.patrolPoints.Add(points[i].position);
				}
				trackedSentinel.sentinelData.currentPointIndex = cp;
				trackedSentinel.sentinelData.targetPointIndex = __instance.tarPointIndex;
				trackedSentinel.sentinelData.isMovingUpIndicies = __instance.isMovingUpIndicies;
				if (ThreadManager.host)
				{
					ServerSend.SentinelInit(trackedSentinel.data.trackedID, trackedSentinel.sentinelData.patrolPoints, trackedSentinel.sentinelData.currentPointIndex, trackedSentinel.sentinelData.targetPointIndex, trackedSentinel.sentinelData.isMovingUpIndicies);
				}
				else if (trackedSentinel.data.trackedID != -1)
				{
					ClientSend.SentinelInit(trackedSentinel.data.trackedID, trackedSentinel.sentinelData.patrolPoints, trackedSentinel.sentinelData.currentPointIndex, trackedSentinel.sentinelData.targetPointIndex, trackedSentinel.sentinelData.isMovingUpIndicies);
				}
				else if (!TrackedNode.unknownInit.Contains(trackedSentinel.data.localWaitingIndex))
				{
					TrackedNode.unknownInit.Add(trackedSentinel.data.localWaitingIndex);
				}
			}
		}

		private static bool FixedUpdatePrefix(Construct_Sentinel __instance)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.PlatePoints[__instance.PlatePoints.Count - 1] != (Object)null && int.TryParse(((Object)__instance.PlatePoints[__instance.PlatePoints.Count - 1]).name, out var result))
			{
				TrackedSentinel trackedSentinel = TrackedObject.trackedReferences[result] as TrackedSentinel;
				if ((Object)(object)trackedSentinel != (Object)null)
				{
					if (trackedSentinel.data.controller == GameManager.ID)
					{
						return true;
					}
					if (__instance.m_isDead)
					{
						return false;
					}
					float deltaTime = Time.deltaTime;
					float num = default(float);
					Vector3 val3 = default(Vector3);
					for (int i = 0; i < __instance.Plates.Count; i++)
					{
						if ((Object)(object)__instance.Plates[i] != (Object)null && (Object)(object)__instance.Plates[i].RB != (Object)null)
						{
							Vector3 val = __instance.PlatePoints[i].position - ((Component)__instance.Plates[i]).transform.position;
							Quaternion val2 = __instance.PlatePoints[i].rotation * Quaternion.Inverse(((Component)__instance.Plates[i]).transform.rotation);
							((Quaternion)(ref val2)).ToAngleAxis(ref num, ref val3);
							Vector3 val4 = val * 900f * deltaTime;
							__instance.Plates[i].RB.velocity = Vector3.MoveTowards(__instance.Plates[i].RB.velocity, val4, 150f * deltaTime);
							if (num > 180f)
							{
								num -= 360f;
							}
							if (num != 0f)
							{
								Vector3 val5 = deltaTime * num * val3 * 6f;
								__instance.Plates[i].RB.angularVelocity = Vector3.MoveTowards(__instance.Plates[i].RB.angularVelocity, val5, 50f * Time.fixedDeltaTime);
							}
						}
					}
					return false;
				}
			}
			return true;
		}
	}
	public class DamagePatches
	{
		public static void DoPatching(Harmony harmony, ref int patchIndex)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			//IL_018b: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Expected O, but got Unknown
			//IL_1768: Unknown result type (might be due to invalid IL or missing references)
			//IL_176f: Unknown result type (might be due to invalid IL or missing references)
			//IL_177c: Expected O, but got Unknown
			//IL_177c: Expected O, but got Unknown
			//IL_17da: Unknown result type (might be due to invalid IL or missing references)
			//IL_17e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_17ee: Expected O, but got Unknown
			//IL_17ee: Expected O, but got Unknown
			//IL_1834: Unknown result type (might be due to invalid IL or missing references)
			//IL_1842: Expected O, but got Unknown
			//IL_18a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_18a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_18b4: Expected O, but got Unknown
			//IL_18b4: Expected O, but got Unknown
			//IL_18fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_1908: Expected O, but got Unknown
			//IL_194e: Unknown result type (might be due to invalid IL or missing references)
			//IL_195c: Expected O, but got Unknown
			//IL_19a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_19b0: Expected O, but got Unknown
			//IL_19f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a04: Expected O, but got Unknown
			//IL_1aee: Unknown result type (might be due to invalid IL or missing references)
			//IL_1afc: Expected O, but got Unknown
			//IL_1b02: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b10: Expected O, but got Unknown
			//IL_1bbb: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bcf: Expected O, but got Unknown
			//IL_1bcf: Expected O, but got Unknown
			//IL_1c15: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c23: Expected O, but got Unknown
			//IL_1c69: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c77: Expected O, but got Unknown
			//IL_1cbd: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ccb: Expected O, but got Unknown
			//IL_1e13: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e21: Expected O, but got Unknown
			//IL_1e67: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e75: Expected O, but got Unknown
			//IL_1fbd: Unknown result type (might be due to invalid IL or missing references)
			//IL_1fcb: Expected O, but got Unknown
			//IL_2097: Unknown result type (might be due to invalid IL or missing references)
			//IL_20a5: Expected O, but got Unknown
			//IL_20ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_20b9: Expected O, but got Unknown
			//IL_20bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_20cd: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Expected O, but got Unknown
			//IL_0337: Expected O, but got Unknown
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Expected O, but got Unknown
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Expected O, but got Unknown
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Expected O, but got Unknown
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Expected O, but got Unknown
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Expected O, but got Unknown
			//IL_0631: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Expected O, but got Unknown
			//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06be: Expected O, but got Unknown
			//IL_07a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b3: Expected O, but got Unknown
			//IL_07e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f5: Expected O, but got Unknown
			//IL_082b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0837: Expected O, but got Unknown
			//IL_0972: Unknown result type (might be due to invalid IL or missing references)
			//IL_097e: Expected O, but got Unknown
			//IL_09b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c0: Expected O, but got Unknown
			//IL_09f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a08: Expected O, but got Unknown
			//IL_0a08: Expected O, but got Unknown
			//IL_0a3e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4a: Expected O, but got Unknown
			//IL_0abf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0acb: Expected O, but got Unknown
			//IL_0b40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4c: Expected O, but got Unknown
			//IL_0bc1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bcd: Expected O, but got Unknown
			//IL_0c42: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c4e: Expected O, but got Unknown
			//IL_0cc3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ccf: Expected O, but got Unknown
			//IL_0d44: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d50: Expected O, but got Unknown
			//IL_0dc5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd1: Expected O, but got Unknown
			//IL_0e46: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e52: Expected O, but got Unknown
			//IL_0ec7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ed3: Expected O, but got Unknown
			//IL_0f48: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f54: Expected O, but got Unknown
			//IL_0fc9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fd5: Expected O, but got Unknown
			//IL_104a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1056: Expected O, but got Unknown
			//IL_10cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_10d7: Expected O, but got Unknown
			//IL_1186: Unknown result type (might be due to invalid IL or missing references)
			//IL_1192: Expected O, but got Unknown
			//IL_11c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_11d4: Expected O, but got Unknown
			//IL_1249: Unknown result type (might be due to invalid IL or missing references)
			//IL_1255: Expected O, but got Unknown
			//IL_12ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_12d6: Expected O, but got Unknown
			//IL_134b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1357: Expected O, but got Unknown
			//IL_13cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_13d8: Expected O, but got Unknown
			//IL_144d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1459: Expected O, but got Unknown
			//IL_14ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_14da: Expected O, but got Unknown
			//IL_154f: Unknown result type (might be due to invalid IL or missing references)
			//IL_155b: Expected O, but got Unknown
			//IL_15d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_15dc: Expected O, but got Unknown
			//IL_1651: Unknown result type (might be due to invalid IL or missing references)
			//IL_165d: Expected O, but got Unknown
			//IL_16d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_16de: Expected O, but got Unknown
			//IL_1b17: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b1e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b25: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b31: Expected O, but got Unknown
			//IL_1b31: Expected O, but got Unknown
			//IL_1b31: Expected O, but got Unknown
			//IL_1d14: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d20: Expected O, but got Unknown
			//IL_1d95: Unknown result type (might be due to invalid IL or missing references)
			//IL_1da1: Expected O, but got Unknown
			//IL_1ebe: Unknown result type (might be due to invalid IL or missing references)
			//IL_1eca: Expected O, but got Unknown
			//IL_1f3f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f4b: Expected O, but got Unknown
			MethodInfo method = typeof(TNH_EncryptionTarget_SubTarget).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method2 = typeof(EncryptionSubDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method, harmony, breaking: true);
			harmony.Patch((MethodBase)method, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method3 = typeof(TNH_EncryptionTarget).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method4 = typeof(EncryptionDamageablePatch).GetMethod("FixedUpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method3, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method3, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Mod.LogError("Exception caught applying DamagePatches.EncryptionDamageablePatch: " + ex.Message + ":\n" + ex.StackTrace);
			}
			patchIndex++;
			MethodInfo method5 = typeof(UberShatterable).GetMethod("Shatter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method6 = typeof(UberShatterableShatterPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method5, harmony, breaking: false);
			harmony.Patch((MethodBase)method5, new HarmonyMethod(method6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method7 = typeof(TNH_EncryptionTarget).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method8 = typeof(EncryptionDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method9 = typeof(EncryptionDamagePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method7, harmony, breaking: true);
			harmony.Patch((MethodBase)method7, new HarmonyMethod(method8), new HarmonyMethod(method9), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method10 = typeof(SosigWeapon).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method11 = typeof(SosigWeaponDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method10, harmony, breaking: false);
			harmony.Patch((MethodBase)method10, new HarmonyMethod(method11), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method12 = typeof(RemoteMissile).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method13 = typeof(RemoteMissileDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method12, harmony, breaking: false);
			harmony.Patch((MethodBase)method12, new HarmonyMethod(method13), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method14 = typeof(StingerMissile).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method15 = typeof(StingerMissileDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method14, harmony, breaking: false);
			harmony.Patch((MethodBase)method14, new HarmonyMethod(method15), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method16 = typeof(BallisticProjectile).GetMethod("Fire", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[4]
			{
				typeof(float),
				typeof(Vector3),
				typeof(FVRFireArm),
				typeof(bool)
			}, null);
			MethodInfo method17 = typeof(ProjectileFirePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method18 = typeof(ProjectileFirePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method16, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method16, new HarmonyMethod(method17), (HarmonyMethod)null, new HarmonyMethod(method18), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex2)
			{
				Mod.LogError("Exception caught applying DamagePatches.ProjectileFirePatch: " + ex2.Message + ":\n" + ex2.StackTrace);
			}
			patchIndex++;
			MethodInfo method19 = typeof(BallisticProjectile).GetMethod("MoveBullet", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method20 = typeof(BallisticProjectileDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method19, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method19, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method20), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex3)
			{
				Mod.LogError("Exception caught applying DamagePatches.BallisticProjectileDamageablePatch: " + ex3.Message + ":\n" + ex3.StackTrace);
			}
			patchIndex++;
			MethodInfo method21 = typeof(BallisticProjectile).GetMethod("FireSubmunitions", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method22 = typeof(SubMunitionsDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method21, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method21, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method22), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex4)
			{
				Mod.LogError("Exception caught applying DamagePatches.SubMunitionsDamageablePatch: " + ex4.Message + ":\n" + ex4.StackTrace);
			}
			patchIndex++;
			MethodInfo method23 = typeof(Explosion).GetMethod("Explode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method24 = typeof(ExplosionDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method23, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method23, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method24), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex5)
			{
				Mod.LogError("Exception caught applying DamagePatches.ExplosionDamageablePatch: " + ex5.Message + ":\n" + ex5.StackTrace);
			}
			patchIndex++;
			MethodInfo method25 = typeof(GrenadeExplosion).GetMethod("Explode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method26 = typeof(GrenadeExplosionDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method25, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method25, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method26), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex6)
			{
				Mod.LogError("Exception caught applying DamagePatches.GrenadeExplosionDamageablePatch: " + ex6.Message + ":\n" + ex6.StackTrace);
			}
			patchIndex++;
			MethodInfo method27 = typeof(FlameThrower).GetMethod("AirBlast", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method28 = typeof(FlameThrowerDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method27, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method27, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method28), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex7)
			{
				Mod.LogError("Exception caught applying DamagePatches.FlameThrowerDamageablePatch: " + ex7.Message + ":\n" + ex7.StackTrace);
			}
			patchIndex++;
			MethodInfo method29 = typeof(FVRGrenade).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method30 = typeof(GrenadeDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method29, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method29, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method30), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex8)
			{
				Mod.LogError("Exception caught applying DamagePatches.GrenadeDamageablePatch: " + ex8.Message + ":\n" + ex8.StackTrace);
			}
			patchIndex++;
			MethodInfo method31 = typeof(MF2_Demonade).GetMethod("Explode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method32 = typeof(DemonadeDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method31, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method31, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method32), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex9)
			{
				Mod.LogError("Exception caught applying DamagePatches.DemonadeDamageablePatch: " + ex9.Message + ":\n" + ex9.StackTrace);
			}
			patchIndex++;
			MethodInfo method33 = typeof(SosigWeapon).GetMethod("Explode", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method34 = typeof(SosigWeaponDamageablePatch).GetMethod("ExplosionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method35 = typeof(SosigWeapon).GetMethod("DoMeleeDamageInCollision", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method36 = typeof(SosigWeaponDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method37 = typeof(SosigWeapon).GetMethod("Update", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method38 = typeof(SosigWeaponDamageablePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method33, harmony, breaking: true);
			PatchController.Verify(method35, harmony, breaking: true);
			PatchController.Verify(method37, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method33, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method34), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex10)
			{
				Mod.LogError("Exception caught applying DamagePatches.SosigWeaponDamageablePatch on sosigWeaponDamageablePatchOriginal: " + ex10.Message + ":\n" + ex10.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method35, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method36), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex11)
			{
				Mod.LogError("Exception caught applying DamagePatches.SosigWeaponDamageablePatch on sosigWeaponDamageablePatchCollisionOriginal: " + ex11.Message + ":\n" + ex11.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method37, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method38), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex12)
			{
				Mod.LogError("Exception caught applying DamagePatches.SosigWeaponDamageablePatch on sosigWeaponDamageablePatchUpdateOriginal: " + ex12.Message + ":\n" + ex12.StackTrace);
			}
			patchIndex++;
			MethodInfo method39 = typeof(MeleeParams).GetMethod("DoStabDamage", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method40 = typeof(MeleeParamsDamageablePatch).GetMethod("StabTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method41 = typeof(MeleeParams).GetMethod("DoTearOutDamage", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method42 = typeof(MeleeParamsDamageablePatch).GetMethod("TearOutTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method43 = typeof(MeleeParams).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method44 = typeof(MeleeParamsDamageablePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method45 = typeof(MeleeParamsDamageablePatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method46 = typeof(MeleeParams).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method47 = typeof(MeleeParamsDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method39, harmony, breaking: true);
			PatchController.Verify(method41, harmony, breaking: true);
			PatchController.Verify(method43, harmony, breaking: true);
			PatchController.Verify(method46, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method39, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method40), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex13)
			{
				Mod.LogError("Exception caught applying DamagePatches.MeleeParamsDamageablePatch on meleeParamsDamageablePatchStabOriginal: " + ex13.Message + ":\n" + ex13.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method41, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method42), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex14)
			{
				Mod.LogError("Exception caught applying DamagePatches.MeleeParamsDamageablePatch on meleeParamsDamageablePatchTearOriginal: " + ex14.Message + ":\n" + ex14.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method43, new HarmonyMethod(method45), (HarmonyMethod)null, new HarmonyMethod(method44), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex15)
			{
				Mod.LogError("Exception caught applying DamagePatches.MeleeParamsDamageablePatch on meleeParamsDamageablePatchUpdateOriginal: " + ex15.Message + ":\n" + ex15.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method46, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method47), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex16)
			{
				Mod.LogError("Exception caught applying DamagePatches.MeleeParamsDamageablePatch on meleeParamsDamageablePatchCollisionOriginal: " + ex16.Message + ":\n" + ex16.StackTrace);
			}
			patchIndex++;
			MethodInfo method48 = typeof(AIMeleeWeapon).GetMethod("Fire", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method49 = typeof(AIMeleeDamageablePatch).GetMethod("FireTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method48, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method48, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method49), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex17)
			{
				Mod.LogError("Exception caught applying DamagePatches.AIMeleeDamageablePatch: " + ex17.Message + ":\n" + ex17.StackTrace);
			}
			patchIndex++;
			MethodInfo method50 = typeof(AutoMeaterBlade).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method51 = typeof(AutoMeaterBladeDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method50, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method50, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method51), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex18)
			{
				Mod.LogError("Exception caught applying DamagePatches.AutoMeaterBladeDamageablePatch: " + ex18.Message + ":\n" + ex18.StackTrace);
			}
			patchIndex++;
			MethodInfo method52 = typeof(BangSnap).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method53 = typeof(BangSnapDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method52, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method52, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method53), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex19)
			{
				Mod.LogError("Exception caught applying DamagePatches.BangSnapDamageablePatch: " + ex19.Message + ":\n" + ex19.StackTrace);
			}
			patchIndex++;
			MethodInfo method54 = typeof(BearTrapInteractiblePiece).GetMethod("SnapShut", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method55 = typeof(BearTrapDamageablePatch).GetMethod("SnapTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method54, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method54, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method55), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex20)
			{
				Mod.LogError("Exception caught applying DamagePatches.BearTrapDamageablePatch: " + ex20.Message + ":\n" + ex20.StackTrace);
			}
			patchIndex++;
			MethodInfo method56 = typeof(Chainsaw).GetMethod("OnCollisionStay", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method57 = typeof(ChainsawDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method56, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method56, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method57), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex21)
			{
				Mod.LogError("Exception caught applying DamagePatches.ChainsawDamageablePatch: " + ex21.Message + ":\n" + ex21.StackTrace);
			}
			patchIndex++;
			MethodInfo method58 = typeof(Drill).GetMethod("OnCollisionStay", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method59 = typeof(DrillDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method58, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method58, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method59), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex22)
			{
				Mod.LogError("Exception caught applying DamagePatches.DrillDamageablePatch: " + ex22.Message + ":\n" + ex22.StackTrace);
			}
			patchIndex++;
			MethodInfo method60 = typeof(DropTrapLogs).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method61 = typeof(DropTrapDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method60, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method60, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method61), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex23)
			{
				Mod.LogError("Exception caught applying DamagePatches.DropTrapDamageablePatch: " + ex23.Message + ":\n" + ex23.StackTrace);
			}
			patchIndex++;
			MethodInfo method62 = typeof(Flipzo).GetMethod("FVRUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method63 = typeof(FlipzoDamageablePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method62, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method62, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method63), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex24)
			{
				Mod.LogError("Exception caught applying DamagePatches.FlipzoDamageablePatch: " + ex24.Message + ":\n" + ex24.StackTrace);
			}
			patchIndex++;
			MethodInfo method64 = typeof(FVRIgnitable).GetMethod("Start", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method65 = typeof(IgnitableDamageablePatch).GetMethod("StartTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method64, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method64, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method65), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex25)
			{
				Mod.LogError("Exception caught applying DamagePatches.IgnitableDamageablePatch: " + ex25.Message + ":\n" + ex25.StackTrace);
			}
			patchIndex++;
			MethodInfo method66 = typeof(FVRSparkler).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method67 = typeof(SparklerDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method66, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method66, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method67), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex26)
			{
				Mod.LogError("Exception caught applying DamagePatches.SparklerDamageablePatch: " + ex26.Message + ":\n" + ex26.StackTrace);
			}
			patchIndex++;
			MethodInfo method68 = typeof(FVRStrikeAnyWhereMatch).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method69 = typeof(MatchDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method68, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method68, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method69), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex27)
			{
				Mod.LogError("Exception caught applying DamagePatches.MatchDamageablePatch: " + ex27.Message + ":\n" + ex27.StackTrace);
			}
			patchIndex++;
			MethodInfo method70 = typeof(HCBBolt).GetMethod("DamageOtherThing", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method71 = typeof(HCBBoltDamageablePatch).GetMethod("DamageOtherTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method70, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method70, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method71), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex28)
			{
				Mod.LogError("Exception caught applying DamagePatches.HCBBoltDamageablePatch: " + ex28.Message + ":\n" + ex28.StackTrace);
			}
			patchIndex++;
			MethodInfo method72 = typeof(KSpike).GetMethod("Tick", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method73 = typeof(KabotDamageablePatch).GetMethod("TickTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method72, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method72, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method73), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex29)
			{
				Mod.LogError("Exception caught applying DamagePatches.KabotDamageablePatch: " + ex29.Message + ":\n" + ex29.StackTrace);
			}
			patchIndex++;
			MethodInfo method74 = typeof(MeatCrab).GetMethod("Crabdate_Lunging", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method75 = typeof(MeatCrabDamageablePatch).GetMethod("LungingTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method76 = typeof(MeatCrab).GetMethod("Crabdate_Attached", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method77 = typeof(MeatCrabDamageablePatch).GetMethod("AttachedTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method74, harmony, breaking: false);
			PatchController.Verify(method76, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method74, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method75), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex30)
			{
				Mod.LogError("Exception caught applying DamagePatches.MeatCrabDamageablePatch on meatCrabDamageablePatchLungingOriginal: " + ex30.Message + ":\n" + ex30.StackTrace);
			}
			try
			{
				harmony.Patch((MethodBase)method76, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method77), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex31)
			{
				Mod.LogError("Exception caught applying DamagePatches.MeatCrabDamageablePatch on meatCrabDamageablePatchAttachedOriginal: " + ex31.Message + ":\n" + ex31.StackTrace);
			}
			patchIndex++;
			MethodInfo method78 = typeof(MF2_BearTrapInteractionZone).GetMethod("SnapShut", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method79 = typeof(MF2_BearTrapDamageablePatch).GetMethod("SnapTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method78, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method78, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method79), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex32)
			{
				Mod.LogError("Exception caught applying DamagePatches.MF2_BearTrapDamageablePatch: " + ex32.Message + ":\n" + ex32.StackTrace);
			}
			patchIndex++;
			MethodInfo method80 = typeof(MG_FlyingHotDogSwarm).GetMethod("FireShot", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method81 = typeof(MG_SwarmDamageablePatch).GetMethod("FireTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method80, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method80, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method81), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex33)
			{
				Mod.LogError("Exception caught applying DamagePatches.MG_SwarmDamageablePatch: " + ex33.Message + ":\n" + ex33.StackTrace);
			}
			patchIndex++;
			MethodInfo method82 = typeof(MG_JerryTheLemon).GetMethod("FireBolt", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method83 = typeof(MG_JerryDamageablePatch).GetMethod("FireTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method82, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method82, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method83), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex34)
			{
				Mod.LogError("Exception caught applying DamagePatches.MG_JerryDamageablePatch: " + ex34.Message + ":\n" + ex34.StackTrace);
			}
			patchIndex++;
			MethodInfo method84 = typeof(Microtorch).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method85 = typeof(MicrotorchDamageablePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method84, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method84, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method85), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex35)
			{
				Mod.LogError("Exception caught applying DamagePatches.MicrotorchDamageablePatch: " + ex35.Message + ":\n" + ex35.StackTrace);
			}
			patchIndex++;
			MethodInfo method86 = typeof(PowerUp_Cyclops).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method87 = typeof(CyclopsDamageablePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method86, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method86, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method87), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex36)
			{
				Mod.LogError("Exception caught applying DamagePatches.CyclopsDamageablePatch: " + ex36.Message + ":\n" + ex36.StackTrace);
			}
			patchIndex++;
			MethodInfo method88 = typeof(RealisticLaserSword).GetMethod("FVRFixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method89 = typeof(LaserSwordDamageablePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method88, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method88, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method89), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex37)
			{
				Mod.LogError("Exception caught applying DamagePatches.LaserSwordDamageablePatch: " + ex37.Message + ":\n" + ex37.StackTrace);
			}
			patchIndex++;
			MethodInfo method90 = typeof(RotrwCharcoal).GetMethod("DamageBubble", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method91 = typeof(CharcoalDamageablePatch).GetMethod("BubbleTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method90, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method90, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method91), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex38)
			{
				Mod.LogError("Exception caught applying DamagePatches.CharcoalDamageablePatch: " + ex38.Message + ":\n" + ex38.StackTrace);
			}
			patchIndex++;
			MethodInfo method92 = typeof(SlicerBladeMaster).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method93 = typeof(SlicerDamageablePatch).GetMethod("UpdateTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method92, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method92, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method93), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex39)
			{
				Mod.LogError("Exception caught applying DamagePatches.SlicerDamageablePatch: " + ex39.Message + ":\n" + ex39.StackTrace);
			}
			patchIndex++;
			MethodInfo method94 = typeof(SpinningBladeTrapBase).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method95 = typeof(SpinningBladeDamageablePatch).GetMethod("CollisionTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method94, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method94, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method95), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex40)
			{
				Mod.LogError("Exception caught applying DamagePatches.SpinningBladeDamageablePatch: " + ex40.Message + ":\n" + ex40.StackTrace);
			}
			patchIndex++;
			MethodInfo method96 = typeof(FVRProjectile).GetMethod("MoveBullet", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method97 = typeof(ProjectileDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method96, harmony, breaking: true);
			try
			{
				harmony.Patch((MethodBase)method96, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method97), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex41)
			{
				Mod.LogError("Exception caught applying DamagePatches.ProjectileDamageablePatch: " + ex41.Message + ":\n" + ex41.StackTrace);
			}
			patchIndex++;
			MethodInfo method98 = typeof(SosigLink).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method99 = typeof(SosigLinkDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method100 = typeof(SosigLinkDamagePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method98, harmony, breaking: true);
			harmony.Patch((MethodBase)method98, new HarmonyMethod(method99), new HarmonyMethod(method100), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method101 = typeof(SosigWearable).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method102 = typeof(SosigWearableDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method103 = typeof(SosigWearableDamagePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method101, harmony, breaking: true);
			harmony.Patch((MethodBase)method101, new HarmonyMethod(method102), new HarmonyMethod(method103), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method104 = typeof(AutoMeater).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method105 = typeof(AutoMeaterDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method104, harmony, breaking: false);
			harmony.Patch((MethodBase)method104, new HarmonyMethod(method105), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method106 = typeof(AutoMeaterHitZone).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method107 = typeof(AutoMeaterHitZoneDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method108 = typeof(AutoMeaterHitZoneDamagePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method106, harmony, breaking: false);
			harmony.Patch((MethodBase)method106, new HarmonyMethod(method107), new HarmonyMethod(method108), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method109 = typeof(TNH_ShatterableCrate).GetMethod("SetHoldingToken", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method110 = typeof(TNH_ShatterableCrateSetHoldingTokenPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method109, harmony, breaking: false);
			harmony.Patch((MethodBase)method109, new HarmonyMethod(method110), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method111 = typeof(TNH_ShatterableCrate).GetMethod("SetHoldingHealth", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method112 = typeof(TNH_ShatterableCrateSetHoldingHealthPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method111, harmony, breaking: false);
			harmony.Patch((MethodBase)method111, new HarmonyMethod(method112), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method113 = typeof(TNH_ShatterableCrate).GetMethod("Destroy", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method114 = typeof(TNH_ShatterableCrateDestroyPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method113, harmony, breaking: false);
			harmony.Patch((MethodBase)method113, new HarmonyMethod(method114), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method115 = typeof(TNH_ShatterableCrate).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method116 = typeof(TNH_ShatterableCrateDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method115, harmony, breaking: false);
			harmony.Patch((MethodBase)method115, new HarmonyMethod(method116), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method117 = typeof(BreakableGlassDamager).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method118 = typeof(BreakableGlassDamagerPatch).GetMethod("DamagePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method119 = typeof(BreakableGlassDamager).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method120 = typeof(BreakableGlassDamagerPatch).GetMethod("OnCollisionEnterPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method121 = typeof(BreakableGlassDamager).GetMethod("ShatterGlass", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method122 = typeof(BreakableGlassDamagerPatch).GetMethod("ShatterGlassPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method123 = typeof(BreakableGlassDamagerPatch).GetMethod("ShatterGlassPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method124 = typeof(BreakableGlassDamagerPatch).GetMethod("ShatterGlassTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method117, harmony, breaking: false);
			PatchController.Verify(method121, harmony, breaking: false);
			PatchController.Verify(method119, harmony, breaking: false);
			harmony.Patch((MethodBase)method117, new HarmonyMethod(method118), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method119, new HarmonyMethod(method120), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			try
			{
				harmony.Patch((MethodBase)method121, new HarmonyMethod(method122), new HarmonyMethod(method123), new HarmonyMethod(method124), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex42)
			{
				Mod.LogError("Exception caught applying DamagePatches.BreakableGlassDamagerPatch: " + ex42.Message + ":\n" + ex42.StackTrace);
			}
			patchIndex++;
			MethodInfo method125 = typeof(ReactiveSteelTarget).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method126 = typeof(ReactiveSteelTargetDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method127 = typeof(ReactiveSteelTargetDamagePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method125, harmony, breaking: false);
			harmony.Patch((MethodBase)method125, new HarmonyMethod(method126), new HarmonyMethod(method127), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method128 = typeof(FVRFireArmRound).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method129 = typeof(RoundDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method128, harmony, breaking: false);
			harmony.Patch((MethodBase)method128, new HarmonyMethod(method129), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method130 = typeof(Brut_GasCuboid).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method131 = typeof(GasCuboidDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method130, harmony, breaking: false);
			harmony.Patch((MethodBase)method130, new HarmonyMethod(method131), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method132 = typeof(Brut_GasCuboidHandle).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method133 = typeof(GasCuboidHandleDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method132, harmony, breaking: false);
			harmony.Patch((MethodBase)method132, new HarmonyMethod(method133), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method134 = typeof(Brut_TransformerSparks).GetMethod("AttemptToGenerateArc", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method135 = typeof(TransformerDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method134, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method134, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method135), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex43)
			{
				Mod.LogError("Exception caught applying DamagePatches.TransformerPatch: " + ex43.Message + ":\n" + ex43.StackTrace);
			}
			patchIndex++;
			MethodInfo method136 = typeof(Construct_Iris).GetMethod("UpdateLaser", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method137 = typeof(IrisDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method136, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method136, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method137), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex44)
			{
				Mod.LogError("Exception caught applying DamagePatches.IrisDamageablePatch: " + ex44.Message + ":\n" + ex44.StackTrace);
			}
			patchIndex++;
			MethodInfo method138 = typeof(Construct_Floater).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method139 = typeof(FloaterDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method138, harmony, breaking: false);
			harmony.Patch((MethodBase)method138, new HarmonyMethod(method139), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method140 = typeof(Construct_Floater_Core).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method141 = typeof(FloaterCoreDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method140, harmony, breaking: false);
			harmony.Patch((MethodBase)method140, new HarmonyMethod(method141), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method142 = typeof(BrutBlockSystem).GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method143 = typeof(BrutBlockSystemDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method142, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method142, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method143), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex45)
			{
				Mod.LogError("Exception caught applying DamagePatches.BrutBlockSystemDamageablePatch: " + ex45.Message + ":\n" + ex45.StackTrace);
			}
			patchIndex++;
			MethodInfo method144 = typeof(BrutTurbine).GetMethod("OnCollisionEnter", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method145 = typeof(BrutTurbineDamageablePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method144, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method144, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method145), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex46)
			{
				Mod.LogError("Exception caught applying DamagePatches.BrutTurbineDamageablePatch: " + ex46.Message + ":\n" + ex46.StackTrace);
			}
			patchIndex++;
			MethodInfo method146 = typeof(Construct_Haze).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method147 = typeof(HazeDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method146, harmony, breaking: false);
			harmony.Patch((MethodBase)method146, new HarmonyMethod(method147), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method148 = typeof(FVRPlayerHitbox).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(float) }, null);
			MethodInfo method149 = typeof(FVRPlayerHitbox).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(Damage) }, null);
			MethodInfo method150 = typeof(FVRPlayerHitbox).GetMethod("Damage", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[1] { typeof(DamageDealt) }, null);
			MethodInfo method151 = typeof(PlayerHitboxDamagePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method148, harmony, breaking: false);
			PatchController.Verify(method149, harmony, breaking: false);
			PatchController.Verify(method150, harmony, breaking: false);
			harmony.Patch((MethodBase)method148, new HarmonyMethod(method151), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method149, new HarmonyMethod(method151), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method150, new HarmonyMethod(method151), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	internal class ProjectileFirePatch
	{
		public static int skipBlast;

		private static void Prefix(ref FVRFireArm ___tempFA, ref FVRFireArm firearm)
		{
			___tempFA = firearm;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(ProjectileFirePatch), "skipBlast")));
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			Label label = il.DefineLabel();
			list2.Add(new CodeInstruction(OpCodes.Bgt_S, (object)label));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Call && val.operand.ToString().Contains("get_CurrentMovementManager"))
				{
					list[i + 7].labels.Add(label);
					list.InsertRange(i, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("ProjectileFirePatch Transpiler not applied!");
			}
			return list;
		}
	}
	public class BallisticProjectileDamageablePatch
	{
		public delegate void OnDamageDelegate(FVRFireArm fireArm, IFVRDamageable damageable);

		public static event OnDamageDelegate OnDamage;

		public static void OnDamageInvoke(FVRFireArm fireArm, IFVRDamageable damageable)
		{
			if (BallisticProjectileDamageablePatch.OnDamage != null)
			{
				BallisticProjectileDamageablePatch.OnDamage(fireArm, damageable);
			}
		}

		public static bool GetActualFlag(bool flag2, FVRFireArm tempFA, IFVRDamageable damageable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				if (flag2)
				{
					OnDamageInvoke(tempFA, damageable);
				}
				return flag2;
			}
			if (flag2)
			{
				TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue(damageable, out trackedObject) ? trackedObject : null);
				if (!(damageable is FVRPlayerHitbox) && (Object)(object)trackedObject == (Object)null)
				{
					OnDamageInvoke(tempFA, damageable);
					return true;
				}
				if ((Object)(object)tempFA == (Object)null)
				{
					int bestPotentialObjectHost = Mod.GetBestPotentialObjectHost(-1);
					bool flag3 = bestPotentialObjectHost == -1 || bestPotentialObjectHost == GameManager.ID;
					if (flag3)
					{
						OnDamageInvoke(tempFA, damageable);
					}
					return flag3;
				}
				TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey((FVRPhysicalObject)(object)tempFA) ? GameManager.trackedItemByItem[(FVRPhysicalObject)(object)tempFA] : ((Component)tempFA).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem == (Object)null)
				{
					return false;
				}
				bool flag4 = trackedItem.data.controller == GameManager.ID;
				if (flag4)
				{
					OnDamageInvoke(tempFA, damageable);
				}
				return flag4;
			}
			return flag2;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)14));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(BallisticProjectile), "tempFA")));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)13));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BallisticProjectileDamageablePatch), "GetActualFlag", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)14));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldc_I4_1 && list[i + 1].opcode == OpCodes.Stloc_S && list[i + 1].operand.ToString().Equals("System.Boolean (14)"))
				{
					list.InsertRange(i + 2, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("BallisticProjectileDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class SubMunitionsDamageablePatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)9));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(BallisticProjectile), "tempFA")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.Explosion (13)"))
				{
					list.InsertRange(i, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("SubMunitionsDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class FlameThrowerDamageablePatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_0 && list[i + 1].opcode == OpCodes.Ldloc_0)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("FlameThrowerDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class GrenadeDamageablePatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("UnityEngine.GameObject (4)"))
				{
					list.InsertRange(i + 1, list3);
					flag2 = true;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("GrenadeDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class DemonadeDamageablePatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("DemonadeDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class SosigWeaponDamageablePatch
	{
		private static IEnumerable<CodeInstruction> ExplosionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "AddControllerReference", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("SosigWeaponDamageablePatch ExplosionTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_0)
				{
					if (flag2)
					{
						list.InsertRange(i + 1, list2);
						flag = true;
						break;
					}
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("SosigWeaponDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_0)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("SosigWeaponDamageablePatch UpdateTranspiler not applied!");
			}
			return list;
		}
	}
	public class ExplosionDamageablePatch
	{
		public delegate void OnAddControllerReferenceDelegate(GameObject dest, MonoBehaviour src);

		public delegate void OnDamageDelegate(MonoBehaviour mb, IFVRDamageable damageable);

		public static event OnAddControllerReferenceDelegate OnAddControllerReference;

		public static event OnDamageDelegate OnDamage;

		public static void OnAddControllerReferenceInvoke(GameObject dest, MonoBehaviour src)
		{
			if (ExplosionDamageablePatch.OnAddControllerReference != null)
			{
				ExplosionDamageablePatch.OnAddControllerReference(dest, src);
			}
		}

		public static void OnDamageInvoke(MonoBehaviour mb, IFVRDamageable damageable)
		{
			if (ExplosionDamageablePatch.OnDamage != null)
			{
				ExplosionDamageablePatch.OnDamage(mb, damageable);
			}
		}

		public static void AddControllerReference(GameObject dest, MonoBehaviour src = null)
		{
			OnAddControllerReferenceInvoke(dest, src);
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0 || (Object)(object)dest == (Object)null)
			{
				return;
			}
			GameObject val = (((Object)(object)src == (Object)null) ? dest : ((Component)src).gameObject);
			TrackedItem component = val.GetComponent<TrackedItem>();
			if ((Object)(object)component != (Object)null)
			{
				ControllerReference controllerReference = dest.GetComponent<ControllerReference>();
				if ((Object)(object)controllerReference == (Object)null)
				{
					controllerReference = dest.AddComponent<ControllerReference>();
				}
				controllerReference.controller = component.data.controller;
			}
		}

		public static IFVRDamageable GetActualDamageable(MonoBehaviour mb, IFVRDamageable original)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				if (original != null)
				{
					OnDamageInvoke(mb, original);
				}
				return original;
			}
			if (original != null)
			{
				TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue(original, out trackedObject) ? trackedObject : null);
				if (!(original is FVRPlayerHitbox) && (Object)(object)trackedObject == (Object)null)
				{
					if (original != null)
					{
						OnDamageInvoke(mb, original);
					}
					return original;
				}
				ControllerReference component = ((Component)mb).GetComponent<ControllerReference>();
				if ((Object)(object)component == (Object)null)
				{
					TrackedItem component2 = ((Component)mb).GetComponent<TrackedItem>();
					if ((Object)(object)component2 == (Object)null)
					{
						int bestPotentialObjectHost = Mod.GetBestPotentialObjectHost(-1);
						if (bestPotentialObjectHost == GameManager.ID || bestPotentialObjectHost == -1)
						{
							if (original != null)
							{
								OnDamageInvoke(mb, original);
							}
							return original;
						}
						return null;
					}
					if (component2.data.controller == GameManager.ID)
					{
						if (original != null)
						{
							OnDamageInvoke(mb, original);
						}
						return original;
					}
					return null;
				}
				if (component.controller == GameManager.ID)
				{
					if (original != null)
					{
						OnDamageInvoke(mb, original);
					}
					return original;
				}
				return null;
			}
			return original;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)16));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)16));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (16)"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("ExplosionDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class GrenadeExplosionDamageablePatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)19));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)19));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (19)"))
				{
					if (flag2)
					{
						list.InsertRange(i, list2);
						flag = true;
						break;
					}
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("GrenadeExplosionDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class MeleeParamsDamageablePatch
	{
		private static IEnumerable<CodeInstruction> StabTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MeleeParams), "m_obj")));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)9));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)9));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (9)"))
				{
					if (flag2)
					{
						list.InsertRange(i + 1, list2);
						flag = true;
						break;
					}
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MeleeParamsDamageablePatch StabTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> TearOutTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MeleeParams), "m_obj")));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)6));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)6));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (6)"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("MeleeParamsDamageablePatch TearOutTranspiler not applied!");
			}
			return list;
		}

		private static bool UpdatePrefix(ref FVRPhysicalObject ___m_obj)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || (Object)(object)___m_obj == (Object)null || GameManager.playersPresent.Count == 0)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey(___m_obj) ? GameManager.trackedItemByItem[___m_obj] : ((Component)___m_obj).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
			{
				return false;
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MeleeParams), "m_obj")));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)14));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)14));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (14)"))
				{
					if (flag2)
					{
						list.InsertRange(i + 1, list2);
						flag = true;
						break;
					}
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MeleeParamsDamageablePatch UpdateTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(MeleeParams), "m_obj")));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)18));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)18));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (18)"))
				{
					if (flag2)
					{
						list.InsertRange(i + 1, list2);
						flag = true;
						break;
					}
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MeleeParamsDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class AIMeleeDamageablePatch
	{
		public static IFVRReceiveDamageable GetActualReceiveDamageable(MonoBehaviour mb, IFVRReceiveDamageable original)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				return original;
			}
			if (original != null)
			{
				ControllerReference component = ((Component)mb).GetComponent<ControllerReference>();
				if (!((Object)(object)component == (Object)null))
				{
					return (component.controller == GameManager.ID) ? original : null;
				}
				TrackedItem component2 = ((Component)mb).GetComponent<TrackedItem>();
				if (!((Object)(object)component2 == (Object)null))
				{
					return (component2.data.controller == GameManager.ID) ? original : null;
				}
				int num = 0;
				using (Dictionary<int, PlayerManager>.Enumerator enumerator = GameManager.players.GetEnumerator())
				{
					if (enumerator.MoveNext())
					{
						KeyValuePair<int, PlayerManager> current = enumerator.Current;
						if (current.Value.visible)
						{
							num = current.Key;
						}
					}
				}
				if (num != GameManager.ID)
				{
					return null;
				}
			}
			return original;
		}

		private static IEnumerable<CodeInstruction> FireTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(AIMeleeDamageablePatch), "GetActualReceiveDamageable", (Type[])null, (Type[])null)));
			list3.Add(new CodeInstruction(OpCodes.Stloc_S, (object)4));
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_3)
				{
					if (flag3)
					{
						flag3 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag3 = true;
				}
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRReceiveDamageable (4)"))
				{
					if (flag4)
					{
						flag4 = false;
						continue;
					}
					list.InsertRange(i + 1, list3);
					flag2 = true;
					flag4 = true;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("AIMeleeDamageablePatch FireTranspiler not applied!");
			}
			return list;
		}
	}
	internal class ProjectileDamageablePatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(AIMeleeDamageablePatch), "GetActualReceiveDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_3)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("ProjectileDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class AutoMeaterBladeDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)10));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)10));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (10)"))
				{
					if (flag2)
					{
						list.InsertRange(i + 1, list2);
						flag = true;
						break;
					}
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("AutoMeaterBladeDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class BangSnapDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_1, (object)null));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("BangSnapDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class BearTrapDamageablePatch
	{
		private static IEnumerable<CodeInstruction> SnapTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)5));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)5));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (5)"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("BearTrapDamageablePatch SnapTranspiler not applied!");
			}
			return list;
		}
	}
	internal class ChainsawDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_2, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_2, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_2)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("ChainsawDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class DrillDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_2, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_2, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_2)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("DrillDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class DropTrapDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)5));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)5));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (5)"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("DropTrapDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class FlipzoDamageablePatch
	{
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)7));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (7)"))
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("FlipzoDamageablePatch UpdateTranspiler not applied!");
			}
			return list;
		}
	}
	internal class IgnitableDamageablePatch
	{
		private static IEnumerable<CodeInstruction> StartTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_0)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("IgnitableDamageablePatch StartTranspiler not applied!");
			}
			return list;
		}
	}
	internal class SparklerDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_0)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("SparklerDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class MatchDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_0)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MatchDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class HCBBoltDamageablePatch
	{
		private static IEnumerable<CodeInstruction> DamageOtherTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_0, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_0)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("HCBBoltDamageablePatch DamageOtherTranspiler not applied!");
			}
			return list;
		}
	}
	internal class KabotDamageablePatch
	{
		private static IEnumerable<CodeInstruction> TickTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(KSpike), "K")));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_1, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("KabotDamageablePatch TickTranspiler not applied!");
			}
			return list;
		}
	}
	internal class MeatCrabDamageablePatch
	{
		private static IEnumerable<CodeInstruction> AttachedTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_1, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MeatCrabDamageablePatch AttachedTranspiler not applied!");
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> LungingTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)5));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)5));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (5)"))
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MeatCrabDamageablePatch LungingTranspiler not applied!");
			}
			return list;
		}
	}
	internal class MF2_BearTrapDamageablePatch
	{
		private static IEnumerable<CodeInstruction> SnapTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)5));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)5));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (5)"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("MF2_BearTrapDamageablePatch SnapTranspiler not applied!");
			}
			return list;
		}
	}
	internal class MG_SwarmDamageablePatch
	{
		private static IEnumerable<CodeInstruction> FireTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_1, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MG_SwarmDamageablePatch FireTranspiler not applied!");
			}
			return list;
		}
	}
	internal class MG_JerryDamageablePatch
	{
		private static IEnumerable<CodeInstruction> FireTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_3)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MG_JerryDamageablePatch FireTranspiler not applied!");
			}
			return list;
		}
	}
	internal class MicrotorchDamageablePatch
	{
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_1, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("MicrotorchDamageablePatch UpdateTranspiler not applied!");
			}
			return list;
		}
	}
	internal class CyclopsDamageablePatch
	{
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			LocalBuilder localBuilder = il.DeclareLocal(typeof(IFVRDamageable));
			localBuilder.SetLocalSymInfo("damageable");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldflda, (object)AccessTools.Field(typeof(PowerUp_Cyclops), "m_hit")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(RaycastHit), "get_collider", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Collider), "get_attachedRigidbody", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Component), "get_gameObject", (Type[])null, (Type[])null)));
			CodeInstruction val = CodeInstruction.Call(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(IFVRDamageable) });
			val.opcode = OpCodes.Callvirt;
			list2.Add(val);
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val2 = list[i];
				if (val2.opcode == OpCodes.Callvirt && val2.operand.ToString().Contains("Emit"))
				{
					num = i;
					list.InsertRange(i + 1, list2);
					flag = true;
				}
				if (val2.opcode == OpCodes.Brfalse)
				{
					if (flag3)
					{
						list.RemoveRange(i + 1, 6);
						list.Insert(i + 1, new CodeInstruction(OpCodes.Ldloc_3, (object)null));
						flag2 = true;
						break;
					}
					flag3 = true;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("CyclopsDamageablePatch UpdateTranspiler not applied!");
			}
			return list;
		}
	}
	internal class LaserSwordDamageablePatch
	{
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Expected O, but got Unknown
			LocalBuilder localBuilder = il.DeclareLocal(typeof(IFVRDamageable));
			localBuilder.SetLocalSymInfo("damageable");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldflda, (object)AccessTools.Field(typeof(PowerUp_Cyclops), "m_hit")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(RaycastHit), "get_collider", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Collider), "get_attachedRigidbody", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(Component), "get_gameObject", (Type[])null, (Type[])null)));
			list2.Add(CodeInstruction.Call(typeof(GameObject), "GetComponent", (Type[])null, new Type[1] { typeof(IFVRDamageable) }));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)8));
			bool flag = false;
			bool flag2 = false;
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("Emit"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
				}
				if (val.opcode == OpCodes.Brfalse)
				{
					if (num >= 2)
					{
						list.RemoveRange(i + 1, 6);
						list.Insert(i + 1, new CodeInstruction(OpCodes.Ldloc_S, (object)8));
						flag2 = true;
						break;
					}
					num++;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("LaserSwordDamageablePatch UpdateTranspiler not applied!");
			}
			return list;
		}
	}
	internal class CharcoalDamageablePatch
	{
		private static IEnumerable<CodeInstruction> BubbleTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_3)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("CharcoalDamageablePatch BubbleTranspiler not applied!");
			}
			return list;
		}
	}
	internal class SlicerDamageablePatch
	{
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_1, (object)null));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list3.Add(new CodeInstruction(OpCodes.Stloc_S, (object)4));
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					if (flag3)
					{
						flag3 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag3 = true;
				}
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (4)"))
				{
					if (flag4)
					{
						flag4 = false;
						continue;
					}
					list.InsertRange(i + 1, list3);
					flag2 = true;
					flag4 = true;
				}
			}
			if (!flag || !flag2)
			{
				Mod.LogError("SlicerDamageablePatch UpdateTranspiler not applied!");
			}
			return list;
		}
	}
	internal class SpinningBladeDamageablePatch
	{
		private static IEnumerable<CodeInstruction> CollisionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_1, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ExplosionDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_1, (object)null));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_1)
				{
					if (flag2)
					{
						flag2 = false;
						continue;
					}
					list.InsertRange(i + 1, list2);
					flag = true;
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("SpinningBladeDamageablePatch CollisionTranspiler not applied!");
			}
			return list;
		}
	}
	internal class SosigLinkDamagePatch
	{
		public static int skip;

		private static TrackedSosig trackedSosig;

		private static bool Prefix(ref SosigLink __instance, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null)
			{
				if (trackedSosig.data.controller == GameManager.ID)
				{
					return true;
				}
				for (int i = 0; i < __instance.S.Links.Count; i++)
				{
					if ((Object)(object)__instance.S.Links[i] == (Object)(object)__instance)
					{
						if (ThreadManager.host)
						{
							ServerSend.SosigLinkDamage(trackedSosig.sosigData, i, d);
						}
						else
						{
							ClientSend.SosigLinkDamage(trackedSosig.data.trackedID, i, d);
						}
						break;
					}
				}
				return false;
			}
			return true;
		}

		private static void Postfix(ref SosigLink __instance)
		{
			if (!((Object)(object)trackedSosig != (Object)null) || trackedSosig.data.trackedID == -1)
			{
				return;
			}
			if (ThreadManager.host)
			{
				if (trackedSosig.data.controller == 0)
				{
					ServerSend.SosigDamageData(trackedSosig);
				}
			}
			else if (trackedSosig.data.controller == Client.singleton.ID)
			{
				ClientSend.SosigDamageData(trackedSosig);
			}
		}
	}
	internal class SosigWearableDamagePatch
	{
		public static int skip;

		private static TrackedSosig trackedSosig;

		private static bool Prefix(ref SosigWearable __instance, Damage d)
		{
			SosigLinkDamagePatch.skip++;
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if ((Object)(object)trackedSosig != (Object)null)
			{
				if (trackedSosig.data.controller == GameManager.ID)
				{
					return true;
				}
				for (int i = 0; i < __instance.S.Links.Count; i++)
				{
					if (!((Object)(object)__instance.S.Links[i] == (Object)(object)__instance.L))
					{
						continue;
					}
					for (int j = 0; j < __instance.L.m_wearables.Count; j++)
					{
						if ((Object)(object)__instance.L.m_wearables[j] == (Object)(object)__instance)
						{
							if (ThreadManager.host)
							{
								ServerSend.SosigWearableDamage(trackedSosig.sosigData, i, j, d);
							}
							else
							{
								ClientSend.SosigWearableDamage(trackedSosig.data.trackedID, i, j, d);
							}
							return false;
						}
					}
					break;
				}
			}
			return true;
		}

		private static void Postfix(ref SosigWearable __instance)
		{
			SosigLinkDamagePatch.skip--;
			if ((Object)(object)trackedSosig != (Object)null && trackedSosig.data.controller == GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.SosigDamageData(trackedSosig);
				}
				else
				{
					ClientSend.SosigDamageData(trackedSosig);
				}
			}
		}
	}
	internal class TNH_ShatterableCrateDamagePatch
	{
		public static int skip;

		private static TrackedItem trackedItem;

		private static bool Prefix(ref TNH_ShatterableCrate __instance, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedItem = ((Component)__instance).GetComponent<TrackedItem>();
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						return true;
					}
					ServerSend.ShatterableCrateDamage(trackedItem.data.trackedID, d);
					return false;
				}
				if (trackedItem.data.controller == Client.singleton.ID)
				{
					return true;
				}
				ClientSend.ShatterableCrateDamage(trackedItem.data.trackedID, d);
				return false;
			}
			return true;
		}
	}
	internal class TNH_ShatterableCrateDestroyPatch
	{
		public static int skip;

		private static TrackedItem trackedItem;

		private static void Prefix(ref TNH_ShatterableCrate __instance, Damage dam)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			trackedItem = ((Component)__instance).GetComponent<TrackedItem>();
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.ShatterableCrateDestroy(trackedItem.data.trackedID, dam);
				}
				else
				{
					ClientSend.ShatterableCrateDestroy(trackedItem.data.trackedID, dam);
				}
			}
		}
	}
	internal class TNH_ShatterableCrateSetHoldingHealthPatch
	{
		public static int skip;

		private static TrackedItem trackedItem;

		private static void Prefix(ref TNH_ShatterableCrate __instance)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			trackedItem = ((Component)__instance).GetComponent<TrackedItem>();
			if (!((Object)(object)trackedItem != (Object)null) || trackedItem.data.controller != GameManager.ID)
			{
				return;
			}
			trackedItem.itemData.additionalData[3] = 1;
			if (trackedItem.data.trackedID == -1)
			{
				if (TrackedItem.unknownCrateHolding.TryGetValue(trackedItem.data.localWaitingIndex, out var value) && value == 1)
				{
					TrackedItem.unknownCrateHolding[trackedItem.data.localWaitingIndex] = 2;
				}
				else
				{
					TrackedItem.unknownCrateHolding.Add(trackedItem.data.localWaitingIndex, 0);
				}
			}
			else if (ThreadManager.host)
			{
				ServerSend.ShatterableCrateSetHoldingHealth(trackedItem.data.trackedID);
			}
			else
			{
				ClientSend.ShatterableCrateSetHoldingHealth(trackedItem.data.trackedID);
			}
		}
	}
	internal class TNH_ShatterableCrateSetHoldingTokenPatch
	{
		public static int skip;

		private static TrackedItem trackedItem;

		private static void Prefix(ref TNH_ShatterableCrate __instance)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			trackedItem = ((Component)__instance).GetComponent<TrackedItem>();
			if (!((Object)(object)trackedItem != (Object)null) || trackedItem.data.controller != GameManager.ID)
			{
				return;
			}
			trackedItem.itemData.additionalData[4] = 1;
			if (trackedItem.data.trackedID == -1)
			{
				if (TrackedItem.unknownCrateHolding.TryGetValue(trackedItem.data.localWaitingIndex, out var value) && value == 0)
				{
					TrackedItem.unknownCrateHolding[trackedItem.data.localWaitingIndex] = 2;
				}
				else
				{
					TrackedItem.unknownCrateHolding.Add(trackedItem.data.localWaitingIndex, 1);
				}
			}
			else if (ThreadManager.host)
			{
				ServerSend.ShatterableCrateSetHoldingToken(trackedItem.data.trackedID);
			}
			else
			{
				ClientSend.ShatterableCrateSetHoldingToken(trackedItem.data.trackedID);
			}
		}
	}
	internal class AutoMeaterDamagePatch
	{
		public static int skip;

		private static TrackedAutoMeater trackedAutoMeater;

		private static bool Prefix(ref AutoMeater __instance, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance) ? GameManager.trackedAutoMeaterByAutoMeater[__instance] : ((Component)__instance).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedAutoMeater.data.controller == 0)
					{
						return true;
					}
					ServerSend.AutoMeaterDamage(trackedAutoMeater.autoMeaterData, d);
					return false;
				}
				if (trackedAutoMeater.data.controller == Client.singleton.ID)
				{
					return true;
				}
				ClientSend.AutoMeaterDamage(trackedAutoMeater.data.trackedID, d);
				return false;
			}
			return true;
		}
	}
	internal class AutoMeaterHitZoneDamagePatch
	{
		public static int skip;

		private static TrackedAutoMeater trackedAutoMeater;

		private static bool Prefix(ref AutoMeaterHitZone __instance, ref AMHitZoneType ___Type, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedAutoMeater = (GameManager.trackedAutoMeaterByAutoMeater.ContainsKey(__instance.M) ? GameManager.trackedAutoMeaterByAutoMeater[__instance.M] : ((Component)__instance.M).GetComponent<TrackedAutoMeater>());
			if ((Object)(object)trackedAutoMeater != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedAutoMeater.data.controller == 0)
					{
						return true;
					}
					ServerSend.AutoMeaterHitZoneDamage(trackedAutoMeater.autoMeaterData, (byte)___Type, d);
					return false;
				}
				if (trackedAutoMeater.data.controller == Client.singleton.ID)
				{
					return true;
				}
				ClientSend.AutoMeaterHitZoneDamage(trackedAutoMeater.data.trackedID, ___Type, d);
				return false;
			}
			return true;
		}

		private static void Postfix(ref AutoMeaterHitZone __instance, ref AMHitZoneType ___Type)
		{
			if (!((Object)(object)trackedAutoMeater != (Object)null))
			{
				return;
			}
			if (ThreadManager.host)
			{
				if (trackedAutoMeater.data.controller == 0)
				{
					ServerSend.AutoMeaterHitZoneDamageData(trackedAutoMeater.data.trackedID, __instance);
				}
			}
			else if (trackedAutoMeater.data.controller == Client.singleton.ID && trackedAutoMeater.data.trackedID != -1)
			{
				ClientSend.AutoMeaterHitZoneDamageData(trackedAutoMeater.data.trackedID, __instance);
			}
		}
	}
	internal class EncryptionDamagePatch
	{
		public static int skip;

		private static TrackedEncryption trackedEncryption;

		private static bool Prefix(ref TNH_EncryptionTarget __instance, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedEncryption = (GameManager.trackedEncryptionByEncryption.ContainsKey(__instance) ? GameManager.trackedEncryptionByEncryption[__instance] : ((Component)__instance).GetComponent<TrackedEncryption>());
			if ((Object)(object)trackedEncryption != (Object)null)
			{
				if (trackedEncryption.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.EncryptionDamage(trackedEncryption.encryptionData, d);
				}
				else
				{
					ClientSend.EncryptionDamage(trackedEncryption.data.trackedID, d);
				}
				return false;
			}
			return true;
		}

		private static void Postfix(ref TNH_EncryptionTarget __instance)
		{
			if (!((Object)(object)trackedEncryption != (Object)null) || !((Object)(object)__instance != (Object)null))
			{
				return;
			}
			if (ThreadManager.host)
			{
				if (trackedEncryption.data.controller == 0)
				{
					ServerSend.EncryptionDamageData(trackedEncryption);
				}
			}
			else if (trackedEncryption.data.controller == GameManager.ID && trackedEncryption.data.trackedID != -1)
			{
				ClientSend.EncryptionDamageData(trackedEncryption);
			}
		}
	}
	internal class EncryptionSubDamagePatch
	{
		public static int skip;

		private static TrackedEncryption trackedEncryption;

		private static bool Prefix(ref TNH_EncryptionTarget_SubTarget __instance, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.Target == (Object)null)
			{
				Mod.LogError("Damaged an encryption sub target that is missing reference to main target!");
				return false;
			}
			trackedEncryption = (GameManager.trackedEncryptionByEncryption.ContainsKey(__instance.Target) ? GameManager.trackedEncryptionByEncryption[__instance.Target] : ((Component)__instance.Target).GetComponent<TrackedEncryption>());
			if ((Object)(object)trackedEncryption != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedEncryption.data.controller == 0)
					{
						return true;
					}
					ServerSend.EncryptionSubDamage(trackedEncryption.encryptionData, __instance.Index, d);
					return false;
				}
				if (trackedEncryption.data.controller == Client.singleton.ID)
				{
					return true;
				}
				ClientSend.EncryptionSubDamage(trackedEncryption.data.trackedID, __instance.Index, d);
				return false;
			}
			return true;
		}
	}
	internal class EncryptionDamageablePatch
	{
		public static bool GetActualFlag(TNH_EncryptionTarget encryption, IFVRDamageable damageable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue(damageable, out trackedObject) ? trackedObject : null);
			if (!(damageable is FVRPlayerHitbox) && (Object)(object)trackedObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)encryption.SpawnPoints[encryption.SpawnPoints.Count - 1] != (Object)null && int.TryParse(((Object)encryption.SpawnPoints[encryption.SpawnPoints.Count - 1]).name, out var result))
			{
				TrackedEncryption trackedEncryption = TrackedEncryption.trackedEncryptionReferences[result];
				if ((Object)(object)trackedEncryption == (Object)null)
				{
					return false;
				}
				return trackedEncryption.data.controller == GameManager.ID;
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> FixedUpdateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)21));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EncryptionDamageablePatch), "GetActualFlag", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)89));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EncryptionDamageablePatch), "GetActualFlag", (Type[])null, (Type[])null)));
			bool[] array = new bool[2];
			int[] array2 = new int[2];
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Contains("22"))
				{
					if (array2[0] == 1)
					{
						list.RemoveAt(i - 1);
						list.InsertRange(i - 1, list2);
						array[0] = true;
						i += 4;
					}
					else
					{
						array2[0]++;
					}
				}
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Contains("90"))
				{
					if (array2[1] == 1)
					{
						list.RemoveAt(i - 1);
						list.InsertRange(i - 1, list3);
						array[1] = true;
						i += 4;
					}
					else
					{
						array2[1]++;
					}
				}
			}
			if (!array[0] || !array[1])
			{
				Mod.LogError("EncryptionDamageablePatch FixedUpdateTranspiler not applied!");
			}
			return list;
		}
	}
	internal class SosigWeaponDamagePatch
	{
		public static int skip;

		private static bool Prefix(ref SosigWeapon __instance, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemBySosigWeapon.ContainsKey(__instance) ? GameManager.trackedItemBySosigWeapon[__instance] : ((Component)__instance).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						return true;
					}
					ServerSend.SosigWeaponDamage(trackedItem.itemData, d);
					return false;
				}
				if (trackedItem.data.controller == Client.singleton.ID)
				{
					return true;
				}
				ClientSend.SosigWeaponDamage(trackedItem.data.trackedID, d);
				return false;
			}
			return true;
		}
	}
	internal class RemoteMissileDamagePatch
	{
		public static int skip;

		private static bool Prefix(RemoteMissileLauncher ___m_launcher, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)___m_launcher, out trackedItem) ? trackedItem : ((Component)___m_launcher).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedItem.data.controller == 0)
					{
						return true;
					}
					ServerSend.RemoteMissileDamage(trackedItem.itemData, d);
					return false;
				}
				if (trackedItem.data.controller == Client.singleton.ID)
				{
					return true;
				}
				ClientSend.RemoteMissileDamage(trackedItem.data.trackedID, d);
				return false;
			}
			return true;
		}
	}
	internal class StingerMissileDamagePatch
	{
		public static int skip;

		private static bool Prefix(StingerMissile __instance, Damage d)
		{
			if (skip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedRef = ((Component)__instance).GetComponent<TrackedObjectReference>().trackedRef;
			if ((Object)(object)trackedRef != (Object)null)
			{
				if (ThreadManager.host)
				{
					if (trackedRef.data.controller == 0)
					{
						return true;
					}
					ServerSend.StingerMissileDamage(((TrackedItem)trackedRef).itemData, d);
					return false;
				}
				if (trackedRef.data.controller == Client.singleton.ID)
				{
					return true;
				}
				ClientSend.StingerMissileDamage(trackedRef.data.trackedID, d);
				return false;
			}
			return true;
		}
	}
	internal class UberShatterableShatterPatch
	{
		public static int skip;

		private static bool Prefix(UberShatterable __instance, Vector3 point, Vector3 dir, float intensity)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByShatterable.TryGetValue(__instance, out trackedObject) ? trackedObject : ((Component)__instance).GetComponent<TrackedObject>());
			if ((Object)(object)trackedObject != (Object)null)
			{
				return trackedObject.HandleShatter(__instance, point, dir, intensity, received: false, 0, null);
			}
			return true;
		}
	}
	internal class BreakableGlassDamagerPatch
	{
		public static int damageSkip;

		private static bool DamagePrefix(BreakableGlassDamager __instance, Damage d)
		{
			if (damageSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedBreakableGlass trackedBreakableGlass = (GameManager.trackedBreakableGlassByBreakableGlassDamager.TryGetValue(__instance, out trackedBreakableGlass) ? trackedBreakableGlass : ((Component)__instance).GetComponent<TrackedBreakableGlass>());
			if ((Object)(object)trackedBreakableGlass != (Object)null)
			{
				if (trackedBreakableGlass.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.BreakableGlassDamage(trackedBreakableGlass.breakableGlassData, d);
				}
				else
				{
					ClientSend.BreakableGlassDamage(trackedBreakableGlass.data.trackedID, d);
				}
				return false;
			}
			return true;
		}

		private static void ShatterGlassPrefix(BreakableGlassDamager __instance)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				Mod.skipAllInstantiates++;
			}
		}

		private static IEnumerable<CodeInstruction> ShatterGlassTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BreakableGlassDamagerPatch), "ShatterAudio", (Type[])null, (Type[])null)));
			List<CodeInstruction> list3 = new List<CodeInstruction>();
			list3.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
			list3.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BreakableGlassDamagerPatch), "ShatterAudio", (Type[])null, (Type[])null)));
			List<CodeInstruction> list4 = new List<CodeInstruction>();
			list4.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list4.Add(new CodeInstruction(OpCodes.Ldc_I4_2, (object)null));
			list4.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BreakableGlassDamagerPatch), "ShatterAudio", (Type[])null, (Type[])null)));
			List<CodeInstruction> list5 = new List<CodeInstruction>();
			list5.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list5.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(BreakableGlassDamager), "m_shards")));
			list5.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BreakableGlassDamagerPatch), "TrackShards", (Type[])null, (Type[])null)));
			bool[] array = new bool[4];
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Call && val.operand.ToString().Contains("PlayCoreSoundDelayed"))
				{
					switch (num)
					{
					case 0:
						list.InsertRange(i + 1, list2);
						i += list2.Count;
						array[0] = true;
						break;
					case 2:
						list.InsertRange(i + 1, list3);
						i += list3.Count;
						array[1] = true;
						break;
					case 4:
						list.InsertRange(i + 1, list4);
						i += list4.Count;
						array[2] = true;
						break;
					}
					num++;
				}
				else if (val.opcode == OpCodes.Callvirt && val.operand.ToString().Contains("Clear"))
				{
					list.InsertRange(i - 2, list5);
					array[3] = true;
					break;
				}
			}
			for (int j = 0; j < array.Length; j++)
			{
				if (!array[j])
				{
					Mod.LogError("BreakableGlassDamagerPatch ShatterGlassTranspiler not applied!");
					break;
				}
			}
			return list;
		}

		public static void ShatterAudio(BreakableGlassDamager __instance, int mode)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedBreakableGlass trackedBreakableGlass = (GameManager.trackedBreakableGlassByBreakableGlassDamager.TryGetValue(__instance, out trackedBreakableGlass) ? trackedBreakableGlass : ((Component)__instance).GetComponent<TrackedBreakableGlass>());
			if ((Object)(object)trackedBreakableGlass != (Object)null)
			{
				if (ThreadManager.host)
				{
					ServerSend.WindowShatterSound(trackedBreakableGlass.data.trackedID, mode);
				}
				else
				{
					ClientSend.WindowShatterSound(trackedBreakableGlass.data.trackedID, mode);
				}
			}
		}

		public static void TrackShards(List<GameObject> shards)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				Mod.LogInfo("Tracking " + shards.Count + " shards");
				for (int i = 0; i < shards.Count; i++)
				{
					GameManager.SyncTrackedObjects(shards[i].transform, controlEverything: true, null);
				}
			}
		}

		private static void ShatterGlassPostfix(BreakableGlassDamager __instance)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				Mod.skipAllInstantiates--;
			}
		}

		private static bool OnCollisionEnterPrefix(BreakableGlassDamager __instance)
		{
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				TrackedBreakableGlass trackedBreakableGlass = (GameManager.trackedBreakableGlassByBreakableGlassDamager.TryGetValue(__instance, out trackedBreakableGlass) ? trackedBreakableGlass : ((Component)__instance).GetComponent<TrackedBreakableGlass>());
				if ((Object)(object)trackedBreakableGlass != (Object)null)
				{
					return trackedBreakableGlass.data.controller == GameManager.ID;
				}
			}
			return true;
		}
	}
	internal class ReactiveSteelTargetDamagePatch
	{
		private static TrackedObject trackedObject;

		private static bool Prefix(ReactiveSteelTarget __instance, Damage dam)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Invalid comparison between Unknown and I4
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue((IFVRDamageable)(object)__instance, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject != (Object)null)
			{
				if (trackedObject.data.controller == GameManager.ID)
				{
					return true;
				}
				if ((int)dam.Class != 1)
				{
					return false;
				}
				if (Vector3.Angle(dam.hitNormal, ((Component)__instance).transform.forward) <= 90f && (Object)(object)__instance.HE_SteelPop != (Object)null)
				{
					__instance.HE_SteelPop.HitEvent();
				}
				Vector3 val = dam.point + dam.hitNormal * Random.Range(0.001f, 0.005f);
				if (__instance.BulletHolePrefabs.Length != 0 && __instance.m_useHoles)
				{
					float num = Mathf.InverseLerp(400f, 2000f, dam.Dam_TotalKinetic);
					float num2 = Mathf.Lerp(__instance.BulletHoleSizeRange.x, __instance.BulletHoleSizeRange.y, num);
					if (__instance.m_currentHoles.Count > __instance.MaxHoles)
					{
						__instance.holeindex++;
						if (__instance.holeindex > __instance.MaxHoles - 1)
						{
							__instance.holeindex = 0;
						}
						__instance.m_currentHoles[__instance.holeindex].transform.position = val;
						__instance.m_currentHoles[__instance.holeindex].transform.rotation = Quaternion.LookRotation(dam.hitNormal, Random.onUnitSphere);
						__instance.m_currentHoles[__instance.holeindex].transform.localScale = new Vector3(num2, num2, num2);
					}
					else
					{
						GameObject val2 = Object.Instantiate<GameObject>(__instance.BulletHolePrefabs[Random.Range(0, __instance.BulletHolePrefabs.Length)], val, Quaternion.LookRotation(dam.hitNormal, Random.onUnitSphere));
						val2.transform.SetParent(((Component)__instance).transform);
						val2.transform.localScale = new Vector3(num2, num2, num2);
						__instance.m_currentHoles.Add(val2);
					}
				}
				__instance.PlayHitSound(Mathf.Clamp(dam.Dam_TotalKinetic * 0.0025f, 0.05f, 1f));
				return false;
			}
			return true;
		}

		private static void Postfix(ReactiveSteelTarget __instance, Damage dam)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null || (int)dam.Class != 1 || !((Object)(object)trackedObject != (Object)null))
			{
				return;
			}
			TrackedItem trackedItem = trackedObject as TrackedItem;
			int num = -1;
			if (trackedItem.findSecondary != null)
			{
				num = trackedItem.findSecondary(__instance);
			}
			if (num == -1)
			{
				return;
			}
			if (ThreadManager.host)
			{
				if (__instance.m_useHoles)
				{
					GameObject val = __instance.m_currentHoles[__instance.holeindex];
					ServerSend.ReactiveSteelTargetDamage(trackedObject.data.trackedID, num, dam.Dam_TotalKinetic, dam.Dam_Blunt, dam.point, dam.strikeDir, usesHoles: true, val.transform.position, val.transform.rotation, val.transform.localScale.x);
				}
				else
				{
					ServerSend.ReactiveSteelTargetDamage(trackedObject.data.trackedID, num, dam.Dam_TotalKinetic, dam.Dam_Blunt, dam.point, dam.strikeDir, usesHoles: false, Vector3.zero, Quaternion.identity, 0f);
				}
			}
			else if (__instance.m_useHoles)
			{
				GameObject val2 = __instance.m_currentHoles[__instance.holeindex];
				ClientSend.ReactiveSteelTargetDamage(trackedObject.data.trackedID, num, dam.Dam_TotalKinetic, dam.Dam_Blunt, dam.point, dam.strikeDir, usesHoles: true, val2.transform.position, val2.transform.rotation, val2.transform.localScale.x);
			}
			else
			{
				ClientSend.ReactiveSteelTargetDamage(trackedObject.data.trackedID, num, dam.Dam_TotalKinetic, dam.Dam_Blunt, dam.point, dam.strikeDir, usesHoles: false, Vector3.zero, Quaternion.identity, 0f);
			}
		}
	}
	internal class RoundDamagePatch
	{
		private static bool Prefix(FVRFireArmRound __instance, Damage d)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue((IFVRDamageable)(object)__instance, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject != (Object)null)
			{
				if (trackedObject.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.RoundDamage(trackedObject.data.trackedID, d, trackedObject.data.controller);
				}
				else
				{
					ClientSend.RoundDamage(trackedObject.data.trackedID, d);
				}
				return false;
			}
			return true;
		}
	}
	internal class GasCuboidDamagePatch
	{
		public static int skip;

		private static bool Prefix(Brut_GasCuboid __instance, Damage d)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue((IFVRDamageable)(object)__instance, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject != (Object)null)
			{
				if (trackedObject.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.GasCuboidDamage(trackedObject.data.trackedID, d, trackedObject.data.controller);
				}
				else
				{
					ClientSend.GasCuboidDamage(trackedObject.data.trackedID, d);
				}
				return false;
			}
			return true;
		}
	}
	internal class GasCuboidHandleDamagePatch
	{
		public static int skip;

		private static bool Prefix(Brut_GasCuboidHandle __instance, Damage d)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue((IFVRDamageable)(object)__instance, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject != (Object)null)
			{
				if (trackedObject.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.GasCuboidHandleDamage(trackedObject.data.trackedID, d, trackedObject.data.controller);
				}
				else
				{
					ClientSend.GasCuboidHandleDamage(trackedObject.data.trackedID, d);
				}
				return false;
			}
			return true;
		}
	}
	internal class TransformerDamageablePatch
	{
		public static bool GetActualFlag(IFVRDamageable damageable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0 || damageable is FVRPlayerHitbox)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue(damageable, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject == (Object)null)
			{
				return true;
			}
			return trackedObject.data.controller == GameManager.ID;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(TransformerDamageablePatch), "GetActualFlag", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)8));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldc_I4_1 && list[i + 1].opcode == OpCodes.Stloc_S && list[i + 1].operand.ToString().Equals("System.Boolean (8)"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("TransformerDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class FloaterDamagePatch
	{
		public static int skip;

		private static bool Prefix(Construct_Floater __instance, Damage D)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue((IFVRDamageable)(object)__instance, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject != (Object)null)
			{
				if (trackedObject.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.FloaterDamage(trackedObject.data.trackedID, D, trackedObject.data.controller);
				}
				else
				{
					ClientSend.FloaterDamage(trackedObject.data.trackedID, D);
				}
				return false;
			}
			return true;
		}
	}
	internal class FloaterCoreDamagePatch
	{
		public static int skip;

		private static bool Prefix(Construct_Floater_Core __instance, Damage D)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue((IFVRDamageable)(object)__instance, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject != (Object)null)
			{
				if (trackedObject.data.controller == GameManager.ID)
				{
					return true;
				}
				if (ThreadManager.host)
				{
					ServerSend.FloaterCoreDamage(trackedObject.data.trackedID, D, trackedObject.data.controller);
				}
				else
				{
					ClientSend.FloaterCoreDamage(trackedObject.data.trackedID, D);
				}
				return false;
			}
			return true;
		}
	}
	internal class IrisDamageablePatch
	{
		public static bool GetActualFlag(Construct_Iris iris, IFVRDamageable damageable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue(damageable, out trackedObject) ? trackedObject : null);
			if (!(damageable is FVRPlayerHitbox) && (Object)(object)trackedObject == (Object)null)
			{
				return true;
			}
			TrackedIris trackedIris = TrackedObject.trackedReferences[iris.BParams[iris.BParams.Count - 1].Pen] as TrackedIris;
			if ((Object)(object)trackedIris == (Object)null)
			{
				return false;
			}
			return trackedIris.data.controller == GameManager.ID;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(IrisDamageablePatch), "GetActualFlag", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)9));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldc_I4_1 && list[i + 1].opcode == OpCodes.Stloc_S && list[i + 1].operand.ToString().Equals("System.Boolean (9)"))
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("IrisDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class BrutBlockSystemDamageablePatch
	{
		public static IFVRDamageable GetActualDamageable(IFVRDamageable original)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0)
			{
				return original;
			}
			if (original != null)
			{
				TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue(original, out trackedObject) ? trackedObject : null);
				if (!(original is FVRPlayerHitbox) && (Object)(object)trackedObject == (Object)null)
				{
					return original;
				}
				int bestPotentialObjectHost = Mod.GetBestPotentialObjectHost(-1);
				return (bestPotentialObjectHost == GameManager.ID || bestPotentialObjectHost == -1) ? original : null;
			}
			return original;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)4));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BrutBlockSystemDamageablePatch), "GetActualDamageable", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)4));
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stloc_S && val.operand.ToString().Equals("FistVR.IFVRDamageable (4)"))
				{
					if (flag2)
					{
						list.InsertRange(i + 1, list2);
						flag = true;
						break;
					}
					flag2 = true;
				}
			}
			if (!flag)
			{
				Mod.LogError("BrutBlockSystemDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class BrutTurbineDamageablePatch
	{
		public static bool GetActualFlag(IFVRDamageable damageable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.playersPresent.Count == 0 || damageable is FVRPlayerHitbox)
			{
				return true;
			}
			TrackedObject trackedObject = (GameManager.trackedObjectByDamageable.TryGetValue(damageable, out trackedObject) ? trackedObject : null);
			if ((Object)(object)trackedObject == (Object)null)
			{
				return true;
			}
			return trackedObject.data.controller == GameManager.ID;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)8));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(BrutTurbineDamageablePatch), "GetActualFlag", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_3, (object)null));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldc_I4_1 && list[i + 1].opcode == OpCodes.Stloc_3)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("BrutTurbineDamageablePatch Transpiler not applied!");
			}
			return list;
		}
	}
	internal class HazeDamagePatch
	{
		public static int skip;

		private static bool Prefix(Construct_Haze __instance, Damage D)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.PSystem2 != (Object)null && int.TryParse(((Object)__instance.PSystem2).name, out var result))
			{
				TrackedHaze trackedHaze = TrackedObject.trackedReferences[result] as TrackedHaze;
				if ((Object)(object)trackedHaze != (Object)null)
				{
					if (trackedHaze.data.controller == GameManager.ID)
					{
						return true;
					}
					if (ThreadManager.host)
					{
						ServerSend.HazeDamage(trackedHaze.data.trackedID, D, trackedHaze.data.controller);
					}
					else
					{
						ClientSend.HazeDamage(trackedHaze.data.trackedID, D);
					}
					return false;
				}
			}
			return true;
		}
	}
	internal class PlayerHitboxDamagePatch
	{
		private static bool Prefix()
		{
			return !H3MPWristMenuSection.invulnerable;
		}
	}
	public class GeneralPatches
	{
		public static void DoPatching(Harmony harmony, ref int patchIndex)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Expected O, but got Unknown
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Expected O, but got Unknown
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Expected O, but got Unknown
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Expected O, but got Unknown
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Expected O, but got Unknown
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Expected O, but got Unknown
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c4: Expected O, but got Unknown
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Expected O, but got Unknown
			MethodInfo method = typeof(SteamVR_LoadLevel).GetMethod("Begin", BindingFlags.Static | BindingFlags.Public);
			MethodInfo method2 = typeof(LoadLevelBeginPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method, harmony, breaking: true);
			harmony.Patch((MethodBase)method, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method3 = typeof(Rigidbody).GetMethod("set_isKinematic", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method4 = typeof(KinematicPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method3, harmony, breaking: true);
			harmony.Patch((MethodBase)method3, new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method5 = typeof(FVRPhysicalObject).GetMethod("RecoverRigidbody", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method6 = typeof(PhysicalObjectRBPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method5, harmony, breaking: true);
			harmony.Patch((MethodBase)method5, (HarmonyMethod)null, new HarmonyMethod(method6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method7 = typeof(FVRPlayerBody).GetMethod("SetPlayerIFF", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method8 = typeof(SetPlayerIFFPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method7, harmony, breaking: false);
			harmony.Patch((MethodBase)method7, new HarmonyMethod(method8), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method9 = typeof(FVRWristMenu2).GetMethod("Update", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method10 = typeof(WristMenuPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method11 = typeof(FVRWristMenu2).GetMethod("Awake", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method12 = typeof(WristMenuPatch).GetMethod("AwakePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method9, harmony, breaking: true);
			PatchController.Verify(method11, harmony, breaking: true);
			harmony.Patch((MethodBase)method9, new HarmonyMethod(method10), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method11, new HarmonyMethod(method12), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method13 = typeof(GM).GetMethod("InitScene", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method14 = typeof(GMInitScenePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method13, harmony, breaking: true);
			harmony.Patch((MethodBase)method13, (HarmonyMethod)null, new HarmonyMethod(method14), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method15 = typeof(TNH_ScoreDisplay).GetMethod("ReloadLevel", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method16 = typeof(TNH_ScoreDisplayReloadPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method15, harmony, breaking: true);
			harmony.Patch((MethodBase)method15, new HarmonyMethod(method16), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method17 = typeof(GM).GetMethod("set_CurrentAIManager", BindingFlags.Static | BindingFlags.Public);
			MethodInfo method18 = typeof(SetCurrentAIManagerPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method17, harmony, breaking: true);
			harmony.Patch((MethodBase)method17, (HarmonyMethod)null, new HarmonyMethod(method18), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method19 = typeof(VaultSystem).GetMethod("ClearExistingSaveableObjects", BindingFlags.Static | BindingFlags.Public);
			MethodInfo method20 = typeof(CleanUpPatch).GetMethod("ClearExistingSaveableObjectsPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method21 = typeof(FVRWristMenuSection_CleanUp).GetMethod("CleanUpScene_Empties", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method22 = typeof(CleanUpPatch).GetMethod("EmptiesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method23 = typeof(FVRWristMenuSection_CleanUp).GetMethod("CleanUpScene_AllMags", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method24 = typeof(CleanUpPatch).GetMethod("AllMagsPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method25 = typeof(FVRWristMenuSection_CleanUp).GetMethod("CleanUpScene_Guns", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method26 = typeof(CleanUpPatch).GetMethod("GunsPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method19, harmony, breaking: true);
			PatchController.Verify(method21, harmony, breaking: false);
			PatchController.Verify(method23, harmony, breaking: false);
			PatchController.Verify(method25, harmony, breaking: false);
			harmony.Patch((MethodBase)method19, new HarmonyMethod(method20), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method21, new HarmonyMethod(method22), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method23, new HarmonyMethod(method24), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method25, new HarmonyMethod(method26), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method27 = typeof(FVRPlayerBody).GetMethod("SetHealthThreshold", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method28 = typeof(SetHealthThresholdPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method27, harmony, breaking: false);
			harmony.Patch((MethodBase)method27, new HarmonyMethod(method28), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method29 = typeof(FVRPlayerBody).GetMethod("Init", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method30 = typeof(PlayerBodyInitPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method29, harmony, breaking: true);
			harmony.Patch((MethodBase)method29, (HarmonyMethod)null, new HarmonyMethod(method30), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method31 = typeof(TNH_ScoreDisplay).GetMethod("SubmitScoreAndGoToBoard", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method32 = typeof(ScorePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method31, harmony, breaking: false);
			harmony.Patch((MethodBase)method31, new HarmonyMethod(method32), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	public class LoadLevelBeginPatch
	{
		public static string loadingLevel;

		private static void Prefix(string levelName)
		{
			loadingLevel = levelName;
			loadingLevel = loadingLevel.Replace("Assets/", "");
			loadingLevel = loadingLevel.Replace(".unity", "");
		}
	}
	internal class KinematicPatch
	{
		public static int skip;

		private static bool Prefix(ref Rigidbody __instance, bool value)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0 || (Object)(object)__instance == (Object)null)
			{
				return true;
			}
			if (value)
			{
				KinematicMarker component = ((Component)__instance).GetComponent<KinematicMarker>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
			}
			else
			{
				TrackedItem component2 = ((Component)__instance).GetComponent<TrackedItem>();
				if ((Object)(object)component2 != (Object)null && component2.data.controller != GameManager.ID)
				{
					return false;
				}
				KinematicMarker component3 = ((Component)__instance).GetComponent<KinematicMarker>();
				if ((Object)(object)component3 != (Object)null)
				{
					Object.Destroy((Object)(object)component3);
				}
			}
			return true;
		}
	}
	internal class PhysicalObjectRBPatch
	{
		private static void Postfix(FVRPhysicalObject __instance)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedItem component = ((Component)__instance).GetComponent<TrackedItem>();
			if ((Object)(object)component != (Object)null && component.data.controller != GameManager.ID)
			{
				KinematicMarker component2 = ((Component)__instance.RootRigidbody).GetComponent<KinematicMarker>();
				if ((Object)(object)component2 == (Object)null)
				{
					component2 = ((Component)__instance.RootRigidbody).gameObject.AddComponent<KinematicMarker>();
				}
				KinematicPatch.skip++;
				__instance.RootRigidbody.isKinematic = true;
				KinematicPatch.skip--;
			}
		}
	}
	internal class SetPlayerIFFPatch
	{
		public static int skip;

		private static void Prefix(int iff)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null) && skip <= 0)
			{
				if (ThreadManager.host)
				{
					ServerSend.PlayerIFF(GameManager.ID, iff);
				}
				else
				{
					ClientSend.PlayerIFF(iff);
				}
			}
		}
	}
	internal class WristMenuPatch
	{
		private static void UpdatePrefix(FVRWristMenu2 __instance)
		{
			if (!H3MPWristMenuSection.init)
			{
				H3MPWristMenuSection.init = true;
				AddSections(__instance);
				__instance.RegenerateButtons();
			}
		}

		private static void AwakePrefix(FVRWristMenu2 __instance)
		{
			AddSections(__instance);
		}

		private static void AddSections(FVRWristMenu2 __instance)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Section_H3MP", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(__instance.MenuGO.transform);
			val.transform.localPosition = new Vector3(0f, 300f, 0f);
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(350f, 350f);
			FVRWristMenuSection val2 = (FVRWristMenuSection)(object)val.AddComponent<H3MPWristMenuSection>();
			val2.ButtonText = "H3MP";
			__instance.Sections.Add(val2);
			val.SetActive(false);
			val = new GameObject("Section_Body", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(__instance.MenuGO.transform);
			val.transform.localPosition = new Vector3(0f, 300f, 0f);
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(350f, 350f);
			val2 = (FVRWristMenuSection)(object)val.AddComponent<BodyWristMenuSection>();
			val2.ButtonText = "Body";
			__instance.Sections.Add(val2);
			val.SetActive(false);
		}
	}
	internal class GMInitScenePatch
	{
		private static void Postfix(FVRPlayerBody ___m_currentPlayerBody)
		{
			if ((Object)(object)Mod.managerObject != (Object)null && (Object)(object)___m_currentPlayerBody != (Object)null)
			{
				((Behaviour)___m_currentPlayerBody.EyeCam).enabled = !GameManager.spectatorHost;
			}
		}
	}
	internal class TNH_ScoreDisplayReloadPatch
	{
		private static bool Prefix()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if ((int)Mod.currentTNHInstance.phase != 2)
				{
					for (int i = 0; i < Mod.currentTNHInstance.currentlyPlaying.Count; i++)
					{
						if (Mod.currentTNHInstance.currentlyPlaying[i] != GameManager.ID && !Mod.currentTNHInstance.dead.Contains(Mod.currentTNHInstance.currentlyPlaying[i]))
						{
							GM.CurrentMovementManager.TeleportToPoint(((Component)GameManager.players[Mod.currentTNHInstance.currentlyPlaying[i]]).transform.position, true);
							return false;
						}
					}
				}
				if (Mod.currentTNHInstance.controller == GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.ResetTNH(Mod.currentTNHInstance.instance);
					}
					else
					{
						ClientSend.ResetTNH(Mod.currentTNHInstance.instance);
					}
					return false;
				}
			}
			return true;
		}
	}
	internal class SetCurrentAIManagerPatch
	{
		private static void Postfix()
		{
			if ((Object)(object)Mod.managerObject != (Object)null || !((Object)(object)GM.CurrentAIManager != (Object)null))
			{
				return;
			}
			foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
			{
				if (player.Value.visible && (Object)(object)player.Value.playerBody != (Object)null)
				{
					player.Value.playerBody.physicalPlayerBody.SetEntitiesRegistered(registered: true);
				}
			}
			for (int i = 0; i < GameManager.objects.Count; i++)
			{
				if (GameManager.objects[i] is TrackedSosigData)
				{
					AIEntity e = (GameManager.objects[i] as TrackedSosigData).physicalSosig.physicalSosig.E;
					if ((Object)(object)GameManager.objects[i].physical != (Object)null && !GM.CurrentAIManager.m_knownEntities.Contains(e))
					{
						GM.CurrentAIManager.RegisterAIEntity(e);
					}
				}
				else if (GameManager.objects[i] is TrackedAutoMeaterData)
				{
					AIEntity e2 = (GameManager.objects[i] as TrackedAutoMeaterData).physicalAutoMeater.physicalAutoMeater.E;
					if ((Object)(object)GameManager.objects[i].physical != (Object)null && !GM.CurrentAIManager.m_knownEntities.Contains(e2))
					{
						GM.CurrentAIManager.RegisterAIEntity(e2);
					}
				}
			}
		}
	}
	internal class CleanUpPatch
	{
		private static bool EmptiesPrefix(FVRWristMenuSection_CleanUp __instance)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)__instance).transform.position);
			if (!__instance.askConfirm_CleanupEmpties)
			{
				__instance.ResetConfirm();
				__instance.AskConfirm_CleanupEmpties();
				return false;
			}
			__instance.ResetConfirm();
			FVRFireArmMagazine[] array = Object.FindObjectsOfType<FVRFireArmMagazine>();
			for (int num = array.Length - 1; num >= 0; num--)
			{
				TrackedItem value;
				TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array[num], out value) ? value : ((Component)array[num]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID || !trackedItem.itemData.underActiveControl)) || (Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID) && !((FVRInteractiveObject)array[num]).IsHeld && (Object)(object)((FVRPhysicalObject)array[num]).QuickbeltSlot == (Object)null && (Object)(object)array[num].FireArm == (Object)null && array[num].m_numRounds == 0 && !array[num].IsIntegrated)
				{
					Object.Destroy((Object)(object)((Component)array[num]).gameObject);
				}
			}
			FVRFireArmRound[] array2 = Object.FindObjectsOfType<FVRFireArmRound>();
			for (int num2 = array2.Length - 1; num2 >= 0; num2--)
			{
				TrackedItem value2;
				TrackedItem trackedItem2 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array2[num2], out value2) ? value2 : ((Component)array2[num2]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem2 == (Object)null || trackedItem2.data.controller == GameManager.ID || !trackedItem2.itemData.underActiveControl)) || (Object)(object)trackedItem2 == (Object)null || trackedItem2.data.controller == GameManager.ID) && !((FVRInteractiveObject)array2[num2]).IsHeld && (Object)(object)((FVRPhysicalObject)array2[num2]).QuickbeltSlot == (Object)null && (Object)(object)((FVRPhysicalObject)array2[num2]).RootRigidbody != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array2[num2]).gameObject);
				}
			}
			FVRFireArmClip[] array3 = Object.FindObjectsOfType<FVRFireArmClip>();
			for (int num3 = array3.Length - 1; num3 >= 0; num3--)
			{
				TrackedItem value3;
				TrackedItem trackedItem3 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array3[num3], out value3) ? value3 : ((Component)array3[num3]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem3 == (Object)null || trackedItem3.data.controller == GameManager.ID || !trackedItem3.itemData.underActiveControl)) || (Object)(object)trackedItem3 == (Object)null || trackedItem3.data.controller == GameManager.ID) && !((FVRInteractiveObject)array3[num3]).IsHeld && (Object)(object)((FVRPhysicalObject)array3[num3]).QuickbeltSlot == (Object)null && (Object)(object)array3[num3].FireArm == (Object)null && array3[num3].m_numRounds == 0)
				{
					Object.Destroy((Object)(object)((Component)array3[num3]).gameObject);
				}
			}
			Speedloader[] array4 = Object.FindObjectsOfType<Speedloader>();
			for (int num4 = array4.Length - 1; num4 >= 0; num4--)
			{
				TrackedItem value4;
				TrackedItem trackedItem4 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array4[num4], out value4) ? value4 : ((Component)array4[num4]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem4 == (Object)null || trackedItem4.data.controller == GameManager.ID || !trackedItem4.itemData.underActiveControl)) || (Object)(object)trackedItem4 == (Object)null || trackedItem4.data.controller == GameManager.ID) && !((FVRInteractiveObject)array4[num4]).IsHeld && (Object)(object)((FVRPhysicalObject)array4[num4]).QuickbeltSlot == (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array4[num4]).gameObject);
				}
			}
			return false;
		}

		private static bool AllMagsPrefix(FVRWristMenuSection_CleanUp __instance)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)__instance).transform.position);
			if (!__instance.askConfirm_CleanupAllMags)
			{
				__instance.AskConfirm_CleanupAllMags();
				return false;
			}
			__instance.ResetConfirm();
			FVRFireArmMagazine[] array = Object.FindObjectsOfType<FVRFireArmMagazine>();
			for (int num = array.Length - 1; num >= 0; num--)
			{
				TrackedItem value;
				TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array[num], out value) ? value : ((Component)array[num]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID || !trackedItem.itemData.underActiveControl)) || (Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID) && !((FVRInteractiveObject)array[num]).IsHeld && (Object)(object)((FVRPhysicalObject)array[num]).QuickbeltSlot == (Object)null && (Object)(object)array[num].FireArm == (Object)null && !array[num].IsIntegrated)
				{
					Object.Destroy((Object)(object)((Component)array[num]).gameObject);
				}
			}
			FVRFireArmRound[] array2 = Object.FindObjectsOfType<FVRFireArmRound>();
			for (int num2 = array2.Length - 1; num2 >= 0; num2--)
			{
				TrackedItem value2;
				TrackedItem trackedItem2 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array2[num2], out value2) ? value2 : ((Component)array2[num2]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem2 == (Object)null || trackedItem2.data.controller == GameManager.ID || !trackedItem2.itemData.underActiveControl)) || (Object)(object)trackedItem2 == (Object)null || trackedItem2.data.controller == GameManager.ID) && !((FVRInteractiveObject)array2[num2]).IsHeld && (Object)(object)((FVRPhysicalObject)array2[num2]).QuickbeltSlot == (Object)null && (Object)(object)((FVRPhysicalObject)array2[num2]).RootRigidbody != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array2[num2]).gameObject);
				}
			}
			FVRFireArmClip[] array3 = Object.FindObjectsOfType<FVRFireArmClip>();
			for (int num3 = array3.Length - 1; num3 >= 0; num3--)
			{
				TrackedItem value3;
				TrackedItem trackedItem3 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array3[num3], out value3) ? value3 : ((Component)array3[num3]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem3 == (Object)null || trackedItem3.data.controller == GameManager.ID || !trackedItem3.itemData.underActiveControl)) || (Object)(object)trackedItem3 == (Object)null || trackedItem3.data.controller == GameManager.ID) && !((FVRInteractiveObject)array3[num3]).IsHeld && (Object)(object)((FVRPhysicalObject)array3[num3]).QuickbeltSlot == (Object)null && (Object)(object)array3[num3].FireArm == (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array3[num3]).gameObject);
				}
			}
			Speedloader[] array4 = Object.FindObjectsOfType<Speedloader>();
			for (int num4 = array4.Length - 1; num4 >= 0; num4--)
			{
				TrackedItem value4;
				TrackedItem trackedItem4 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array4[num4], out value4) ? value4 : ((Component)array4[num4]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem4 == (Object)null || trackedItem4.data.controller == GameManager.ID || !trackedItem4.itemData.underActiveControl)) || (Object)(object)trackedItem4 == (Object)null || trackedItem4.data.controller == GameManager.ID) && !((FVRInteractiveObject)array4[num4]).IsHeld && (Object)(object)((FVRPhysicalObject)array4[num4]).QuickbeltSlot == (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array4[num4]).gameObject);
				}
			}
			return false;
		}

		private static bool GunsPrefix(FVRWristMenuSection_CleanUp __instance)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)__instance).transform.position);
			if (!__instance.askConfirm_CleanupGuns)
			{
				__instance.AskConfirm_CleanupGuns();
				return false;
			}
			__instance.ResetConfirm();
			FVRFireArm[] array = Object.FindObjectsOfType<FVRFireArm>();
			for (int num = array.Length - 1; num >= 0; num--)
			{
				TrackedItem value;
				TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array[num], out value) ? value : ((Component)array[num]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID || !trackedItem.itemData.underActiveControl)) || (Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID) && !((FVRInteractiveObject)array[num]).IsHeld && (Object)(object)((FVRPhysicalObject)array[num]).QuickbeltSlot == (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array[num]).gameObject);
				}
			}
			SosigWeapon[] array2 = Object.FindObjectsOfType<SosigWeapon>();
			for (int num2 = array2.Length - 1; num2 >= 0; num2--)
			{
				TrackedItem value2;
				TrackedItem trackedItem2 = (GameManager.trackedItemBySosigWeapon.TryGetValue(array2[num2], out value2) ? value2 : ((Component)array2[num2]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem2 == (Object)null || trackedItem2.data.controller == GameManager.ID || !trackedItem2.itemData.underActiveControl)) || (Object)(object)trackedItem2 == (Object)null || trackedItem2.data.controller == GameManager.ID) && !((FVRInteractiveObject)array2[num2].O).IsHeld && (Object)(object)array2[num2].O.QuickbeltSlot == (Object)null && !array2[num2].IsHeldByBot && !array2[num2].IsInBotInventory)
				{
					Object.Destroy((Object)(object)((Component)array2[num2]).gameObject);
				}
			}
			FVRMeleeWeapon[] array3 = Object.FindObjectsOfType<FVRMeleeWeapon>();
			for (int num3 = array3.Length - 1; num3 >= 0; num3--)
			{
				TrackedItem value3;
				TrackedItem trackedItem3 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array3[num3], out value3) ? value3 : ((Component)array3[num3]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem3 == (Object)null || trackedItem3.data.controller == GameManager.ID || !trackedItem3.itemData.underActiveControl)) || (Object)(object)trackedItem3 == (Object)null || trackedItem3.data.controller == GameManager.ID) && !((FVRInteractiveObject)array3[num3]).IsHeld && (Object)(object)((FVRPhysicalObject)array3[num3]).QuickbeltSlot == (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array3[num3]).gameObject);
				}
			}
			FVRFireArmAttachment[] array4 = Object.FindObjectsOfType<FVRFireArmAttachment>();
			for (int num4 = array4.Length - 1; num4 >= 0; num4--)
			{
				TrackedItem value4;
				TrackedItem trackedItem4 = (GameManager.trackedItemByItem.TryGetValue((FVRPhysicalObject)(object)array4[num4], out value4) ? value4 : ((Component)array4[num4]).GetComponent<TrackedItem>());
				if (((ThreadManager.host && ((Object)(object)trackedItem4 == (Object)null || trackedItem4.data.controller == GameManager.ID || !trackedItem4.itemData.underActiveControl)) || (Object)(object)trackedItem4 == (Object)null || trackedItem4.data.controller == GameManager.ID) && !((FVRInteractiveObject)array4[num4]).IsHeld && (Object)(object)((FVRPhysicalObject)array4[num4]).QuickbeltSlot == (Object)null && (Object)(object)array4[num4].curMount == (Object)null)
				{
					Object.Destroy((Object)(object)((Component)array4[num4]).gameObject);
				}
			}
			return false;
		}

		private static bool ClearExistingSaveableObjectsPrefix(FVRWristMenuSection_CleanUp __instance, bool ClearNonSaveLoadable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (!SpawnVaultFileRoutinePatch.inInitSpawnVaultFileRoutine)
			{
				FVRPhysicalObject[] array = Object.FindObjectsOfType<FVRPhysicalObject>();
				for (int num = array.Length - 1; num >= 0; num--)
				{
					FVRPhysicalObject val = array[num];
					TrackedItem value;
					TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(array[num], out value) ? value : ((Component)array[num]).GetComponent<TrackedItem>());
					if (((ThreadManager.host && ((Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID || !trackedItem.itemData.underActiveControl)) || (Object)(object)trackedItem == (Object)null || trackedItem.data.controller == GameManager.ID) && !((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeSelf && !((FVRInteractiveObject)val).IsHeld && !((Object)(object)val.QuickbeltSlot != (Object)null) && !((Object)(object)val.ObjectWrapper == (Object)null) && !((Object)(object)((Component)val).gameObject.transform.parent != (Object)null) && (val.GetIsSaveLoadable() || !ClearNonSaveLoadable) && IM.HasSpawnedID(val.ObjectWrapper.SpawnedFromId))
					{
						Object.Destroy((Object)(object)((FVRInteractiveObject)val).GameObject);
					}
				}
			}
			return false;
		}
	}
	internal class SetHealthThresholdPatch
	{
		public static int skip;

		private static bool Prefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0 || GameManager.overrideMaxHealthSetting)
			{
				return true;
			}
			if (GameManager.maxHealthByInstanceByScene.TryGetValue(GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene, out var value) && value.ContainsKey(GameManager.instance))
			{
				return false;
			}
			return true;
		}
	}
	internal class PlayerBodyInitPatch
	{
		private static void Postfix(FVRPlayerBody __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.TNHSpectating)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(-3);
				((Component)__instance.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)1;
				((Component)__instance.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)1;
			}
			GameManager.RaisePlayerBodyInit(__instance);
		}
	}
	internal class ScorePatch
	{
		private static bool Prefix()
		{
			return false;
		}
	}
	internal class SetActivePatch
	{
		private static void Prefix(ref GameObject __instance, bool value)
		{
			if (value)
			{
				Mod.LogWarning("SetActivePatch called with true on " + ((Object)__instance).name + ":\n" + Environment.StackTrace);
			}
		}
	}
	internal class TeleportToPointPatch
	{
		private static void Prefix(Vector3 point)
		{
			Mod.LogWarning("TeleportToPoint called with point: (" + point.x + "," + point.y + "," + point.z + "):\n" + Environment.StackTrace);
		}
	}
	internal class DestroyPatch
	{
		private static void Prefix(Object obj)
		{
			Mod.LogInfo("Destroying " + ((object)obj)?.ToString() + ":\n" + Environment.StackTrace);
		}
	}
	internal class AIEntityCheckPatch
	{
		private unsafe static bool Prefix(AIManager __instance, AIEntity e)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Expected O, but got Unknown
			e.ResetTick();
			if (e.ReceivesEvent_Visual)
			{
				Vector3 pos = e.GetPos();
				Vector3 val = pos;
				Vector3 forward = e.SensoryFrame.forward;
				if (!e.IsVisualCheckOmni)
				{
					val += forward * e.MaximumSightRange;
				}
				Collider[] array = Physics.OverlapSphere(val, e.MaximumSightRange, LayerMask.op_Implicit(__instance.LM_Entity), (QueryTriggerInteraction)2);
				if (array.Length != 0)
				{
					Mod.LogInfo("EntityCheck on " + ((Object)e).name + " with parent: " + (((Object)(object)((Component)e).transform.parent == (Object)null) ? "null" : ((Object)((Component)e).transform.parent).name) + ", got " + array.Length + " entities");
					for (int i = 0; i < array.Length; i++)
					{
						Mod.LogInfo("\tChecking " + i + " " + ((Object)array[i]).name + " with parent: " + (((Object)(object)((Component)array[i]).transform.parent == (Object)null) ? "null" : ((Object)((Component)array[i]).transform.parent).name));
						AIEntity component = ((Component)array[i]).GetComponent<AIEntity>();
						if ((Object)(object)component == (Object)null)
						{
							continue;
						}
						Mod.LogInfo("\t\tHas AIEntity");
						if ((Object)(object)component == (Object)(object)e)
						{
							continue;
						}
						Mod.LogInfo("\t\t\tNot current AIEntity");
						if (component.IFFCode < -1)
						{
							continue;
						}
						Mod.LogInfo("\t\t\t\tGot valid IFF: " + component.IFFCode);
						if (component.IsPassiveEntity && !e.PerceivesPassiveEntities)
						{
							continue;
						}
						Vector3 pos2 = component.GetPos();
						Vector3 val2 = pos2 - pos;
						float magnitude = ((Vector3)(ref val2)).magnitude;
						float num = magnitude;
						float num2 = e.MaximumSightRange;
						string[] obj = new string[10]
						{
							"\t\t\t\t\tNot passive or we perceive, num = ",
							magnitude.ToString(),
							" from ",
							((Vector3)(ref val2)).magnitude.ToString(),
							", from pos2: ",
							null,
							null,
							null,
							null,
							null
						};
						Vector3 val3 = pos2;
						obj[5] = ((object)(*(Vector3*)(&val3))/*cast due to .constrained prefix*/).ToString();
						obj[6] = " and pos: ";
						val3 = pos;
						obj[7] = ((object)(*(Vector3*)(&val3))/*cast due to .constrained prefix*/).ToString();
						obj[8] = ", while num2 = ";
						obj[9] = num2.ToString();
						Mod.LogInfo(string.Concat(obj));
						if (!(magnitude <= component.MaxDistanceVisibleFrom))
						{
							continue;
						}
						Mod.LogInfo("\t\t\t\t\t\t" + magnitude + " <= max dist vis from: " + component.MaxDistanceVisibleFrom);
						if (!(component.VisibilityMultiplier <= 2f))
						{
							continue;
						}
						magnitude = ((!(component.VisibilityMultiplier > 1f)) ? Mathf.Lerp(0f, magnitude, component.VisibilityMultiplier) : Mathf.Lerp(magnitude, num2, component.VisibilityMultiplier - 1f));
						if (!e.IsVisualCheckOmni)
						{
							float num3 = Vector3.Angle(forward, val2);
							num2 = e.MaximumSightRange * e.SightDistanceByFOVMultiplier.Evaluate(num3 / e.MaximumSightFOV);
						}
						Mod.LogInfo("\t\t\t\t\t\t\tGot valid vis mult, num: " + magnitude + ", num2: " + num2);
						if (magnitude <= num2)
						{
							Mod.LogInfo("\t\t\t\t\t\t\t\tValid");
							if (!Physics.Linecast(pos, pos2, LayerMask.op_Implicit(e.LM_VisualOcclusionCheck), (QueryTriggerInteraction)2))
							{
								Mod.LogInfo("\t\t\t\t\t\t\t\t\tGot line of sight, sending event receive for visual event");
								float num4 = magnitude / e.MaximumSightRange * component.DangerMultiplier;
								AIEvent val4 = new AIEvent(component, (AIEType)1, num4, num);
								e.OnAIEventReceive(val4);
							}
						}
					}
				}
			}
			return false;
		}
	}
	public class InstantiationPatches
	{
		public static void DoPatching(Harmony harmony, ref int patchIndex)
		{
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0119: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_0130: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_01f6: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02bc: Expected O, but got Unknown
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Expected O, but got Unknown
			//IL_032e: Expected O, but got Unknown
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Expected O, but got Unknown
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Expected O, but got Unknown
			//IL_0426: Expected O, but got Unknown
			//IL_0426: Expected O, but got Unknown
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Expected O, but got Unknown
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Expected O, but got Unknown
			//IL_0518: Expected O, but got Unknown
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Expected O, but got Unknown
			//IL_05ac: Expected O, but got Unknown
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Expected O, but got Unknown
			//IL_05c6: Expected O, but got Unknown
			//IL_0624: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Expected O, but got Unknown
			//IL_0638: Expected O, but got Unknown
			MethodInfo method = typeof(FVRFireArmChamber).GetMethod("EjectRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[4]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(Vector3),
				typeof(bool)
			}, null);
			MethodInfo method2 = typeof(FVRFireArmChamber).GetMethod("EjectRound", BindingFlags.Instance | BindingFlags.Public, null, CallingConventions.Any, new Type[6]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(Vector3),
				typeof(Vector3),
				typeof(Quaternion),
				typeof(bool)
			}, null);
			MethodInfo method3 = typeof(ChamberEjectRoundPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method4 = typeof(ChamberEjectRoundPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method, harmony, breaking: true);
			PatchController.Verify(method2, harmony, breaking: true);
			harmony.Patch((MethodBase)method, new HarmonyMethod(method3), new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method2, new HarmonyMethod(method3), new HarmonyMethod(method4), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method5 = typeof(Object).GetMethod("Internal_CloneSingle", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method6 = typeof(Internal_CloneSinglePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method5, harmony, breaking: true);
			harmony.Patch((MethodBase)method5, (HarmonyMethod)null, new HarmonyMethod(method6), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method7 = typeof(Object).GetMethod("Internal_CloneSingleWithParent", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method8 = typeof(Internal_CloneSingleWithParentPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method9 = typeof(Internal_CloneSingleWithParentPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method7, harmony, breaking: true);
			harmony.Patch((MethodBase)method7, new HarmonyMethod(method8), new HarmonyMethod(method9), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method10 = typeof(Object).GetMethod("Internal_InstantiateSingle", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method11 = typeof(Internal_InstantiateSinglePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method10, harmony, breaking: true);
			harmony.Patch((MethodBase)method10, (HarmonyMethod)null, new HarmonyMethod(method11), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method12 = typeof(Object).GetMethod("Internal_InstantiateSingleWithParent", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method13 = typeof(Internal_InstantiateSingleWithParentPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method14 = typeof(Internal_InstantiateSingleWithParentPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method12, harmony, breaking: true);
			harmony.Patch((MethodBase)method12, new HarmonyMethod(method13), new HarmonyMethod(method14), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method15 = typeof(FVRSceneSettings).GetMethod("LoadDefaultSceneRoutine", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method16 = typeof(LoadDefaultSceneRoutinePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method17 = typeof(LoadDefaultSceneRoutinePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method15, harmony, breaking: false);
			harmony.Patch((MethodBase)method15, new HarmonyMethod(method16), new HarmonyMethod(method17), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method18 = typeof(VaultSystem).GetMethod("SpawnObjects", BindingFlags.Static | BindingFlags.Public);
			MethodInfo method19 = typeof(SpawnObjectsPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method18, harmony, breaking: false);
			harmony.Patch((MethodBase)method18, new HarmonyMethod(method19), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method20 = typeof(VaultSystem).GetMethod("SpawnVaultFileRoutine", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo methodInfo = PatchController.EnumeratorMoveNext(method20);
			MethodInfo method21 = typeof(SpawnVaultFileRoutinePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method22 = typeof(SpawnVaultFileRoutinePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method23 = typeof(SpawnVaultFileRoutinePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method20, harmony, breaking: false);
			PatchController.Verify(methodInfo, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(method21), new HarmonyMethod(method23), new HarmonyMethod(method22), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Mod.LogError("Exception caught applying InstantiationPatches.SpawnVaultFileRoutinePatch: " + ex.Message + ":\n" + ex.StackTrace);
			}
			patchIndex++;
			MethodInfo method24 = typeof(FVRPhysicalObject).GetMethod("set_IDSpawnedFrom", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method25 = typeof(IDSpawnedFromPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method24, harmony, breaking: true);
			harmony.Patch((MethodBase)method24, (HarmonyMethod)null, new HarmonyMethod(method25), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method26 = typeof(AnvilPrefabSpawn).GetMethod("InstantiateAndZero", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method27 = typeof(AnvilPrefabSpawnPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method28 = typeof(AnvilPrefabSpawnPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method26, harmony, breaking: true);
			harmony.Patch((MethodBase)method26, new HarmonyMethod(method27), new HarmonyMethod(method28), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method29 = typeof(BrutPlacer).GetMethod("Start", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method30 = typeof(BrutAssemblagePlacer).GetMethod("Start", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method31 = typeof(BrutPlacerPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method32 = typeof(BrutPlacerPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method29, harmony, breaking: true);
			PatchController.Verify(method30, harmony, breaking: true);
			harmony.Patch((MethodBase)method29, new HarmonyMethod(method31), new HarmonyMethod(method32), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method30, new HarmonyMethod(method31), new HarmonyMethod(method32), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method33 = typeof(Construct_Volume).GetMethod("SpawnConstructs", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method34 = typeof(ConstructVolumePatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method35 = typeof(ConstructVolumePatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method33, harmony, breaking: true);
			harmony.Patch((MethodBase)method33, new HarmonyMethod(method34), new HarmonyMethod(method35), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	internal class ChamberEjectRoundPatch
	{
		public static int overrideFlag;

		private static bool track;

		private static int incrementedSkip;

		private static TrackedItem chamberOwnerTrackedItem;

		private static void Prefix(ref FVRFireArmChamber __instance, ref FVRFireArmRound ___m_round, bool ForceCaseLessEject)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			incrementedSkip = 0;
			if (!((Object)(object)___m_round != (Object)null) || (!(!___m_round.IsCaseless || ForceCaseLessEject) && !__instance.SuppressCaselessDeletion))
			{
				return;
			}
			Transform val = ((Component)__instance).transform;
			chamberOwnerTrackedItem = null;
			while ((Object)(object)val != (Object)null)
			{
				chamberOwnerTrackedItem = ((Component)val).GetComponent<TrackedItem>();
				if ((Object)(object)chamberOwnerTrackedItem != (Object)null)
				{
					break;
				}
				val = val.parent;
			}
			if (__instance.IsSpent)
			{
				Mod.skipAllInstantiates++;
				incrementedSkip++;
			}
			else if (overrideFlag > 0 || (Object)(object)chamberOwnerTrackedItem == (Object)null || chamberOwnerTrackedItem.data.controller == GameManager.ID)
			{
				track = true;
			}
			else
			{
				Mod.skipAllInstantiates++;
				incrementedSkip++;
			}
		}

		private static void Postfix(FVRFireArmChamber __instance, ref FVRFireArmRound __result)
		{
			if (incrementedSkip > 0)
			{
				Mod.skipAllInstantiates -= incrementedSkip;
				incrementedSkip = 0;
			}
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			if (track)
			{
				track = false;
				Mod.OnInstantiationTrackInvoke(((Component)__result).gameObject);
				GameManager.SyncTrackedObjects(((Component)__result).transform, controlEverything: true, null);
				if (overrideFlag > 0 && (Object)(object)chamberOwnerTrackedItem != (Object)null && chamberOwnerTrackedItem.data.controller != GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.ChamberRound(chamberOwnerTrackedItem.data.trackedID, (FireArmRoundClass)(-1), chamberOwnerTrackedItem.getChamberIndex(__instance));
					}
					else
					{
						ClientSend.ChamberRound(chamberOwnerTrackedItem.data.trackedID, (FireArmRoundClass)(-1), chamberOwnerTrackedItem.getChamberIndex(__instance));
					}
				}
				return;
			}
			if (overrideFlag > 0 && (Object)(object)chamberOwnerTrackedItem != (Object)null && chamberOwnerTrackedItem.data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.ChamberRound(chamberOwnerTrackedItem.data.trackedID, (FireArmRoundClass)(-1), chamberOwnerTrackedItem.getChamberIndex(__instance));
				}
				else
				{
					ClientSend.ChamberRound(chamberOwnerTrackedItem.data.trackedID, (FireArmRoundClass)(-1), chamberOwnerTrackedItem.getChamberIndex(__instance));
				}
			}
			if ((Object)(object)__result != (Object)null)
			{
				__result.SetKillCounting(true);
				__result.Fire();
			}
		}
	}
	internal class Internal_CloneSinglePatch
	{
		private static void Postfix(ref Object __result)
		{
			if (Mod.skipAllInstantiates <= 0 && !(__result == (Object)null) && !((Object)(object)Mod.managerObject == (Object)null))
			{
				if (SpawnVaultFileRoutinePatch.inSpawnVaultFileRoutineToSkip && ((GameManager.sceneLoading && !GameManager.controlOverride) || (!GameManager.sceneLoading && !GameManager.firstPlayerInSceneInstance)) && SpawnVaultFileRoutinePatch.routineData.ContainsKey(SpawnVaultFileRoutinePatch.currentFile))
				{
					List<Object> list = SpawnVaultFileRoutinePatch.routineData[SpawnVaultFileRoutinePatch.currentFile];
					list.Add(__result);
				}
				else if (__result is GameObject)
				{
					Object obj = __result;
					Mod.OnInstantiationTrackInvoke((GameObject)(object)((obj is GameObject) ? obj : null));
					Object obj2 = __result;
					GameManager.SyncTrackedObjects(((GameObject)((obj2 is GameObject) ? obj2 : null)).transform, controlEverything: true, null);
				}
			}
		}
	}
	internal class Internal_CloneSingleWithParentPatch
	{
		private static bool track;

		private static TrackedItemData parentData;

		private static void Prefix(Object data, Transform parent)
		{
			if (Mod.skipAllInstantiates > 0 || data == (Object)null || (Object)(object)Mod.managerObject == (Object)null || !(data is GameObject))
			{
				return;
			}
			Transform val = parent;
			parentData = null;
			while ((Object)(object)val != (Object)null)
			{
				TrackedItem component = ((Component)parent).GetComponent<TrackedItem>();
				if ((Object)(object)component != (Object)null)
				{
					parentData = component.itemData;
					break;
				}
				val = val.parent;
			}
			track = parentData == null || parentData.controller == GameManager.ID;
		}

		private static void Postfix(ref Object __result, Transform parent)
		{
			if (Mod.skipAllInstantiates <= 0 && !((Object)(object)Mod.managerObject == (Object)null))
			{
				if (SpawnVaultFileRoutinePatch.inSpawnVaultFileRoutineToSkip && GameManager.playersPresent.Count > 0 && SpawnVaultFileRoutinePatch.routineData.ContainsKey(SpawnVaultFileRoutinePatch.currentFile))
				{
					List<Object> list = SpawnVaultFileRoutinePatch.routineData[SpawnVaultFileRoutinePatch.currentFile];
					list.Add(__result);
					track = false;
				}
				else if (track)
				{
					Object obj = __result;
					Mod.OnInstantiationTrackInvoke((GameObject)(object)((obj is GameObject) ? obj : null));
					track = false;
					Object obj2 = __result;
					GameManager.SyncTrackedObjects(((GameObject)((obj2 is GameObject) ? obj2 : null)).transform, controlEverything: true, parentData);
				}
			}
		}
	}
	internal class Internal_InstantiateSinglePatch
	{
		private static void Postfix(ref Object __result)
		{
			if (__result.name.Contains("Cascading"))
			{
				Mod.LogInfo("Instantiate single pach for " + __result.name);
			}
			if (Mod.skipAllInstantiates > 0)
			{
				return;
			}
			if (__result.name.Contains("Cascading"))
			{
				Mod.LogInfo("\tNo skip");
			}
			if (__result == (Object)null || (Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			if (__result.name.Contains("Cascading"))
			{
				Mod.LogInfo("\tNo skip");
			}
			if (SpawnVaultFileRoutinePatch.inSpawnVaultFileRoutineToSkip)
			{
				if (__result.name.Contains("Cascading"))
				{
					Mod.LogInfo("\t\tInvault file routine");
				}
				if (GameManager.playersPresent.Count > 0 && SpawnVaultFileRoutinePatch.routineData.ContainsKey(SpawnVaultFileRoutinePatch.currentFile))
				{
					List<Object> list = SpawnVaultFileRoutinePatch.routineData[SpawnVaultFileRoutinePatch.currentFile];
					list.Add(__result);
					return;
				}
			}
			if (__result is GameObject)
			{
				Object obj = __result;
				Mod.OnInstantiationTrackInvoke((GameObject)(object)((obj is GameObject) ? obj : null));
				Object obj2 = __result;
				GameManager.SyncTrackedObjects(((GameObject)((obj2 is GameObject) ? obj2 : null)).transform, controlEverything: true, null);
			}
		}
	}
	internal class Internal_InstantiateSingleWithParentPatch
	{
		private static bool track;

		private static TrackedItemData parentData;

		private static void Prefix(Object data, Transform parent)
		{
			if (Mod.skipAllInstantiates > 0 || data == (Object)null || (Object)(object)Mod.managerObject == (Object)null || !(data is GameObject))
			{
				return;
			}
			Transform val = parent;
			parentData = null;
			while ((Object)(object)val != (Object)null)
			{
				TrackedItem component = ((Component)parent).GetComponent<TrackedItem>();
				if ((Object)(object)component != (Object)null)
				{
					parentData = component.itemData;
					break;
				}
				val = val.parent;
			}
			track = parentData == null || parentData.controller == GameManager.ID;
		}

		private static void Postfix(ref Object __result, Transform parent)
		{
			if (Mod.skipAllInstantiates <= 0 && !((Object)(object)Mod.managerObject == (Object)null))
			{
				if (SpawnVaultFileRoutinePatch.inSpawnVaultFileRoutineToSkip && GameManager.playersPresent.Count > 0 && SpawnVaultFileRoutinePatch.routineData.ContainsKey(SpawnVaultFileRoutinePatch.currentFile))
				{
					List<Object> list = SpawnVaultFileRoutinePatch.routineData[SpawnVaultFileRoutinePatch.currentFile];
					list.Add(__result);
					track = false;
				}
				else if (track)
				{
					Object obj = __result;
					Mod.OnInstantiationTrackInvoke((GameObject)(object)((obj is GameObject) ? obj : null));
					track = false;
					Object obj2 = __result;
					GameManager.SyncTrackedObjects(((GameObject)((obj2 is GameObject) ? obj2 : null)).transform, controlEverything: true, parentData);
				}
			}
		}
	}
	internal class LoadDefaultSceneRoutinePatch
	{
		public static bool inLoadDefaultSceneRoutine;

		private static void Prefix()
		{
			inLoadDefaultSceneRoutine = true;
		}

		private static void Postfix()
		{
			inLoadDefaultSceneRoutine = false;
		}
	}
	internal class SpawnObjectsPatch
	{
		private static void Prefix(VaultFile file)
		{
			if (!LoadDefaultSceneRoutinePatch.inLoadDefaultSceneRoutine)
			{
				return;
			}
			if ((Object)(object)Mod.managerObject == (Object)null || GameManager.firstPlayerInSceneInstance)
			{
				if (SpawnVaultFileRoutinePatch.initFiles == null)
				{
					SpawnVaultFileRoutinePatch.initFiles = new List<string>();
				}
				SpawnVaultFileRoutinePatch.initFiles.Add(file.FileName);
			}
			else
			{
				if (SpawnVaultFileRoutinePatch.filesToSkip == null)
				{
					SpawnVaultFileRoutinePatch.filesToSkip = new List<string>();
				}
				SpawnVaultFileRoutinePatch.filesToSkip.Add(file.FileName);
			}
		}
	}
	internal class SpawnVaultFileRoutinePatch
	{
		public static bool inSpawnVaultFileRoutineToSkip;

		public static bool inInitSpawnVaultFileRoutine;

		public static List<string> filesToSkip;

		public static List<string> initFiles;

		public static string currentFile;

		public static Dictionary<string, List<Object>> routineData = new Dictionary<string, List<Object>>();

		public static void FinishedRoutine()
		{
			if (!inSpawnVaultFileRoutineToSkip || !routineData.ContainsKey(currentFile))
			{
				return;
			}
			foreach (Object item in routineData[currentFile])
			{
				if (item == (Object)null)
				{
					Mod.LogWarning("SpawnVaultFileRoutinePatch.FinishedRoutine object to be destroyed already null");
					continue;
				}
				TrackedObject trackedObject = null;
				if (item is GameObject)
				{
					GameObject val = (GameObject)(object)((item is GameObject) ? item : null);
					if ((Object)(object)val != (Object)null)
					{
						trackedObject = val.GetComponent<TrackedObject>();
					}
				}
				if ((Object)(object)trackedObject != (Object)null)
				{
					trackedObject.skipFullDestroy = true;
				}
				Object.Destroy(item);
			}
			routineData.Remove(currentFile);
		}

		private static void Prefix(ref VaultFile ___f)
		{
			if (filesToSkip != null && filesToSkip.Contains(___f.FileName))
			{
				inSpawnVaultFileRoutineToSkip = true;
				currentFile = ___f.FileName;
				if (!routineData.ContainsKey(___f.FileName))
				{
					routineData.Add(___f.FileName, new List<Object>());
				}
			}
			else if (initFiles != null && initFiles.Contains(___f.FileName))
			{
				inInitSpawnVaultFileRoutine = true;
				currentFile = ___f.FileName;
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			CodeInstruction item = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SpawnVaultFileRoutinePatch), "FinishedRoutine", (Type[])null, (Type[])null));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Stfld && val.operand.ToString().Equals("System.Int32 $PC") && list[i + 1].opcode == OpCodes.Ldc_I4_0 && list[i + 2].opcode == OpCodes.Ret)
				{
					list.Insert(i + 1, item);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("SpawnVaultFileRoutinePatch Transpiler not applied!");
			}
			return list;
		}

		private static void Postfix(ref VaultFile ___f)
		{
			inSpawnVaultFileRoutineToSkip = false;
			inInitSpawnVaultFileRoutine = false;
		}
	}
	internal class IDSpawnedFromPatch
	{
		private static void Postfix(ref FVRPhysicalObject __instance)
		{
			if (!((Object)(object)__instance.IDSpawnedFrom == (Object)null) && !((Object)(object)Mod.managerObject == (Object)null))
			{
				GameManager.SyncTrackedObjects(((Component)__instance).transform, controlEverything: true, null);
			}
		}
	}
	internal class AnvilPrefabSpawnPatch
	{
		public static bool inInitPrefabSpawn;

		private static bool Prefix(AnvilPrefabSpawn __instance, GameObject result)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			inInitPrefabSpawn = true;
			Mod.LogInfo("AnvilPrefabSpawn: " + ((Object)__instance).name + ", loading?: " + GameManager.sceneLoading + ", override?: " + GameManager.controlOverride + ", firstPlayerInSceneInstance?: " + GameManager.firstPlayerInSceneInstance);
			return (GameManager.sceneLoading && GameManager.controlOverride) || (!GameManager.sceneLoading && GameManager.firstPlayerInSceneInstance);
		}

		private static void Postfix()
		{
			inInitPrefabSpawn = false;
		}
	}
	internal class BrutPlacerPatch
	{
		public static bool inInitBrutPlacer;

		private static bool Prefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			inInitBrutPlacer = true;
			Mod.LogInfo("Brut(Assemblage)Placer: loading?: " + GameManager.sceneLoading + ", override?: " + GameManager.controlOverride + ", firstPlayerInSceneInstance?: " + GameManager.firstPlayerInSceneInstance);
			return (GameManager.sceneLoading && GameManager.controlOverride) || (!GameManager.sceneLoading && GameManager.firstPlayerInSceneInstance);
		}

		private static void Postfix()
		{
			inInitBrutPlacer = false;
		}
	}
	internal class ConstructVolumePatch
	{
		public static bool inInitConstructVolume;

		private static bool Prefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			inInitConstructVolume = true;
			Mod.LogInfo("Construct volume: loading?: " + GameManager.sceneLoading + ", override?: " + GameManager.controlOverride + ", firstPlayerInSceneInstance?: " + GameManager.firstPlayerInSceneInstance);
			return (GameManager.sceneLoading && GameManager.controlOverride) || (!GameManager.sceneLoading && GameManager.firstPlayerInSceneInstance);
		}

		private static void Postfix()
		{
			inInitConstructVolume = false;
		}
	}
	public class InteractionPatches
	{
		public static void DoPatching(Harmony harmony, ref int patchIndex)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0065: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Expected O, but got Unknown
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Expected O, but got Unknown
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Expected O, but got Unknown
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Expected O, but got Unknown
			//IL_038a: Expected O, but got Unknown
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Expected O, but got Unknown
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Expected O, but got Unknown
			//IL_0477: Expected O, but got Unknown
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Expected O, but got Unknown
			//IL_0491: Expected O, but got Unknown
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Expected O, but got Unknown
			MethodInfo method = typeof(FVRViveHand).GetMethod("set_CurrentInteractable", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method2 = typeof(HandCurrentInteractableSetPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method3 = typeof(HandCurrentInteractableSetPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method, harmony, breaking: true);
			harmony.Patch((MethodBase)method, new HarmonyMethod(method2), new HarmonyMethod(method3), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method4 = typeof(FVRPhysicalObject).GetMethod("SetQuickBeltSlot", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method5 = typeof(SetQuickBeltSlotPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method4, harmony, breaking: true);
			harmony.Patch((MethodBase)method4, (HarmonyMethod)null, new HarmonyMethod(method5), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method6 = typeof(SosigHand).GetMethod("PickUp", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method7 = typeof(SosigPickUpPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method6, harmony, breaking: true);
			harmony.Patch((MethodBase)method6, (HarmonyMethod)null, new HarmonyMethod(method7), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method8 = typeof(SosigHand).GetMethod("DropHeldObject", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method9 = typeof(SosigHand).GetMethod("ThrowObject", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method10 = typeof(SosigHandDropPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method8, harmony, breaking: true);
			PatchController.Verify(method9, harmony, breaking: true);
			harmony.Patch((MethodBase)method8, new HarmonyMethod(method10), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method9, new HarmonyMethod(method10), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method11 = typeof(Slot).GetMethod("PlaceObjectIn", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method12 = typeof(SosigPlaceObjectInPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method11, harmony, breaking: true);
			harmony.Patch((MethodBase)method11, (HarmonyMethod)null, new HarmonyMethod(method12), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method13 = typeof(Slot).GetMethod("DetachHeldObject", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method14 = typeof(SosigSlotDetachPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method13, harmony, breaking: true);
			harmony.Patch((MethodBase)method13, new HarmonyMethod(method14), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method15 = typeof(FVRViveHand).GetMethod("BeginFlick", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method16 = typeof(GrabbityPatch).GetMethod("FlickPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method17 = typeof(FVRViveHand).GetMethod("CastToFindHover", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method18 = typeof(GrabbityPatch).GetMethod("CastToFindHoverPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method15, harmony, breaking: false);
			PatchController.Verify(method17, harmony, breaking: false);
			harmony.Patch((MethodBase)method15, new HarmonyMethod(method16), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method17, new HarmonyMethod(method18), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method19 = typeof(GBeamer).GetMethod("ObjectSearch", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method20 = typeof(GBeamerPatch).GetMethod("ObjectSearchPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method21 = typeof(GBeamerPatch).GetMethod("ObjectSearchPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method22 = typeof(GBeamer).GetMethod("WideShunt", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method23 = typeof(GBeamerPatch).GetMethod("WideShuntTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method19, harmony, breaking: false);
			PatchController.Verify(method22, harmony, breaking: false);
			harmony.Patch((MethodBase)method19, new HarmonyMethod(method20), new HarmonyMethod(method21), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			try
			{
				harmony.Patch((MethodBase)method22, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method23), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Mod.LogError("Exception caught applying InteractionPatches.GBeamerPatch: " + ex.Message + ":\n" + ex.StackTrace);
			}
			patchIndex++;
			MethodInfo method24 = typeof(FVRViveHand).GetMethod("set_CurrentHoveredQuickbeltSlot", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method25 = typeof(HandCurrentHoveredQuickBeltSlotSetPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method26 = typeof(HandCurrentHoveredQuickBeltSlotSetPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method27 = typeof(FVRViveHand).GetMethod("set_CurrentHoveredQuickbeltSlotDirty", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method28 = typeof(HandCurrentHoveredQuickBeltSlotSetPatch).GetMethod("DirtyPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method24, harmony, breaking: false);
			PatchController.Verify(method27, harmony, breaking: false);
			harmony.Patch((MethodBase)method24, new HarmonyMethod(method25), new HarmonyMethod(method26), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method27, new HarmonyMethod(method25), new HarmonyMethod(method28), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method29 = typeof(FVRViveHand).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method30 = typeof(HandUpdatePatch).GetMethod("Transpiler", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method29, harmony, breaking: false);
			harmony.Patch((MethodBase)method29, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method30), (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}
	internal class HandCurrentInteractableSetPatch
	{
		private static FVRInteractiveObject preObject;

		private static void Prefix(ref FVRViveHand __instance, ref FVRInteractiveObject ___m_currentInteractable)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				preObject = ___m_currentInteractable;
			}
		}

		private static void Postfix(ref FVRViveHand __instance, ref FVRInteractiveObject ___m_currentInteractable)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return;
			}
			TrackedObject value2;
			if ((Object)(object)___m_currentInteractable != (Object)null)
			{
				if ((Object)(object)preObject != (Object)(object)___m_currentInteractable && GameManager.trackedObjectByInteractive.TryGetValue(___m_currentInteractable, out var value))
				{
					value.BeginInteraction(__instance);
				}
			}
			else if ((Object)(object)preObject != (Object)null && GameManager.trackedObjectByInteractive.TryGetValue(preObject, out value2))
			{
				value2.EndInteraction(__instance);
			}
		}
	}
	internal class SetQuickBeltSlotPatch
	{
		private static void Postfix(ref FVRQuickBeltSlot slot, ref FVRPhysicalObject __instance)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null) && (Object)(object)slot != (Object)null)
			{
				TrackedItem trackedItem = (GameManager.trackedItemByItem.ContainsKey(__instance) ? GameManager.trackedItemByItem[__instance] : ((Component)__instance).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID)
				{
					trackedItem.data.TakeControlRecursive();
					Mod.SetKinematicRecursive(((Component)trackedItem.physical).transform, value: false);
				}
			}
		}
	}
	internal class SosigPickUpPatch
	{
		public static int skip;

		private static void Postfix(ref SosigHand __instance, SosigWeapon o)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemBySosigWeapon.TryGetValue(o, out trackedItem) ? trackedItem : ((Component)o).GetComponent<TrackedItem>());
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.TryGetValue(__instance.S, out trackedSosig) ? trackedSosig : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedItem != (Object)null) || !((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			bool flag = __instance == __instance.S.Hand_Primary;
			trackedItem.BeginInteraction(null);
			if (ThreadManager.host)
			{
				trackedSosig.sosigData.inventory[(!flag) ? 1u : 0u] = trackedItem.data.trackedID;
				ServerSend.SosigPickUpItem(trackedSosig.data.trackedID, trackedItem.data.trackedID, flag);
				return;
			}
			if (trackedItem.data.trackedID == -1)
			{
				if (TrackedItem.unknownSosigInventoryItems.TryGetValue(trackedItem.data.localWaitingIndex, out var _))
				{
					TrackedItem.unknownSosigInventoryItems[trackedItem.data.localWaitingIndex] = new KeyValuePair<TrackedSosigData, int>(trackedSosig.sosigData, (!flag) ? 1 : 0);
				}
				else
				{
					TrackedItem.unknownSosigInventoryItems.Add(trackedItem.data.localWaitingIndex, new KeyValuePair<TrackedSosigData, int>(trackedSosig.sosigData, (!flag) ? 1 : 0));
				}
			}
			if (trackedSosig.data.trackedID == -1)
			{
				if (TrackedSosig.unknownItemInteract.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownItemInteract[trackedSosig.data.localWaitingIndex].Add(new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(0, new KeyValuePair<TrackedItemData, int>(trackedItem.itemData, (!flag) ? 1 : 0)));
				}
				else
				{
					TrackedSosig.unknownItemInteract.Add(trackedSosig.data.localWaitingIndex, new List<KeyValuePair<int, KeyValuePair<TrackedItemData, int>>>
					{
						new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(0, new KeyValuePair<TrackedItemData, int>(trackedItem.itemData, (!flag) ? 1 : 0))
					});
				}
			}
			if (trackedItem.data.trackedID != -1 && trackedSosig.data.trackedID != -1)
			{
				trackedSosig.sosigData.inventory[(!flag) ? 1u : 0u] = trackedItem.data.trackedID;
				ClientSend.SosigPickUpItem(trackedSosig, trackedItem.data.trackedID, flag);
			}
		}
	}
	internal class SosigHandDropPatch
	{
		public static int skip;

		private static void Prefix(ref SosigHand __instance)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null || !__instance.IsHoldingObject)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.S) ? GameManager.trackedSosigBySosig[__instance.S] : ((Component)__instance.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			int num = ((__instance != __instance.S.Hand_Primary) ? 1 : 0);
			trackedSosig.sosigData.inventory[num] = -1;
			Mod.LogInfo("Sosig " + trackedSosig.data.trackedID + " dropped item in hand: " + num);
			if (ThreadManager.host)
			{
				ServerSend.SosigHandDrop(trackedSosig.data.trackedID, __instance.S.Hand_Primary == __instance);
			}
			else if (trackedSosig.data.trackedID == -1)
			{
				bool flag = false;
				if (TrackedSosig.unknownItemInteract.TryGetValue(trackedSosig.data.localWaitingIndex, out var value))
				{
					for (int num2 = value.Count; num2 >= 0; num2--)
					{
						if (value[num2].Key == 0 && value[num2].Value.Value == num)
						{
							flag = true;
							value.RemoveAt(num2);
							if (value.Count == 0)
							{
								TrackedSosig.unknownItemInteract.Remove(trackedSosig.data.localWaitingIndex);
								break;
							}
						}
					}
				}
				if (!flag)
				{
					if (TrackedSosig.unknownItemInteract.ContainsKey(trackedSosig.data.localWaitingIndex))
					{
						TrackedSosig.unknownItemInteract[trackedSosig.data.localWaitingIndex].Add(new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(3, new KeyValuePair<TrackedItemData, int>(null, num)));
						return;
					}
					TrackedSosig.unknownItemInteract.Add(trackedSosig.data.localWaitingIndex, new List<KeyValuePair<int, KeyValuePair<TrackedItemData, int>>>
					{
						new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(3, new KeyValuePair<TrackedItemData, int>(null, num))
					});
				}
			}
			else
			{
				ClientSend.SosigHandDrop(trackedSosig.data.trackedID, __instance.S.Hand_Primary == __instance);
			}
		}
	}
	internal class SosigPlaceObjectInPatch
	{
		public static int skip;

		private static void Postfix(ref Slot __instance, SosigWeapon o)
		{
			if ((Object)(object)Mod.managerObject == (Object)null || skip > 0)
			{
				return;
			}
			TrackedItem trackedItem = (GameManager.trackedItemBySosigWeapon.TryGetValue(o, out trackedItem) ? trackedItem : ((Component)o).GetComponent<TrackedItem>());
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.TryGetValue(__instance.I.S, out trackedSosig) ? trackedSosig : ((Component)__instance.I.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedItem != (Object)null) || !((Object)(object)trackedSosig != (Object)null))
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < __instance.I.Slots.Count; i++)
			{
				if (__instance.I.Slots[i] == __instance)
				{
					num = i;
					break;
				}
			}
			trackedItem.BeginInteraction(null);
			if (ThreadManager.host)
			{
				trackedSosig.sosigData.inventory[num + 2] = trackedItem.data.trackedID;
				ServerSend.SosigPlaceItemIn(trackedSosig.data.trackedID, num, trackedItem.data.trackedID);
				return;
			}
			if (trackedItem.data.trackedID == -1)
			{
				if (TrackedItem.unknownSosigInventoryItems.TryGetValue(trackedItem.data.localWaitingIndex, out var _))
				{
					TrackedItem.unknownSosigInventoryItems[trackedItem.data.localWaitingIndex] = new KeyValuePair<TrackedSosigData, int>(trackedSosig.sosigData, num);
				}
				else
				{
					TrackedItem.unknownSosigInventoryItems.Add(trackedItem.data.localWaitingIndex, new KeyValuePair<TrackedSosigData, int>(trackedSosig.sosigData, num));
				}
			}
			if (trackedSosig.data.trackedID == -1)
			{
				if (TrackedSosig.unknownItemInteract.ContainsKey(trackedSosig.data.localWaitingIndex))
				{
					TrackedSosig.unknownItemInteract[trackedSosig.data.localWaitingIndex].Add(new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(1, new KeyValuePair<TrackedItemData, int>(trackedItem.itemData, num)));
				}
				else
				{
					TrackedSosig.unknownItemInteract.Add(trackedSosig.data.localWaitingIndex, new List<KeyValuePair<int, KeyValuePair<TrackedItemData, int>>>
					{
						new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(1, new KeyValuePair<TrackedItemData, int>(trackedItem.itemData, num))
					});
				}
			}
			if (trackedItem.data.trackedID != -1 && trackedSosig.data.trackedID != -1)
			{
				trackedSosig.sosigData.inventory[num + 2] = trackedItem.data.trackedID;
				ClientSend.SosigPlaceItemIn(trackedSosig.data.trackedID, num, trackedItem.data.trackedID);
			}
		}
	}
	internal class SosigSlotDetachPatch
	{
		public static int skip;

		private static void Prefix(ref Slot __instance)
		{
			if (skip > 0 || (Object)(object)Mod.managerObject == (Object)null || !__instance.IsHoldingObject)
			{
				return;
			}
			TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(__instance.I.S) ? GameManager.trackedSosigBySosig[__instance.I.S] : ((Component)__instance.I.S).GetComponent<TrackedSosig>());
			if (!((Object)(object)trackedSosig != (Object)null) || trackedSosig.data.trackedID == -1)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < __instance.I.Slots.Count; i++)
			{
				if (__instance.I.Slots[i] == __instance)
				{
					num = i;
					break;
				}
			}
			Mod.LogInfo("Sosig " + trackedSosig.data.trackedID + " drop item in slot: " + num);
			trackedSosig.sosigData.inventory[num + 2] = -1;
			if (ThreadManager.host)
			{
				ServerSend.SosigDropSlot(trackedSosig.data.trackedID, num);
			}
			else if (trackedSosig.data.trackedID == -1)
			{
				bool flag = false;
				if (TrackedSosig.unknownItemInteract.TryGetValue(trackedSosig.data.localWaitingIndex, out var value))
				{
					for (int num2 = value.Count; num2 >= 0; num2--)
					{
						if (value[num2].Key == 1 && value[num2].Value.Value == num)
						{
							flag = true;
							value.RemoveAt(num2);
							if (value.Count == 0)
							{
								TrackedSosig.unknownItemInteract.Remove(trackedSosig.data.localWaitingIndex);
								break;
							}
						}
					}
				}
				if (!flag)
				{
					if (TrackedSosig.unknownItemInteract.ContainsKey(trackedSosig.data.localWaitingIndex))
					{
						TrackedSosig.unknownItemInteract[trackedSosig.data.localWaitingIndex].Add(new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(2, new KeyValuePair<TrackedItemData, int>(null, num)));
						return;
					}
					TrackedSosig.unknownItemInteract.Add(trackedSosig.data.localWaitingIndex, new List<KeyValuePair<int, KeyValuePair<TrackedItemData, int>>>
					{
						new KeyValuePair<int, KeyValuePair<TrackedItemData, int>>(2, new KeyValuePair<TrackedItemData, int>(null, num))
					});
				}
			}
			else
			{
				ClientSend.SosigDropSlot(trackedSosig.data.trackedID, num);
			}
		}
	}
	internal class GrabbityPatch
	{
		private static bool FlickPrefix(FVRViveHand __instance, FVRPhysicalObject o)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			TrackedItem value;
			TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(o, out value) ? value : ((Component)o).GetComponent<TrackedItem>());
			if ((Object)(object)trackedItem != (Object)null)
			{
				trackedItem.BeginInteraction(__instance);
			}
			return true;
		}

		private static bool CastToFindHoverPrefix(FVRViveHand __instance, RaycastHit ___m_grabbity_hit)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_0509: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_057d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			bool flag = false;
			if (Physics.Raycast(__instance.PointingTransform.position, __instance.Input.FilteredForward, ref ___m_grabbity_hit, 10f, LayerMask.op_Implicit(__instance.LM_Grabbity_Beam), (QueryTriggerInteraction)2) && (Object)(object)((RaycastHit)(ref ___m_grabbity_hit)).collider.attachedRigidbody != (Object)null)
			{
				FVRPhysicalObject component = ((Component)((RaycastHit)(ref ___m_grabbity_hit)).collider.attachedRigidbody).gameObject.GetComponent<FVRPhysicalObject>();
				if ((Object)(object)component != (Object)null)
				{
					TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(component, out trackedItem) ? trackedItem : ((Component)component).GetComponent<TrackedItem>());
					if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID && !trackedItem.itemData.underActiveControl && ((FVRInteractiveObject)component).IsDistantGrabbable() && !Physics.Linecast(__instance.PointingTransform.position, __instance.PointingTransform.position + __instance.PointingTransform.forward * ((RaycastHit)(ref ___m_grabbity_hit)).distance, LayerMask.op_Implicit(__instance.LM_Grabbity_Block), (QueryTriggerInteraction)1))
					{
						__instance.SetGrabbityHovered(component);
						flag = true;
					}
					else if (!((FVRInteractiveObject)component).IsHeld && ((FVRInteractiveObject)component).IsDistantGrabbable() && (Object)(object)component.QuickbeltSlot == (Object)null && !component.RootRigidbody.isKinematic && !Physics.Linecast(__instance.PointingTransform.position, __instance.PointingTransform.position + __instance.PointingTransform.forward * ((RaycastHit)(ref ___m_grabbity_hit)).distance, LayerMask.op_Implicit(__instance.LM_Grabbity_Block), (QueryTriggerInteraction)1))
					{
						__instance.SetGrabbityHovered(component);
						flag = true;
					}
				}
			}
			if (!flag && Physics.SphereCast(__instance.PointingTransform.position, 0.2f, __instance.PointingTransform.forward, ref ___m_grabbity_hit, 10f, LayerMask.op_Implicit(__instance.LM_Grabbity_BeamTrigger), (QueryTriggerInteraction)2) && (Object)(object)((RaycastHit)(ref ___m_grabbity_hit)).collider.attachedRigidbody != (Object)null)
			{
				FVRPhysicalObject component2 = ((Component)((RaycastHit)(ref ___m_grabbity_hit)).collider.attachedRigidbody).gameObject.GetComponent<FVRPhysicalObject>();
				if ((Object)(object)component2 != (Object)null)
				{
					TrackedItem trackedItem2 = (GameManager.trackedItemByItem.TryGetValue(component2, out trackedItem2) ? trackedItem2 : ((Component)component2).GetComponent<TrackedItem>());
					if ((Object)(object)trackedItem2 != (Object)null && trackedItem2.data.controller != GameManager.ID && !trackedItem2.itemData.underActiveControl && ((FVRInteractiveObject)component2).IsDistantGrabbable() && !Physics.Linecast(__instance.PointingTransform.position, __instance.PointingTransform.position + __instance.PointingTransform.forward * ((RaycastHit)(ref ___m_grabbity_hit)).distance, LayerMask.op_Implicit(__instance.LM_Grabbity_Block), (QueryTriggerInteraction)1))
					{
						__instance.SetGrabbityHovered(component2);
						flag = true;
					}
					else if (!((FVRInteractiveObject)component2).IsHeld && ((FVRInteractiveObject)component2).IsDistantGrabbable() && (Object)(object)component2.QuickbeltSlot == (Object)null && !component2.RootRigidbody.isKinematic && !Physics.Linecast(__instance.PointingTransform.position, __instance.PointingTransform.position + __instance.PointingTransform.forward * ((RaycastHit)(ref ___m_grabbity_hit)).distance, LayerMask.op_Implicit(__instance.LM_Grabbity_Block), (QueryTriggerInteraction)1))
					{
						__instance.SetGrabbityHovered(component2);
						flag = true;
					}
				}
			}
			if (!flag && Physics.SphereCast(__instance.PointingTransform.position, 0.2f, __instance.PointingTransform.forward, ref ___m_grabbity_hit, 10f, LayerMask.op_Implicit(__instance.LM_Grabbity_Beam), (QueryTriggerInteraction)2) && (Object)(object)((RaycastHit)(ref ___m_grabbity_hit)).collider.attachedRigidbody != (Object)null)
			{
				FVRPhysicalObject component3 = ((Component)((RaycastHit)(ref ___m_grabbity_hit)).collider.attachedRigidbody).gameObject.GetComponent<FVRPhysicalObject>();
				if ((Object)(object)component3 != (Object)null && !((FVRInteractiveObject)component3).IsHeld && ((FVRInteractiveObject)component3).IsDistantGrabbable() && (Object)(object)component3.QuickbeltSlot == (Object)null && !component3.RootRigidbody.isKinematic && !Physics.Linecast(__instance.PointingTransform.position, __instance.PointingTransform.position + __instance.PointingTransform.forward * ((RaycastHit)(ref ___m_grabbity_hit)).distance, LayerMask.op_Implicit(__instance.LM_Grabbity_Block), (QueryTriggerInteraction)1))
				{
					TrackedItem trackedItem3 = (GameManager.trackedItemByItem.TryGetValue(component3, out trackedItem3) ? trackedItem3 : ((Component)component3).GetComponent<TrackedItem>());
					if ((Object)(object)trackedItem3 != (Object)null && trackedItem3.data.controller != GameManager.ID && !trackedItem3.itemData.underActiveControl && ((FVRInteractiveObject)component3).IsDistantGrabbable() && !Physics.Linecast(__instance.PointingTransform.position, __instance.PointingTransform.position + __instance.PointingTransform.forward * ((RaycastHit)(ref ___m_grabbity_hit)).distance, LayerMask.op_Implicit(__instance.LM_Grabbity_Block), (QueryTriggerInteraction)1))
					{
						__instance.SetGrabbityHovered(component3);
						flag = true;
					}
					else if (!((FVRInteractiveObject)component3).IsHeld && ((FVRInteractiveObject)component3).IsDistantGrabbable() && (Object)(object)component3.QuickbeltSlot == (Object)null && !component3.RootRigidbody.isKinematic && !Physics.Linecast(__instance.PointingTransform.position, __instance.PointingTransform.position + __instance.PointingTransform.forward * ((RaycastHit)(ref ___m_grabbity_hit)).distance, LayerMask.op_Implicit(__instance.LM_Grabbity_Block), (QueryTriggerInteraction)1))
					{
						__instance.SetGrabbityHovered(component3);
						flag = true;
					}
				}
			}
			if (!flag)
			{
				__instance.SetGrabbityHovered((FVRPhysicalObject)null);
			}
			return false;
		}
	}
	internal class GBeamerPatch
	{
		private static bool hadObject;

		private static void ObjectSearchPrefix(bool ___m_hasObject)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				hadObject = ___m_hasObject;
			}
		}

		private static void ObjectSearchPostfix(FVRPhysicalObject ___m_obj)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null) && !hadObject && (Object)(object)___m_obj != (Object)null)
			{
				TrackedItem value;
				TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(___m_obj, out value) ? value : ((Component)___m_obj).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem != (Object)null)
				{
					trackedItem.BeginInteraction(null);
				}
			}
		}

		private static IEnumerable<CodeInstruction> WideShuntTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_3, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GBeamerPatch), "TakeControl", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldloc_3)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("GBeamerPatch WideShuntTranspiler not applied!");
			}
			return list;
		}

		public static void TakeControl(FVRPhysicalObject physObj)
		{
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				TrackedItem value;
				TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(physObj, out value) ? value : ((Component)physObj).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem != (Object)null)
				{
					trackedItem.BeginInteraction(null);
				}
			}
		}
	}
	internal class HandCurrentHoveredQuickBeltSlotSetPatch
	{
		private static bool Prefix()
		{
			return !Mod.TNHSpectating;
		}

		private static void Postfix(FVRViveHand __instance)
		{
			if (Mod.TNHSpectating && (Object)(object)__instance.m_currentHoveredQuickbeltSlot != (Object)null)
			{
				__instance.m_currentHoveredQuickbeltSlot.IsHovered = false;
				__instance.m_currentHoveredQuickbeltSlot = null;
			}
		}

		private static void DirtyPostfix(FVRViveHand __instance)
		{
			if (Mod.TNHSpectating && (Object)(object)__instance.m_currentHoveredQuickbeltSlotDirty != (Object)null)
			{
				__instance.m_currentHoveredQuickbeltSlotDirty.IsHovered = false;
				__instance.m_currentHoveredQuickbeltSlotDirty = null;
			}
		}
	}
	internal class HandUpdatePatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldloc_S, (object)7));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(HandUpdatePatch), "GetNewFlag", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Stloc_S, (object)7));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldloc_S && val.operand.ToString().Contains("(7)"))
				{
					list.InsertRange(i, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("HandUpdatePatch Transpiler not applied!");
			}
			return list;
		}

		public static bool GetNewFlag(bool currentFlag)
		{
			return currentFlag && !Mod.TNHSpectating;
		}
	}
	public class PatchController
	{
		private static Type ILManipulatorType;

		private static MethodInfo getInstructionsMethod;

		public static Dictionary<string, int> hashes;

		public static bool writeWhenDone;

		public static int breakingPatchVerify = 0;

		public static int warningPatchVerify = 0;

		public static Assembly[] assemblies;

		public static int TNHTweakerAsmIdx = -1;

		public static Type TNHTweaker_TNHTweaker;

		public static FieldInfo TNHTweaker_TNHTweaker_SpawnedBossIndexes;

		public static FieldInfo TNHTweaker_TNHTweaker_PreventOutfitFunctionality;

		public static Type TNHTweaker_TNHPatches;

		public static MethodInfo TNHTweaker_TNHPatches_ConfigureSupplyPoint;

		public static Type TNHTweaker_PatrolPatches;

		public static Type TNHTweaker_Patrol;

		public static Type TNHTweaker_LoadedTemplateManager;

		public static FieldInfo TNHTweaker_LoadedTemplateManager_LoadedCharactersDict;

		public static Type TNHTweaker_CustomCharacter;

		public static MethodInfo TNHTweaker_CustomCharacter_GetCurrentLevel;

		public static FieldInfo TNHTweaker_CustomCharacter_ForceDisableOutfitFunctionality;

		public static FieldInfo TNHTweaker_CustomCharacter_HasPrimaryWeapon;

		public static FieldInfo TNHTweaker_CustomCharacter_PrimaryWeapon;

		public static FieldInfo TNHTweaker_CustomCharacter_HasSecondaryWeapon;

		public static FieldInfo TNHTweaker_CustomCharacter_SecondaryWeapon;

		public static FieldInfo TNHTweaker_CustomCharacter_HasTertiaryWeapon;

		public static FieldInfo TNHTweaker_CustomCharacter_TertiaryWeapon;

		public static FieldInfo TNHTweaker_CustomCharacter_HasPrimaryItem;

		public static FieldInfo TNHTweaker_CustomCharacter_PrimaryItem;

		public static FieldInfo TNHTweaker_CustomCharacter_HasSecondaryItem;

		public static FieldInfo TNHTweaker_CustomCharacter_SecondaryItem;

		public static FieldInfo TNHTweaker_CustomCharacter_HasTertiaryItem;

		public static FieldInfo TNHTweaker_CustomCharacter_TertiaryItem;

		public static FieldInfo TNHTweaker_CustomCharacter_HasShield;

		public static FieldInfo TNHTweaker_CustomCharacter_Shield;

		public static Type TNHTweaker_EquipmentGroup;

		public static MethodInfo TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups;

		public static MethodInfo TNHTweaker_EquipmentGroup_GetObjects;

		public static FieldInfo TNHTweaker_EquipmentGroup_NumMagsSpawned;

		public static FieldInfo TNHTweaker_EquipmentGroup_NumRoundsSpawned;

		public static FieldInfo TNHTweaker_EquipmentGroup_MinAmmoCapacity;

		public static FieldInfo TNHTweaker_EquipmentGroup_MaxAmmoCapacity;

		public static FieldInfo TNHTweaker_EquipmentGroup_ItemsToSpawn;

		public static Type TNHTweaker_LoadoutEntry;

		public static FieldInfo TNHTweaker_LoadoutEntry_PrimaryGroup;

		public static FieldInfo TNHTweaker_LoadoutEntry_BackupGroup;

		public static Type TNHTweaker_TNHTweakerUtils;

		public static MethodInfo TNHTweaker_TNHTweakerUtils_InstantiateFromEquipmentGroup;

		public static int MWAsmIdx = -1;

		public static Type MW_IModularWeapon;

		public static MethodInfo MW_IModularWeapon_get_AllAttachmentPoints;

		public static MethodInfo MW_IModularWeapon_ConfigureModularWeaponPart;

		public static MethodInfo MW_IModularWeapon_ApplySkin;

		public static Type MW_ModularWeaponPartsAttachmentPoint;

		public static FieldInfo MW_ModularWeaponPartsAttachmentPoint_ModularPartsGroupID;

		public static FieldInfo MW_ModularWeaponPartsAttachmentPoint_SelectedModularWeaponPart;

		public static FieldInfo MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint;

		public static Type MW_ModularWeaponPart;

		public static FieldInfo MW_ModularWeaponPart_SelectedModularWeaponPartSkinID;

		public static MethodInfo MW_ModularWeaponPart_EnablePart;

		public static Type MW_ModularBoltActionRifle;

		public static MethodInfo MW_ModularBoltActionRifle_ApplySkin;

		public static Type MW_ModularBreakActionWeapon;

		public static MethodInfo MW_ModularBreakActionWeapon_ApplySkin;

		public static Type MW_ModularClosedBoltWeapon;

		public static MethodInfo MW_ModularClosedBoltWeapon_ApplySkin;

		public static Type MW_ModularHandgun;

		public static MethodInfo MW_ModularHandgun_ApplySkin;

		public static Type MW_ModularOpenBoltReceiver;

		public static MethodInfo MW_ModularOpenBoltReceiver_ApplySkin;

		public static Type MW_ModularRevolver;

		public static MethodInfo MW_ModularRevolver_ApplySkin;

		public static Type MW_ModularTubeFedShotgun;

		public static MethodInfo MW_ModularTubeFedShotgun_ApplySkin;

		private static void GetCompatibilityData()
		{
			assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				if (assemblies[i].GetName().Name.Equals("TakeAndHoldTweaker"))
				{
					Mod.LogInfo("Found TNH tweaker assembly at " + i);
					TNHTweakerAsmIdx = i;
					TNHTweaker_TNHPatches = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.Patches.TNHPatches");
					TNHTweaker_TNHPatches_ConfigureSupplyPoint = TNHTweaker_TNHPatches.GetMethod("ConfigureSupplyPoint", BindingFlags.Static | BindingFlags.Public);
					TNHTweaker_PatrolPatches = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.Patches.PatrolPatches");
					TNHTweaker_Patrol = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.ObjectTemplates.Patrol");
					TNHTweaker_LoadedTemplateManager = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.LoadedTemplateManager");
					TNHTweaker_LoadedTemplateManager_LoadedCharactersDict = TNHTweaker_LoadedTemplateManager.GetField("LoadedCharactersDict", BindingFlags.Static | BindingFlags.Public);
					TNHTweaker_CustomCharacter = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.ObjectTemplates.CustomCharacter");
					TNHTweaker_CustomCharacter_GetCurrentLevel = TNHTweaker_CustomCharacter.GetMethod("GetCurrentLevel", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_ForceDisableOutfitFunctionality = TNHTweaker_CustomCharacter.GetField("ForceDisableOutfitFunctionality", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_HasPrimaryWeapon = TNHTweaker_CustomCharacter.GetField("HasPrimaryWeapon", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_PrimaryWeapon = TNHTweaker_CustomCharacter.GetField("PrimaryWeapon", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_HasSecondaryWeapon = TNHTweaker_CustomCharacter.GetField("HasSecondaryWeapon", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_SecondaryWeapon = TNHTweaker_CustomCharacter.GetField("SecondaryWeapon", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_HasTertiaryWeapon = TNHTweaker_CustomCharacter.GetField("HasTertiaryWeapon", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_TertiaryWeapon = TNHTweaker_CustomCharacter.GetField("TertiaryWeapon", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_HasPrimaryItem = TNHTweaker_CustomCharacter.GetField("HasPrimaryItem", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_PrimaryItem = TNHTweaker_CustomCharacter.GetField("PrimaryItem", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_HasSecondaryItem = TNHTweaker_CustomCharacter.GetField("HasSecondaryItem", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_SecondaryItem = TNHTweaker_CustomCharacter.GetField("SecondaryItem", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_HasTertiaryItem = TNHTweaker_CustomCharacter.GetField("HasTertiaryItem", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_TertiaryItem = TNHTweaker_CustomCharacter.GetField("TertiaryItem", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_HasShield = TNHTweaker_CustomCharacter.GetField("HasShield", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_CustomCharacter_Shield = TNHTweaker_CustomCharacter.GetField("Shield", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_EquipmentGroup = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.ObjectTemplates.EquipmentGroup");
					TNHTweaker_EquipmentGroup_GetSpawnedEquipmentGroups = TNHTweaker_EquipmentGroup.GetMethod("GetSpawnedEquipmentGroups", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_EquipmentGroup_GetObjects = TNHTweaker_EquipmentGroup.GetMethod("GetObjects", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_EquipmentGroup_NumMagsSpawned = TNHTweaker_EquipmentGroup.GetField("NumMagsSpawned", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_EquipmentGroup_NumRoundsSpawned = TNHTweaker_EquipmentGroup.GetField("NumRoundsSpawned", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_EquipmentGroup_MinAmmoCapacity = TNHTweaker_EquipmentGroup.GetField("MinAmmoCapacity", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_EquipmentGroup_MaxAmmoCapacity = TNHTweaker_EquipmentGroup.GetField("MaxAmmoCapacity", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_EquipmentGroup_ItemsToSpawn = TNHTweaker_EquipmentGroup.GetField("ItemsToSpawn", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_LoadoutEntry = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.ObjectTemplates.LoadoutEntry");
					TNHTweaker_LoadoutEntry_PrimaryGroup = TNHTweaker_LoadoutEntry.GetField("PrimaryGroup", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_LoadoutEntry_BackupGroup = TNHTweaker_LoadoutEntry.GetField("BackupGroup", BindingFlags.Instance | BindingFlags.Public);
					TNHTweaker_TNHTweaker = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.TNHTweaker");
					TNHTweaker_TNHTweaker_SpawnedBossIndexes = TNHTweaker_TNHTweaker.GetField("SpawnedBossIndexes", BindingFlags.Static | BindingFlags.Public);
					TNHTweaker_TNHTweaker_PreventOutfitFunctionality = TNHTweaker_TNHTweaker.GetField("PreventOutfitFunctionality", BindingFlags.Static | BindingFlags.Public);
					TNHTweaker_TNHTweakerUtils = assemblies[TNHTweakerAsmIdx].GetType("TNHTweaker.Utilities.TNHTweakerUtils");
					TNHTweaker_TNHTweakerUtils_InstantiateFromEquipmentGroup = TNHTweaker_TNHTweaker.GetMethod("InstantiateFromEquipmentGroup", BindingFlags.Static | BindingFlags.Public);
				}
				else if (assemblies[i].GetName().Name.Equals("ModularWorkshop"))
				{
					MWAsmIdx = i;
					MW_IModularWeapon = assemblies[MWAsmIdx].GetType("ModularWorkshop.IModularWeapon");
					MW_IModularWeapon_get_AllAttachmentPoints = MW_IModularWeapon.GetMethod("get_AllAttachmentPoints", BindingFlags.Instance | BindingFlags.Public);
					MW_IModularWeapon_ConfigureModularWeaponPart = MW_IModularWeapon.GetMethod("ConfigureModularWeaponPart", BindingFlags.Instance | BindingFlags.Public);
					MW_IModularWeapon_ApplySkin = MW_IModularWeapon.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularWeaponPartsAttachmentPoint = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularWeaponPartsAttachmentPoint");
					MW_ModularWeaponPartsAttachmentPoint_ModularPartsGroupID = MW_ModularWeaponPartsAttachmentPoint.GetField("ModularPartsGroupID", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularWeaponPartsAttachmentPoint_SelectedModularWeaponPart = MW_ModularWeaponPartsAttachmentPoint.GetField("SelectedModularWeaponPart", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint = MW_ModularWeaponPartsAttachmentPoint.GetField("ModularPartPoint", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularWeaponPart = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularWeaponPart");
					MW_ModularWeaponPart_SelectedModularWeaponPartSkinID = MW_ModularWeaponPart.GetField("SelectedModularWeaponPartSkinID", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularWeaponPart_EnablePart = MW_ModularWeaponPart.GetMethod("EnablePart", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularBoltActionRifle = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularBoltActionRifle");
					MW_ModularBoltActionRifle_ApplySkin = MW_ModularBoltActionRifle.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularBreakActionWeapon = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularBreakActionWeapon");
					MW_ModularBreakActionWeapon_ApplySkin = MW_ModularBreakActionWeapon.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularClosedBoltWeapon = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularClosedBoltWeapon");
					MW_ModularClosedBoltWeapon_ApplySkin = MW_ModularClosedBoltWeapon.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularHandgun = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularHandgun");
					MW_ModularHandgun_ApplySkin = MW_ModularHandgun.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularOpenBoltReceiver = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularOpenBoltReceiver");
					MW_ModularOpenBoltReceiver_ApplySkin = MW_ModularOpenBoltReceiver.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularRevolver = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularRevolver");
					MW_ModularRevolver_ApplySkin = MW_ModularRevolver.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
					MW_ModularTubeFedShotgun = assemblies[MWAsmIdx].GetType("ModularWorkshop.ModularTubeFedShotgun");
					MW_ModularTubeFedShotgun_ApplySkin = MW_ModularTubeFedShotgun.GetMethod("ApplySkin", BindingFlags.Instance | BindingFlags.Public);
				}
			}
		}

		public static void Verify(MethodInfo methodInfo, Harmony harmony, bool breaking)
		{
			if (hashes == null)
			{
				if (File.Exists(Mod.H3MPPath + "/PatchHashes.json"))
				{
					hashes = ((JToken)JObject.Parse(File.ReadAllText(Mod.H3MPPath + "/PatchHashes.json"))).ToObject<Dictionary<string, int>>();
				}
				else
				{
					hashes = new Dictionary<string, int>();
					writeWhenDone = true;
				}
			}
			if ((object)ILManipulatorType == null)
			{
				ILManipulatorType = typeof(HarmonyManipulator).Assembly.GetType("HarmonyLib.Internal.Patching.ILManipulator");
				getInstructionsMethod = ILManipulatorType.GetMethod("GetInstructions", BindingFlags.Instance | BindingFlags.Public);
			}
			string text = methodInfo.DeclaringType.Name + "." + methodInfo.Name + GetParamArrHash(methodInfo.GetParameters());
			ILGenerator iLGenerator = PatchProcessor.CreateILGenerator((MethodBase)methodInfo);
			MethodBody body = PatchManager.GetMethodPatcher((MethodBase)methodInfo).CopyOriginal().Definition.Body;
			object obj = Activator.CreateInstance(ILManipulatorType, body, false);
			object[] parameters = new object[2] { iLGenerator, null };
			List<CodeInstruction> list = (List<CodeInstruction>)getInstructionsMethod.Invoke(obj, parameters);
			string text2 = "";
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				OpCode opcode = val.opcode;
				bool flag = false;
				text2 = text2 + ((opcode == OpCodes.Call || opcode == OpCodes.Callvirt) ? "c" : opcode.ToString()) + ((val.operand == null) ? "null operand" : val.operand.ToString());
			}
			int deterministicHashCode = StringExtensions.GetDeterministicHashCode(text2);
			if (hashes.TryGetValue(text, out var value))
			{
				if (value != deterministicHashCode)
				{
					if (breaking)
					{
						Mod.LogError("PatchVerify: " + text + " failed patch verify, this will most probably break H3MP! Update the mod.\nOriginal hash: " + value + ", new hash: " + deterministicHashCode);
						breakingPatchVerify++;
					}
					else
					{
						Mod.LogWarning("PatchVerify: " + text + " failed patch verify, this will most probably break some part of H3MP. Update the mod.\nOriginal hash: " + value + ", new hash: " + deterministicHashCode);
						warningPatchVerify++;
					}
					hashes[text] = deterministicHashCode;
				}
			}
			else
			{
				hashes.Add(text, deterministicHashCode);
				if (!writeWhenDone)
				{
					Mod.LogWarning("PatchVerify: " + text + " not found in hashes. Most probably a new patch. This warning will remain until new hash file is written.");
				}
			}
		}

		private static int GetParamArrHash(ParameterInfo[] paramArr)
		{
			int num = 0;
			foreach (ParameterInfo parameterInfo in paramArr)
			{
				num += StringExtensions.GetDeterministicHashCode(parameterInfo.ParameterType.Name);
			}
			return num;
		}

		public static void DoPatching()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Harmony harmony = new Harmony("VIP.TommySoucy.H3MP");
			GetCompatibilityData();
			int num = 0;
			int patchIndex = 0;
			try
			{
				GeneralPatches.DoPatching(harmony, ref patchIndex);
				patchIndex = 0;
				num++;
				InteractionPatches.DoPatching(harmony, ref patchIndex);
				patchIndex = 0;
				num++;
				ActionPatches.DoPatching(harmony, ref patchIndex);
				patchIndex = 0;
				num++;
				InstantiationPatches.DoPatching(harmony, ref patchIndex);
				patchIndex = 0;
				num++;
				DamagePatches.DoPatching(harmony, ref patchIndex);
				patchIndex = 0;
				num++;
				TNHPatches.DoPatching(harmony, ref patchIndex);
			}
			catch (Exception ex)
			{
				Mod.LogError("PATCHING EXCEPTION AT " + num + "-" + patchIndex + ":\n" + ex.Message + ":\n" + ex.StackTrace);
			}
			ProcessPatchResult();
		}

		private static void ProcessPatchResult()
		{
			if (writeWhenDone)
			{
				File.WriteAllText(Mod.H3MPPath + "/PatchHashes.json", ((object)JObject.FromObject((object)hashes)).ToString());
			}
			if (breakingPatchVerify > 0)
			{
				Mod.LogError("PatchVerify report: " + breakingPatchVerify + " breaking, " + warningPatchVerify + " warnings.\nIf you have other mods installed this may be normal. Refer to H3MP mod compatibility list in case things break.");
			}
			else if (warningPatchVerify > 0)
			{
				Mod.LogWarning("PatchVerify report: 0 breaking, " + warningPatchVerify + " warnings.\nIf you have other mods installed this may be normal. Refer to H3MP mod compatibility list in case things break.");
			}
			List<string> list = new List<string>();
			object[] customAttributes = typeof(Mod).GetCustomAttributes(typeof(BepInDependency), inherit: false);
			foreach (object obj in customAttributes)
			{
				BepInDependency val = (BepInDependency)((obj is BepInDependency) ? obj : null);
				if (val != null)
				{
					list.Add(val.DependencyGUID);
				}
			}
			int num = 0;
			List<string> list2 = new List<string>();
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				if (!pluginInfo.Key.Equals("VIP.TommySoucy.H3MP") && !list.Contains(pluginInfo.Key))
				{
					num++;
					list2.Add(pluginInfo.Key);
				}
				switch (pluginInfo.Key)
				{
				case "dll.wfiost.h3vrutilities":
					Mod.LogWarning("You have H3VRUtilities installed! Note that any object/entity that uses the scripts included in this mod may not work with H3MP!");
					break;
				case "h3vr.cityrobo.OpenScripts":
					Mod.LogWarning("You have OpenScripts installed! Note that any object/entity that uses the scripts included in this mod may not work with H3MP!");
					break;
				case "h3vr.OpenScripts2":
					Mod.LogWarning("You have OpenScripts2 installed! Note that any object/entity that uses the scripts included in this mod may not work with H3MP!");
					break;
				case "h3vr.andrew_ftw.afcl":
					Mod.LogWarning("You have FTW Arms AFCL installed! Note that any object/entity that uses the scripts included in this mod may not work with H3MP!");
					break;
				}
			}
			Mod.LogWarning("You have at least " + num + " mods installed that are either unrecognized or unsupported by H3MP");
			Mod.LogWarning("Unknown/Unsupported mods:");
			for (int j = 0; j < list2.Count; j++)
			{
				Mod.LogWarning(list2[j]);
			}
		}

		public static MethodInfo EnumeratorMoveNext(MethodBase method)
		{
			if ((object)method == null)
			{
				return null;
			}
			IEnumerable<KeyValuePair<OpCode, object>> source = from pair in PatchProcessor.ReadMethodBody(method)
				where pair.Key == OpCodes.Newobj
				select pair;
			if (source.Count() != 1)
			{
				return null;
			}
			if (!(source.First().Value is ConstructorInfo constructorInfo))
			{
				return null;
			}
			Type declaringType = constructorInfo.DeclaringType;
			if ((object)declaringType == null)
			{
				return null;
			}
			return AccessTools.Method(declaringType, "MoveNext", (Type[])null, (Type[])null);
		}
	}
	public class TNHPatches
	{
		public static void DoPatching(Harmony harmony, ref int patchIndex)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b6: Expected O, but got Unknown
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Expected O, but got Unknown
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Expected O, but got Unknown
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Expected O, but got Unknown
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Expected O, but got Unknown
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Expected O, but got Unknown
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Expected O, but got Unknown
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Expected O, but got Unknown
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Expected O, but got Unknown
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Expected O, but got Unknown
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Expected O, but got Unknown
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Expected O, but got Unknown
			//IL_0e59: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e67: Expected O, but got Unknown
			//IL_098f: Unknown result type (might be due to invalid IL or missing references)
			//IL_099c: Expected O, but got Unknown
			//IL_09a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b0: Expected O, but got Unknown
			//IL_09b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c4: Expected O, but got Unknown
			//IL_09ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d8: Expected O, but got Unknown
			//IL_09de: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ec: Expected O, but got Unknown
			//IL_09f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a00: Expected O, but got Unknown
			//IL_0a06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a14: Expected O, but got Unknown
			//IL_0a1a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a21: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2e: Expected O, but got Unknown
			//IL_0a2e: Expected O, but got Unknown
			//IL_0a34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a48: Expected O, but got Unknown
			//IL_0a48: Expected O, but got Unknown
			//IL_0a4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a55: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a62: Expected O, but got Unknown
			//IL_0a62: Expected O, but got Unknown
			//IL_0a68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a76: Expected O, but got Unknown
			//IL_0a7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8a: Expected O, but got Unknown
			//IL_0a90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9e: Expected O, but got Unknown
			//IL_0aa4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab8: Expected O, but got Unknown
			//IL_0ab8: Expected O, but got Unknown
			//IL_0abe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad2: Expected O, but got Unknown
			//IL_0ad2: Expected O, but got Unknown
			//IL_0ad8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0adf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aec: Expected O, but got Unknown
			//IL_0aec: Expected O, but got Unknown
			//IL_0af2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b00: Expected O, but got Unknown
			//IL_0d59: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d6d: Expected O, but got Unknown
			//IL_0d6d: Expected O, but got Unknown
			//IL_0d73: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d7a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d87: Expected O, but got Unknown
			//IL_0d87: Expected O, but got Unknown
			//IL_0d8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d94: Unknown result type (might be due to invalid IL or missing references)
			//IL_0da1: Expected O, but got Unknown
			//IL_0da1: Expected O, but got Unknown
			//IL_0c05: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c0c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c19: Expected O, but got Unknown
			//IL_0c19: Expected O, but got Unknown
			//IL_0c1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c26: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c33: Expected O, but got Unknown
			//IL_0c33: Expected O, but got Unknown
			//IL_0c39: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c4d: Expected O, but got Unknown
			//IL_0c4d: Expected O, but got Unknown
			//IL_135f: Unknown result type (might be due to invalid IL or missing references)
			//IL_136d: Expected O, but got Unknown
			//IL_1373: Unknown result type (might be due to invalid IL or missing references)
			//IL_1381: Expected O, but got Unknown
			//IL_1387: Unknown result type (might be due to invalid IL or missing references)
			//IL_1395: Expected O, but got Unknown
			//IL_139b: Unknown result type (might be due to invalid IL or missing references)
			//IL_13a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_13af: Expected O, but got Unknown
			//IL_13af: Expected O, but got Unknown
			//IL_13b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_13c3: Expected O, but got Unknown
			//IL_13c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_13d7: Expected O, but got Unknown
			//IL_13dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_13eb: Expected O, but got Unknown
			//IL_13f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_13ff: Expected O, but got Unknown
			//IL_1405: Unknown result type (might be due to invalid IL or missing references)
			//IL_1413: Expected O, but got Unknown
			//IL_1419: Unknown result type (might be due to invalid IL or missing references)
			//IL_1427: Expected O, but got Unknown
			//IL_142e: Unknown result type (might be due to invalid IL or missing references)
			//IL_143b: Expected O, but got Unknown
			//IL_1441: Unknown result type (might be due to invalid IL or missing references)
			//IL_144f: Expected O, but got Unknown
			//IL_1456: Unknown result type (might be due to invalid IL or missing references)
			//IL_1463: Expected O, but got Unknown
			//IL_1469: Unknown result type (might be due to invalid IL or missing references)
			//IL_1477: Expected O, but got Unknown
			//IL_147d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1484: Unknown result type (might be due to invalid IL or missing references)
			//IL_1491: Expected O, but got Unknown
			//IL_1491: Expected O, but got Unknown
			//IL_1497: Unknown result type (might be due to invalid IL or missing references)
			//IL_149e: Unknown result type (might be due to invalid IL or missing references)
			//IL_14ab: Expected O, but got Unknown
			//IL_14ab: Expected O, but got Unknown
			//IL_14b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_14b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_14c5: Expected O, but got Unknown
			//IL_14c5: Expected O, but got Unknown
			//IL_14cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_14d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_14df: Expected O, but got Unknown
			//IL_14df: Expected O, but got Unknown
			//IL_1525: Unknown result type (might be due to invalid IL or missing references)
			//IL_1533: Expected O, but got Unknown
			//IL_1579: Unknown result type (might be due to invalid IL or missing references)
			//IL_1587: Expected O, but got Unknown
			//IL_0e1b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e27: Expected O, but got Unknown
			MethodInfo method = typeof(GM).GetMethod("set_TNH_Manager", BindingFlags.Static | BindingFlags.Public);
			MethodInfo method2 = typeof(SetTNHManagerPatch).GetMethod("Postfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method, harmony, breaking: true);
			harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method3 = typeof(TNH_Token).GetMethod("Collect", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method4 = typeof(TNH_TokenPatch).GetMethod("CollectPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method5 = typeof(TNH_TokenPatch).GetMethod("CollectPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method3, harmony, breaking: true);
			harmony.Patch((MethodBase)method3, new HarmonyMethod(method4), new HarmonyMethod(method5), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method6 = typeof(TNH_UIManager).GetMethod("SetOBS_Progression", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method7 = typeof(TNH_UIManagerPatch).GetMethod("ProgressionPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method8 = typeof(TNH_UIManager).GetMethod("SetOBS_EquipmentMode", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method9 = typeof(TNH_UIManagerPatch).GetMethod("EquipmentPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method10 = typeof(TNH_UIManager).GetMethod("SetOBS_HealthMode", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method11 = typeof(TNH_UIManagerPatch).GetMethod("HealthModePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method12 = typeof(TNH_UIManager).GetMethod("SetOBS_TargetMode", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method13 = typeof(TNH_UIManagerPatch).GetMethod("TargetPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method14 = typeof(TNH_UIManager).GetMethod("SetOBS_AIDifficulty", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method15 = typeof(TNH_UIManagerPatch).GetMethod("AIDifficultyPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method16 = typeof(TNH_UIManager).GetMethod("SetOBS_AIRadarMode", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method17 = typeof(TNH_UIManagerPatch).GetMethod("RadarModePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method18 = typeof(TNH_UIManager).GetMethod("SetOBS_ItemSpawner", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method19 = typeof(TNH_UIManagerPatch).GetMethod("ItemSpawnerModePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method20 = typeof(TNH_UIManager).GetMethod("SetOBS_Backpack", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method21 = typeof(TNH_UIManagerPatch).GetMethod("BackpackModePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method22 = typeof(TNH_UIManager).GetMethod("SetOBS_HealthMult", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method23 = typeof(TNH_UIManagerPatch).GetMethod("HealthMultPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method24 = typeof(TNH_UIManager).GetMethod("SetOBS_SosiggunShakeReloading", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method25 = typeof(TNH_UIManagerPatch).GetMethod("SosigGunReloadPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method26 = typeof(TNH_UIManager).GetMethod("SetOBS_RunSeed", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method27 = typeof(TNH_UIManagerPatch).GetMethod("SeedPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method28 = typeof(TNH_UIManager).GetMethod("SelectLevelRelative", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method29 = typeof(TNH_UIManagerPatch).GetMethod("SelectLevelRelativePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method6, harmony, breaking: false);
			PatchController.Verify(method8, harmony, breaking: false);
			PatchController.Verify(method10, harmony, breaking: false);
			PatchController.Verify(method12, harmony, breaking: false);
			PatchController.Verify(method14, harmony, breaking: false);
			PatchController.Verify(method16, harmony, breaking: false);
			PatchController.Verify(method18, harmony, breaking: false);
			PatchController.Verify(method20, harmony, breaking: false);
			PatchController.Verify(method22, harmony, breaking: false);
			PatchController.Verify(method24, harmony, breaking: false);
			PatchController.Verify(method26, harmony, breaking: false);
			PatchController.Verify(method28, harmony, breaking: false);
			harmony.Patch((MethodBase)method6, new HarmonyMethod(method7), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method8, new HarmonyMethod(method9), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method10, new HarmonyMethod(method11), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method12, new HarmonyMethod(method13), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method14, new HarmonyMethod(method15), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method16, new HarmonyMethod(method17), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method18, new HarmonyMethod(method19), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method20, new HarmonyMethod(method21), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method22, new HarmonyMethod(method23), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method24, new HarmonyMethod(method25), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method26, new HarmonyMethod(method27), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method28, new HarmonyMethod(method29), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo methodInfo = null;
			MethodInfo methodInfo2 = null;
			if (PatchController.TNHTweakerAsmIdx > -1)
			{
				methodInfo = PatchController.TNHTweaker_TNHPatches.GetMethod("SetPhase_Take_Replacement", BindingFlags.Static | BindingFlags.Public);
				Mod.LogInfo("About to patch TNH tweaker SetPhase_Take_Replacement, null?: " + ((object)methodInfo == null));
				methodInfo2 = PatchController.TNHTweaker_PatrolPatches.GetMethod("GeneratePatrol", BindingFlags.Static | BindingFlags.Public, null, CallingConventions.Any, new Type[6]
				{
					typeof(TNH_Manager),
					PatchController.TNHTweaker_Patrol,
					typeof(List<Vector3>),
					typeof(List<Vector3>),
					typeof(List<Vector3>),
					typeof(int)
				}, null);
			}
			else
			{
				methodInfo = typeof(TNH_Manager).GetMethod("SetPhase_Take", BindingFlags.Instance | BindingFlags.NonPublic);
				methodInfo2 = typeof(TNH_Manager).GetMethod("GeneratePatrol", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			MethodInfo method30 = typeof(TNH_Manager).GetMethod("PlayerDied", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method31 = typeof(TNH_ManagerPatch).GetMethod("PlayerDiedPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method32 = typeof(TNH_Manager).GetMethod("AddTokens", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method33 = typeof(TNH_ManagerPatch).GetMethod("AddTokensPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method34 = typeof(TNH_Manager).GetMethod("OnSosigKill", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method35 = typeof(TNH_ManagerPatch).GetMethod("OnSosigKillPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method36 = typeof(TNH_Manager).GetMethod("SetPhase", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method37 = typeof(TNH_ManagerPatch).GetMethod("SetPhasePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method38 = typeof(TNH_Manager).GetMethod("Update", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method39 = typeof(TNH_ManagerPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method40 = typeof(TNH_Manager).GetMethod("InitBeginningEquipment", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method41 = typeof(TNH_ManagerPatch).GetMethod("InitBeginEquipPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method42 = typeof(TNH_ManagerPatch).GetMethod("SetPhaseTakePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method43 = typeof(TNH_ManagerPatch).GetMethod("SetPhaseTakePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method44 = typeof(TNH_Manager).GetMethod("SetPhase_Hold", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method45 = typeof(TNH_ManagerPatch).GetMethod("SetPhaseHoldPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method46 = typeof(TNH_ManagerPatch).GetMethod("SetPhaseHoldPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method47 = typeof(TNH_Manager).GetMethod("SetPhase_Completed", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method48 = typeof(TNH_ManagerPatch).GetMethod("SetPhaseCompletePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method49 = typeof(TNH_ManagerPatch).GetMethod("SetPhaseCompletePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method50 = typeof(TNH_Manager).GetMethod("SetLevel", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method51 = typeof(TNH_ManagerPatch).GetMethod("SetLevelPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method52 = typeof(TNH_Manager).GetMethod("OnShotFired", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method53 = typeof(TNH_ManagerPatch).GetMethod("OnShotFiredPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method54 = typeof(TNH_Manager).GetMethod("OnBotShotFired", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method55 = typeof(TNH_ManagerPatch).GetMethod("OnBotShotFiredPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method56 = typeof(TNH_Manager).GetMethod("AddFVRObjectToTrackedList", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method57 = typeof(TNH_ManagerPatch).GetMethod("AddFVRObjectToTrackedListPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method58 = typeof(TNH_Manager).GetMethod("GenerateSentryPatrol", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method59 = typeof(TNH_ManagerPatch).GetMethod("GenerateSentryPatrolPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method60 = typeof(TNH_ManagerPatch).GetMethod("GenerateSentryPatrolPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method61 = typeof(TNH_ManagerPatch).GetMethod("GeneratePatrolPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method62 = typeof(TNH_ManagerPatch).GetMethod("GeneratePatrolPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method63 = typeof(TNH_Manager).GetMethod("DelayedInit", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method64 = typeof(TNH_ManagerPatch).GetMethod("DelayedInitPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method65 = typeof(TNH_ManagerPatch).GetMethod("DelayedInitPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method66 = typeof(TNH_Manager).GetMethod("ObjectCleanupInHold", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method67 = typeof(TNH_ManagerPatch).GetMethod("ObjectCleanupInHoldPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method30, harmony, breaking: true);
			PatchController.Verify(method32, harmony, breaking: true);
			PatchController.Verify(method34, harmony, breaking: true);
			PatchController.Verify(method36, harmony, breaking: true);
			PatchController.Verify(method38, harmony, breaking: true);
			PatchController.Verify(method40, harmony, breaking: true);
			PatchController.Verify(methodInfo, harmony, breaking: true);
			PatchController.Verify(method44, harmony, breaking: true);
			PatchController.Verify(method47, harmony, breaking: true);
			PatchController.Verify(method50, harmony, breaking: true);
			PatchController.Verify(method52, harmony, breaking: true);
			PatchController.Verify(method54, harmony, breaking: true);
			PatchController.Verify(method56, harmony, breaking: true);
			PatchController.Verify(method58, harmony, breaking: true);
			PatchController.Verify(methodInfo2, harmony, breaking: true);
			PatchController.Verify(method63, harmony, breaking: true);
			PatchController.Verify(method66, harmony, breaking: false);
			harmony.Patch((MethodBase)method30, (HarmonyMethod)null, new HarmonyMethod(method31), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method32, new HarmonyMethod(method33), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method34, new HarmonyMethod(method35), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method36, new HarmonyMethod(method37), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method38, new HarmonyMethod(method39), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method40, new HarmonyMethod(method41), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method50, new HarmonyMethod(method51), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(method42), new HarmonyMethod(method43), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method44, new HarmonyMethod(method45), new HarmonyMethod(method46), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method47, new HarmonyMethod(method48), new HarmonyMethod(method49), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method52, new HarmonyMethod(method53), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method54, new HarmonyMethod(method55), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method56, new HarmonyMethod(method57), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method58, new HarmonyMethod(method59), new HarmonyMethod(method60), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(method61), new HarmonyMethod(method62), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method63, new HarmonyMethod(method64), new HarmonyMethod(method65), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method66, new HarmonyMethod(method67), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			if (PatchController.TNHTweakerAsmIdx > -1)
			{
				MethodInfo method68 = PatchController.TNHTweaker_TNHPatches.GetMethod("SpawnSupplyGroup", BindingFlags.Static | BindingFlags.Public);
				MethodInfo method69 = PatchController.TNHTweaker_TNHPatches.GetMethod("SpawnSupplyTurrets", BindingFlags.Static | BindingFlags.Public);
				MethodInfo method70 = PatchController.TNHTweaker_TNHPatches.GetMethod("SpawnSupplyBoxes", BindingFlags.Static | BindingFlags.Public);
				PatchController.Verify(method68, harmony, breaking: false);
				PatchController.Verify(method69, harmony, breaking: false);
				PatchController.Verify(method70, harmony, breaking: false);
				MethodInfo method71 = typeof(TNH_SupplyPointPatch).GetMethod("TNHTweaker_SpawnTakeEnemyGroupPrefix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method72 = typeof(TNH_SupplyPointPatch).GetMethod("TNHTweaker_SpawnTakeEnemyGroupPostfix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method73 = typeof(TNH_SupplyPointPatch).GetMethod("TNHTweaker_SpawnDefensesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method74 = typeof(TNH_SupplyPointPatch).GetMethod("TNHTweaker_SpawnDefensesPostfix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method75 = typeof(TNH_SupplyPointPatch).GetMethod("TNHTweaker_SpawnBoxesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method76 = typeof(TNH_SupplyPointPatch).GetMethod("TNHTweaker_SpawnBoxesPostfix", BindingFlags.Static | BindingFlags.NonPublic);
				harmony.Patch((MethodBase)method68, new HarmonyMethod(method71), new HarmonyMethod(method72), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)method69, new HarmonyMethod(method73), new HarmonyMethod(method74), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)method70, new HarmonyMethod(method75), new HarmonyMethod(method76), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				MethodInfo method77 = typeof(TNH_SupplyPoint).GetMethod("SpawnTakeEnemyGroup", BindingFlags.Instance | BindingFlags.NonPublic);
				MethodInfo methodInfo3 = PatchController.EnumeratorMoveNext(method77);
				MethodInfo method78 = typeof(TNH_SupplyPoint).GetMethod("SpawnDefenses", BindingFlags.Instance | BindingFlags.NonPublic);
				MethodInfo method79 = typeof(TNH_SupplyPoint).GetMethod("SpawnBoxes", BindingFlags.Instance | BindingFlags.NonPublic);
				PatchController.Verify(method77, harmony, breaking: false);
				PatchController.Verify(method78, harmony, breaking: false);
				PatchController.Verify(method79, harmony, breaking: false);
				MethodInfo method80 = typeof(TNH_SupplyPointPatch).GetMethod("SpawnTakeEnemyGroupPrefix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method81 = typeof(TNH_SupplyPointPatch).GetMethod("SpawnTakeEnemyGroupPostfix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method82 = typeof(TNH_SupplyPointPatch).GetMethod("SpawnDefensesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method83 = typeof(TNH_SupplyPointPatch).GetMethod("SpawnDefensesPostfix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method84 = typeof(TNH_SupplyPointPatch).GetMethod("SpawnBoxesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo method85 = typeof(TNH_SupplyPointPatch).GetMethod("SpawnBoxesPostfix", BindingFlags.Static | BindingFlags.NonPublic);
				harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(method80), new HarmonyMethod(method81), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)method78, new HarmonyMethod(method82), new HarmonyMethod(method83), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)method79, new HarmonyMethod(method84), new HarmonyMethod(method85), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			patchIndex++;
			MethodInfo method86 = typeof(TAH_ReticleContact).GetMethod("Tick", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method87 = typeof(TAHReticleContactPatch).GetMethod("TickTranspiler", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method88 = typeof(TAH_ReticleContact).GetMethod("SetContactType", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method89 = typeof(TAHReticleContactPatch).GetMethod("SetContactTypePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method86, harmony, breaking: false);
			try
			{
				harmony.Patch((MethodBase)method86, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(method87), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Mod.LogError("Exception caught applying TNHPatches.TAHReticleContactPatch: " + ex.Message + ":\n" + ex.StackTrace);
			}
			harmony.Patch((MethodBase)method88, new HarmonyMethod(method89), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo methodInfo4 = null;
			MethodInfo methodInfo5 = null;
			MethodInfo methodInfo6 = null;
			MethodInfo methodInfo7 = null;
			MethodInfo methodInfo8 = null;
			if (PatchController.TNHTweakerAsmIdx > -1)
			{
				methodInfo4 = PatchController.TNHTweaker_TNHPatches.GetMethod("SpawnEncryptionReplacement", BindingFlags.Static | BindingFlags.Public);
				methodInfo5 = PatchController.TNHTweaker_TNHPatches.GetMethod("SpawnTakeGroupReplacement", BindingFlags.Static | BindingFlags.Public);
				methodInfo7 = PatchController.TNHTweaker_TNHPatches.GetMethod("SpawnHoldEnemyGroup", BindingFlags.Static | BindingFlags.Public);
				methodInfo8 = PatchController.TNHTweaker_TNHPatches.GetMethod("SpawnTurretsReplacement", BindingFlags.Static | BindingFlags.Public);
			}
			else
			{
				methodInfo4 = typeof(TNH_HoldPoint).GetMethod("SpawnTargetGroup", BindingFlags.Instance | BindingFlags.NonPublic);
				methodInfo5 = typeof(TNH_HoldPoint).GetMethod("SpawnTakeEnemyGroup", BindingFlags.Instance | BindingFlags.NonPublic);
				methodInfo6 = PatchController.EnumeratorMoveNext(methodInfo5);
				methodInfo7 = typeof(TNH_HoldPoint).GetMethod("SpawnHoldEnemyGroup", BindingFlags.Instance | BindingFlags.NonPublic);
				methodInfo8 = typeof(TNH_HoldPoint).GetMethod("SpawnTurrets", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			MethodInfo method90 = typeof(TNH_HoldPoint).GetMethod("ConfigureAsSystemNode", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method91 = typeof(TNH_HoldPointPatch).GetMethod("ConfigureAsSystemNodePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method92 = typeof(TNH_HoldPoint).GetMethod("SpawnTakeChallengeEntities", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method93 = typeof(TNH_HoldPointPatch).GetMethod("SpawnTakeChallengeEntitiesPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method94 = typeof(TNH_HoldPoint).GetMethod("BeginHoldChallenge", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method95 = typeof(TNH_HoldPointPatch).GetMethod("BeginHoldPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method96 = typeof(TNH_HoldPoint).GetMethod("RaiseRandomBarriers", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method97 = typeof(TNH_HoldPointPatch).GetMethod("RaiseRandomBarriersPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method98 = typeof(TNH_HoldPointPatch).GetMethod("RaiseRandomBarriersPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method99 = typeof(TNH_DestructibleBarrierPoint).GetMethod("SetCoverPointData", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method100 = typeof(TNH_HoldPointPatch).GetMethod("BarrierSetCoverPointDataPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method101 = typeof(TNH_HoldPoint).GetMethod("CompletePhase", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method102 = typeof(TNH_HoldPointPatch).GetMethod("CompletePhasePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method103 = typeof(TNH_HoldPoint).GetMethod("Update", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method104 = typeof(TNH_HoldPointPatch).GetMethod("UpdatePrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method105 = typeof(TNH_HoldPoint).GetMethod("BeginAnalyzing", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method106 = typeof(TNH_HoldPointPatch).GetMethod("BeginAnalyzingPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method107 = typeof(TNH_HoldPoint).GetMethod("SpawnWarpInMarkers", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method108 = typeof(TNH_HoldPointPatch).GetMethod("SpawnWarpInMarkersPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method109 = typeof(TNH_HoldPointPatch).GetMethod("SpawnTargetGroupPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method110 = typeof(TNH_HoldPoint).GetMethod("IdentifyEncryption", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method111 = typeof(TNH_HoldPointPatch).GetMethod("IdentifyEncryptionPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method112 = typeof(TNH_HoldPoint).GetMethod("FailOut", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method113 = typeof(TNH_HoldPointPatch).GetMethod("FailOutPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method114 = typeof(TNH_HoldPoint).GetMethod("BeginPhase", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method115 = typeof(TNH_HoldPointPatch).GetMethod("BeginPhasePostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method116 = typeof(TNH_HoldPoint).GetMethod("ShutDownHoldPoint", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method117 = typeof(TNH_HoldPointPatch).GetMethod("ShutDownHoldPointPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method118 = typeof(TNH_HoldPoint).GetMethod("CompleteHold", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method119 = typeof(TNH_HoldPointPatch).GetMethod("CompleteHoldPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method120 = typeof(TNH_HoldPointPatch).GetMethod("CompleteHoldPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method121 = typeof(TNH_HoldPointPatch).GetMethod("SpawnEnemyGroupPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method122 = typeof(TNH_HoldPointPatch).GetMethod("SpawnHoldEnemyGroupPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method123 = typeof(TNH_HoldPointPatch).GetMethod("SpawnEnemyGroupPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method124 = typeof(TNH_HoldPointPatch).GetMethod("SpawnTurretsPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			MethodInfo method125 = typeof(TNH_HoldPointPatch).GetMethod("SpawnTurretsPostfix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method90, harmony, breaking: true);
			PatchController.Verify(method92, harmony, breaking: true);
			PatchController.Verify(method94, harmony, breaking: true);
			PatchController.Verify(method96, harmony, breaking: true);
			PatchController.Verify(method99, harmony, breaking: true);
			PatchController.Verify(method101, harmony, breaking: true);
			PatchController.Verify(method103, harmony, breaking: true);
			PatchController.Verify(method105, harmony, breaking: true);
			PatchController.Verify(method107, harmony, breaking: false);
			PatchController.Verify(methodInfo4, harmony, breaking: true);
			PatchController.Verify(method110, harmony, breaking: true);
			PatchController.Verify(method112, harmony, breaking: true);
			PatchController.Verify(method114, harmony, breaking: true);
			PatchController.Verify(method116, harmony, breaking: true);
			PatchController.Verify(method118, harmony, breaking: true);
			PatchController.Verify(methodInfo5, harmony, breaking: true);
			PatchController.Verify(methodInfo7, harmony, breaking: true);
			PatchController.Verify(methodInfo8, harmony, breaking: true);
			harmony.Patch((MethodBase)method90, new HarmonyMethod(method91), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method92, new HarmonyMethod(method93), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method94, new HarmonyMethod(method95), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method96, new HarmonyMethod(method97), new HarmonyMethod(method98), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method99, new HarmonyMethod(method100), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method101, new HarmonyMethod(method102), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method103, new HarmonyMethod(method104), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method105, (HarmonyMethod)null, new HarmonyMethod(method106), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method107, new HarmonyMethod(method108), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo4, new HarmonyMethod(method109), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method110, (HarmonyMethod)null, new HarmonyMethod(method111), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method112, new HarmonyMethod(method113), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method114, (HarmonyMethod)null, new HarmonyMethod(method115), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method116, new HarmonyMethod(method117), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)method118, new HarmonyMethod(method119), new HarmonyMethod(method120), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo6, new HarmonyMethod(method121), new HarmonyMethod(method123), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo7, new HarmonyMethod(method122), new HarmonyMethod(method123), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo8, new HarmonyMethod(method124), new HarmonyMethod(method125), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method126 = typeof(TNH_WeaponCrate).GetMethod("SpawnObjectsRaw", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method127 = typeof(TNHWeaponCrateSpawnObjectsPatch).GetMethod("SpawnObjectsRawPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method126, harmony, breaking: false);
			harmony.Patch((MethodBase)method126, new HarmonyMethod(method127), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
			MethodInfo method128 = typeof(SceneLoader).GetMethod("LoadMG", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method129 = typeof(SceneLoaderPatch).GetMethod("LoadMGPrefix", BindingFlags.Static | BindingFlags.NonPublic);
			PatchController.Verify(method128, harmony, breaking: true);
			harmony.Patch((MethodBase)method128, new HarmonyMethod(method129), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			patchIndex++;
		}
	}
	internal class SetTNHManagerPatch
	{
		private static void Postfix()
		{
			Mod.LogInfo("SetTNHManagerPatch postfix", debug: false);
			if (!((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			Mod.LogInfo("\tConnected", debug: false);
			if (Mod.currentTNHInstance != null)
			{
				Mod.LogInfo("\t\tIn MP TNH instance", debug: false);
				if ((Object)(object)GM.TNH_Manager != (Object)null)
				{
					Mod.LogInfo("\t\t\tGM.TNH_Manager set", debug: false);
					Mod.currentTNHInstance.manager = GM.TNH_Manager;
					TNH_ManagerPatch.patrolIndex = -1;
					Mod.currentTNHInstance.AddCurrentlyPlaying(send: true, GameManager.ID, ThreadManager.host);
					Mod.currentlyPlayingTNH = true;
				}
				else if (Mod.currentlyPlayingTNH)
				{
					Mod.LogInfo("\t\t\tGM.TNH_Manager unset", debug: false);
					Mod.currentlyPlayingTNH = false;
					Mod.currentTNHInstance.RemoveCurrentlyPlaying(send: true, GameManager.ID, ThreadManager.host);
				}
				return;
			}
			Mod.LogInfo("\t\tNot in MP TNH instance", debug: false);
			if ((Object)(object)GM.TNH_Manager == (Object)null)
			{
				if (GameManager.instance != 0)
				{
					GameManager.SetInstance(0);
				}
			}
			else
			{
				Mod.setLatestInstance = true;
				GameManager.AddNewInstance();
			}
		}
	}
	internal class TNH_UIManagerPatch
	{
		public static int progressionSkip;

		public static int equipmentSkip;

		public static int healthModeSkip;

		public static int targetSkip;

		public static int AIDifficultySkip;

		public static int radarSkip;

		public static int itemSpawnerSkip;

		public static int backpackSkip;

		public static int healthMultSkip;

		public static int sosigGunReloadSkip;

		public static int seedSkip;

		private static bool ProgressionPrefix(int i)
		{
			if (progressionSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.progressionTypeSetting = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHProgression(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHProgression(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool EquipmentPrefix(int i)
		{
			if (equipmentSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.equipmentModeSetting = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHEquipment(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHEquipment(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool HealthModePrefix(int i)
		{
			if (healthModeSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.healthModeSetting = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHHealthMode(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHHealthMode(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool TargetPrefix(int i)
		{
			if (targetSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.targetModeSetting = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHTargetMode(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHTargetMode(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool AIDifficultyPrefix(int i)
		{
			if (AIDifficultySkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.AIDifficultyModifier = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHAIDifficulty(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHAIDifficulty(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool RadarModePrefix(int i)
		{
			if (radarSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.radarModeModifier = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHRadarMode(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHRadarMode(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool ItemSpawnerModePrefix(int i)
		{
			if (itemSpawnerSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.itemSpawnerMode = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHItemSpawnerMode(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHItemSpawnerMode(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool BackpackModePrefix(int i)
		{
			if (backpackSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.backpackMode = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHBackpackMode(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHBackpackMode(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool HealthMultPrefix(int i)
		{
			if (healthMultSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.healthMult = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHHealthMult(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHHealthMult(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool SosigGunReloadPrefix(int i)
		{
			if (sosigGunReloadSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.sosiggunShakeReloading = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHSosigGunReload(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHSosigGunReload(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool SeedPrefix(int i)
		{
			if (seedSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				Mod.currentTNHInstance.TNHSeed = i;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHSeed(i, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHSeed(i, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool SelectLevelRelativePrefix(ref TNH_UIManager __instance, int i)
		{
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.currentlyPlaying.Count > 0)
				{
					return false;
				}
				int index = (__instance._currentLevelIndex + i + __instance.Levels.Count) % __instance.Levels.Count;
				Mod.currentTNHInstance.levelID = __instance.Levels[index].LevelID;
				if (ThreadManager.host)
				{
					ServerSend.SetTNHLevelID(Mod.currentTNHInstance.levelID, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.SetTNHLevelID(Mod.currentTNHInstance.levelID, Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}
	}
	internal class TNH_TokenPatch
	{
		private static void CollectPrefix()
		{
			TNH_ManagerPatch.addTokensSkip++;
		}

		private static void CollectPostfix()
		{
			TNH_ManagerPatch.addTokensSkip--;
		}
	}
	internal class TNH_ManagerPatch
	{
		public static int addTokensSkip;

		public static int completeTokenSkip;

		public static int sosigKillSkip;

		public static bool inDelayedInit;

		private static bool skipNextSetPhaseTake;

		private static bool TNHInitializing;

		private static bool TNHInitialized;

		public static bool inGenerateSentryPatrol;

		public static bool inGeneratePatrol;

		public static List<Vector3> patrolPoints;

		public static int patrolIndex = -1;

		private static void PlayerDiedPostfix()
		{
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			if (Mod.currentTNHInstance.controller != GameManager.ID)
			{
				Mod.currentTNHInstance.dead.Add(GameManager.ID);
			}
			GM.TNH_Manager.SubtractTokens(GM.TNH_Manager.GetNumTokens());
			if (ThreadManager.host)
			{
				ServerSend.TNHPlayerDied(Mod.currentTNHInstance.instance, GameManager.ID);
			}
			else
			{
				ClientSend.TNHPlayerDied(Mod.currentTNHInstance.instance, GameManager.ID);
			}
			if (Mod.currentTNHInstance.PlayersStillAlive())
			{
				if (!Mod.TNHOnDeathSpectate)
				{
					return;
				}
				Mod.TNHSpectating = true;
				Mod.DropAllItems();
				if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
				{
					GM.CurrentPlayerBody.SetPlayerIFF(-3);
					if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
					{
						((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)1;
						((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)1;
					}
				}
				Mod.currentTNHInstance.manager.DispatchScore(false);
				Mod.currentTNHInstance.manager.FMODController.SwitchTo(0, 2f, false, false);
			}
			else if (Mod.currentTNHInstance.controller != GameManager.ID)
			{
				Mod.currentTNHInstance.manager.m_patrolSquads.Clear();
				Mod.currentTNHInstance.manager.FMODController.SwitchTo(0, 2f, false, false);
				for (int i = 0; i < Mod.currentTNHInstance.manager.HoldPoints.Count; i++)
				{
					TNH_HoldPoint val = Mod.currentTNHInstance.manager.HoldPoints[i];
					val.m_isInHold = false;
					val.m_state = (HoldState)0;
					val.NavBlockers.SetActive(false);
					val.m_phaseIndex = 0;
					val.m_maxPhases = 0;
					val.m_curPhase = null;
					val.DeleteSystemNode();
					val.m_activeTargets.Clear();
					val.DeleteAllActiveWarpIns();
					val.DeleteBarriers();
					val.m_activeSosigs.Clear();
					val.m_activeTurrets.Clear();
				}
				for (int j = 0; j < Mod.currentTNHInstance.manager.SupplyPoints.Count; j++)
				{
					TNH_SupplyPoint val2 = Mod.currentTNHInstance.manager.SupplyPoints[j];
					val2.m_activeSosigs.Clear();
					val2.m_activeTurrets.Clear();
					if (val2.m_trackedObjects.Count > 0)
					{
						for (int num = val2.m_trackedObjects.Count - 1; num >= 0; num--)
						{
							if ((Object)(object)val2.m_trackedObjects[num] != (Object)null)
							{
								Object.Destroy((Object)(object)val2.m_trackedObjects[num]);
							}
						}
					}
					if ((Object)(object)val2.m_constructor != (Object)null)
					{
						val2.m_constructor.GetComponent<TNH_ObjectConstructor>().ClearCase();
						Object.Destroy((Object)(object)val2.m_constructor);
						val2.m_constructor = null;
					}
					if ((Object)(object)val2.m_panel != (Object)null)
					{
						Object.Destroy((Object)(object)val2.m_panel);
						val2.m_panel = null;
					}
					for (int num2 = val2.m_panels.Count - 1; num2 >= 0; num2--)
					{
						if ((Object)(object)val2.m_panels[num2] != (Object)null)
						{
							Object.Destroy((Object)(object)val2.m_panels[num2]);
						}
						val2.m_panels.RemoveAt(num2);
					}
					val2.m_panels.Clear();
				}
				Mod.currentTNHInstance.Reset();
			}
			else
			{
				Mod.currentTNHInstance.Reset();
			}
		}

		private static bool AddTokensPrefix(int i, bool Scorethis)
		{
			if (completeTokenSkip > 0)
			{
				return false;
			}
			if (addTokensSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Scorethis)
				{
					if (ThreadManager.host)
					{
						ServerSend.TNHAddTokens(Mod.currentTNHInstance.instance, i);
					}
					else
					{
						ClientSend.TNHAddTokens(Mod.currentTNHInstance.instance, i);
					}
					Mod.currentTNHInstance.tokenCount += i;
				}
				if (Mod.currentTNHInstance.dead.Contains(GameManager.ID))
				{
					return false;
				}
			}
			return true;
		}

		private static bool OnSosigKillPrefix(Sosig s)
		{
			if (sosigKillSkip > 0)
			{
				return true;
			}
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				if (Mod.currentTNHInstance.controller != GameManager.ID)
				{
					return false;
				}
				TrackedSosig trackedSosig = (GameManager.trackedSosigBySosig.ContainsKey(s) ? GameManager.trackedSosigBySosig[s] : ((Component)s).GetComponent<TrackedSosig>());
				if ((Object)(object)trackedSosig != (Object)null)
				{
					if (trackedSosig.data.trackedID == -1)
					{
						TrackedSosig.unknownTNHKills.Add(trackedSosig.data.localWaitingIndex, Mod.currentTNHInstance.instance);
					}
					else if (ThreadManager.host)
					{
						ServerSend.TNHSosigKill(Mod.currentTNHInstance.instance, trackedSosig.data.trackedID);
					}
					else
					{
						ClientSend.TNHSosigKill(Mod.currentTNHInstance.instance, trackedSosig.data.trackedID);
					}
				}
			}
			return true;
		}

		private unsafe static bool SetPhasePrefix(TNH_Phase p)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				bool flag = (inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && Mod.currentTNHInstance.initializer != -1 && (!ThreadManager.host || !Mod.currentTNHInstance.initializationRequested));
				Mod.LogInfo("SetPhasePrefix: phase: " + ((object)(*(TNH_Phase*)(&p))/*cast due to .constrained prefix*/).ToString() + ", continuing: " + flag, debug: false);
				if (flag && (int)p == 3)
				{
					Mod.currentTNHInstance.dead.Add(GameManager.ID);
					flag &= !Mod.currentTNHInstance.PlayersStillAlive();
				}
				return flag;
			}
			return true;
		}

		private static void SetLevelPrefix(int level)
		{
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller == GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.TNHSetLevel(Mod.currentTNHInstance.instance, level);
				}
				else
				{
					ClientSend.TNHSetLevel(Mod.currentTNHInstance.instance, level);
				}
			}
		}

		private static bool SetPhaseTakePrefix()
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Invalid comparison between Unknown and I4
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Invalid comparison between Unknown and I4
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0681: Unknown result type (might be due to invalid IL or missing references)
			//IL_068f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fb: Invalid comparison between Unknown and I4
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				Mod.LogInfo("SetPhaseTakePrefix: In MP TNH", debug: false);
				if (inDelayedInit)
				{
					Mod.LogInfo("\tIn DelayedInit, this is init SetPhase_Take", debug: false);
					if (Mod.currentTNHInstance.initializer == GameManager.ID)
					{
						Mod.LogInfo("\t\tWe are initializer, set initialized and continuing", debug: false);
						TNHInitialized = true;
						Mod.currentTNHInstance.phase = (TNH_Phase)0;
						return true;
					}
					Mod.LogInfo("\t\tWe are not initializer, initializing with data", debug: false);
					InitJoinTNH();
					skipNextSetPhaseTake = true;
					return false;
				}
				Mod.LogInfo("\tNot in DelayedInit", debug: false);
				if (Mod.currentTNHInstance.controller == GameManager.ID)
				{
					Mod.LogInfo("\tWe are controller, continuing", debug: false);
					Mod.currentTNHInstance.phase = (TNH_Phase)0;
					return true;
				}
				Mod.LogInfo("\tWe are not controller, setting take phase with data", debug: false);
				Mod.currentTNHInstance.phase = (TNH_Phase)0;
				Mod.currentTNHInstance.manager.Phase = (TNH_Phase)0;
				Mod.currentTNHInstance.manager.ResetAlertedThisPhase();
				Mod.currentTNHInstance.manager.ResetPlayerTookDamageThisPhase();
				Mod.currentTNHInstance.manager.KillAllPatrols();
				object obj = null;
				if (PatchController.TNHTweakerAsmIdx > -1)
				{
					object obj2 = ((IDictionary)PatchController.TNHTweaker_LoadedTemplateManager_LoadedCharactersDict.GetValue(PatchController.TNHTweaker_LoadedTemplateManager))[GM.TNH_Manager.C];
					obj = PatchController.TNHTweaker_CustomCharacter_GetCurrentLevel.Invoke(obj2, new object[1] { GM.TNH_Manager.m_curLevel });
					((List<int>)PatchController.TNHTweaker_TNHTweaker_SpawnedBossIndexes.GetValue(PatchController.TNHTweaker_TNHTweaker)).Clear();
					PatchController.TNHTweaker_TNHTweaker_PreventOutfitFunctionality.SetValue(PatchController.TNHTweaker_TNHTweaker, PatchController.TNHTweaker_CustomCharacter_ForceDisableOutfitFunctionality.GetValue(obj2));
				}
				if ((int)Mod.currentTNHInstance.manager.RadarMode == 0)
				{
					((Component)Mod.currentTNHInstance.manager.TAHReticle).GetComponent<AIEntity>().LM_VisualOcclusionCheck = Mod.currentTNHInstance.manager.ReticleMask_Take;
				}
				else if ((int)Mod.currentTNHInstance.manager.RadarMode == 1)
				{
					((Component)Mod.currentTNHInstance.manager.TAHReticle).GetComponent<AIEntity>().LM_VisualOcclusionCheck = Mod.currentTNHInstance.manager.ReticleMask_Hold;
				}
				Mod.currentTNHInstance.manager.m_lastHoldIndex = Mod.currentTNHInstance.manager.m_curHoldIndex;
				Mod.currentTNHInstance.manager.m_curHoldIndex = Mod.currentTNHInstance.curHoldIndex;
				Mod.currentTNHInstance.manager.TAHReticle.DeRegisterTrackedType((ContactType)1);
				Mod.currentTNHInstance.manager.TAHReticle.DeRegisterTrackedType((ContactType)3);
				Mod.currentTNHInstance.manager.m_curHoldPoint = Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex];
				Level curLevel = Mod.currentTNHInstance.manager.m_curLevel;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].ConfigureAsSystemNode(curLevel.TakeChallenge, curLevel.HoldChallenge, curLevel.NumOverrideTokensForHold, Mod.currentTNHInstance.manager.m_level);
				Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].SpawnPoint_SystemNode, (ContactType)1);
				bool flag = true;
				Mod.currentTNHInstance.manager.m_activeSupplyPointIndicies = Mod.currentTNHInstance.activeSupplyPointIndices;
				if (PatchController.TNHTweakerAsmIdx > -1)
				{
					if (Mod.currentTNHInstance.manager.m_curPointSequence.UsesExplicitSingleSupplyPoints)
					{
						for (int i = 0; i < Mod.currentTNHInstance.activeSupplyPointIndices.Count; i++)
						{
							TNH_SupplyPoint val = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[i]];
							object[] array = new object[3]
							{
								val,
								obj,
								(object)(SupplyPanelType)3
							};
							PatchController.TNHTweaker_TNHPatches_ConfigureSupplyPoint.Invoke(PatchController.TNHTweaker_TNHPatches, array);
							Mod.currentTNHInstance.nextSupplyPanelType = (int)array[2];
							TAH_ReticleContact contact = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val.SpawnPoint_PlayerSpawn, (ContactType)3);
							val.SetContact(contact);
						}
					}
					else
					{
						for (int j = 0; j < Mod.currentTNHInstance.activeSupplyPointIndices.Count; j++)
						{
							TNH_SupplyPoint val2 = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[j]];
							int nextSupplyPanelType = Mod.currentTNHInstance.nextSupplyPanelType;
							object[] array2 = new object[3] { val2, obj, nextSupplyPanelType };
							PatchController.TNHTweaker_TNHPatches_ConfigureSupplyPoint.Invoke(PatchController.TNHTweaker_TNHPatches, array2);
							Mod.currentTNHInstance.nextSupplyPanelType = (int)array2[2];
							TAH_ReticleContact contact2 = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val2.SpawnPoint_PlayerSpawn, (ContactType)3);
							val2.SetContact(contact2);
						}
					}
				}
				else if (Mod.currentTNHInstance.manager.m_curPointSequence.UsesExplicitSingleSupplyPoints)
				{
					for (int k = 0; k < Mod.currentTNHInstance.activeSupplyPointIndices.Count; k++)
					{
						TNH_SupplyPoint val3 = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[k]];
						val3.Configure(curLevel.SupplyChallenge, false, false, true, (SupplyPanelType)3, 0, 0, true);
						TAH_ReticleContact contact3 = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val3.SpawnPoint_PlayerSpawn, (ContactType)3);
						val3.SetContact(contact3);
					}
				}
				else
				{
					for (int l = 0; l < Mod.currentTNHInstance.activeSupplyPointIndices.Count; l++)
					{
						TNH_SupplyPoint val4 = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[l]];
						int num = l;
						if (l > 0)
						{
							num = Mod.currentTNHInstance.nextSupplyPanelType;
							Mod.currentTNHInstance.nextSupplyPanelType++;
							if (Mod.currentTNHInstance.nextSupplyPanelType > 2)
							{
								Mod.currentTNHInstance.nextSupplyPanelType = 1;
							}
						}
						SupplyPanelType val5 = (SupplyPanelType)num;
						val4.Configure(curLevel.SupplyChallenge, false, false, true, val5, 0, 0, flag);
						flag = false;
						TAH_ReticleContact contact4 = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val4.SpawnPoint_PlayerSpawn, (ContactType)3);
						val4.SetContact(contact4);
					}
				}
				if ((int)Mod.currentTNHInstance.manager.BGAudioMode == 0)
				{
					Mod.currentTNHInstance.manager.FMODController.SwitchTo(0, 2f, false, false);
				}
				return false;
			}
			return true;
		}

		private static void SetPhaseTakePostfix()
		{
			if (skipNextSetPhaseTake)
			{
				skipNextSetPhaseTake = false;
			}
			else if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && ((inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !inDelayedInit)))
			{
				Mod.LogInfo("SetPhaseTakePostfix controller not in init or initializer in init, sending", debug: false);
				Mod.currentTNHInstance.curHoldIndex = Mod.currentTNHInstance.manager.m_curHoldIndex;
				Mod.currentTNHInstance.activeSupplyPointIndices = Mod.currentTNHInstance.manager.m_activeSupplyPointIndicies;
				if (ThreadManager.host)
				{
					ServerSend.TNHSetPhaseTake(Mod.currentTNHInstance.instance, Mod.currentTNHInstance.curHoldIndex, Mod.currentTNHInstance.activeSupplyPointIndices, inDelayedInit);
				}
				else
				{
					ClientSend.TNHSetPhaseTake(Mod.currentTNHInstance.instance, Mod.currentTNHInstance.curHoldIndex, Mod.currentTNHInstance.activeSupplyPointIndices, inDelayedInit);
				}
			}
		}

		private static bool SetPhaseHoldPrefix()
		{
			//IL_0341: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Invalid comparison between Unknown and I4
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				Mod.LogInfo("SetPhaseHoldPrefix", debug: false);
				if (Mod.currentTNHInstance.controller != GameManager.ID)
				{
					Mod.LogInfo("\tWe are not controller, this was an order, setting from data", debug: false);
					Mod.currentTNHInstance.manager.Phase = (TNH_Phase)1;
					Mod.currentTNHInstance.manager.m_fireThreshold = 0f;
					Mod.currentTNHInstance.manager.m_botKillThreshold = 0f;
					Mod.currentTNHInstance.manager.m_patrolSquads.Clear();
					((Component)Mod.currentTNHInstance.manager.TAHReticle).GetComponent<AIEntity>().LM_VisualOcclusionCheck = Mod.currentTNHInstance.manager.ReticleMask_Hold;
					Mod.currentTNHInstance.manager.TAHReticle.DeRegisterTrackedType((ContactType)3);
					if ((int)Mod.currentTNHInstance.manager.BGAudioMode == 0)
					{
						Mod.currentTNHInstance.manager.FMODController.SwitchTo(1, 0f, true, false);
					}
					for (int i = 0; i < Mod.currentTNHInstance.manager.HoldPoints.Count; i++)
					{
						TNH_HoldPoint val = Mod.currentTNHInstance.manager.HoldPoints[i];
						val.m_activeTargets.Clear();
						val.DeleteAllActiveWarpIns();
						val.DeleteBarriers();
						val.m_activeSosigs.Clear();
						val.m_activeTurrets.Clear();
					}
					for (int j = 0; j < Mod.currentTNHInstance.manager.SupplyPoints.Count; j++)
					{
						TNH_SupplyPoint val2 = Mod.currentTNHInstance.manager.SupplyPoints[j];
						val2.m_activeSosigs.Clear();
						val2.m_activeTurrets.Clear();
						if (val2.m_trackedObjects.Count > 0)
						{
							for (int num = val2.m_trackedObjects.Count - 1; num >= 0; num--)
							{
								if ((Object)(object)val2.m_trackedObjects[num] != (Object)null)
								{
									Object.Destroy((Object)(object)val2.m_trackedObjects[num]);
								}
							}
						}
						if ((Object)(object)val2.m_constructor != (Object)null)
						{
							val2.m_constructor.GetComponent<TNH_ObjectConstructor>().ClearCase();
							Object.Destroy((Object)(object)val2.m_constructor);
							val2.m_constructor = null;
						}
						if ((Object)(object)val2.m_panel != (Object)null)
						{
							Object.Destroy((Object)(object)val2.m_panel);
							val2.m_panel = null;
						}
						for (int num2 = val2.m_panels.Count - 1; num2 >= 0; num2--)
						{
							if ((Object)(object)val2.m_panels[num2] != (Object)null)
							{
								Object.Destroy((Object)(object)val2.m_panels[num2]);
							}
							val2.m_panels.RemoveAt(num2);
						}
						val2.m_panels.Clear();
					}
					return false;
				}
				Mod.currentTNHInstance.phase = (TNH_Phase)1;
			}
			return true;
		}

		private static void SetPhaseHoldPostfix()
		{
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("SetPhaseHoldPrefix, we are controller, sending", debug: false);
				if (ThreadManager.host)
				{
					ServerSend.TNHSetPhaseHold(Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.TNHSetPhaseHold(Mod.currentTNHInstance.instance);
				}
			}
		}

		private static bool SetPhaseCompletePrefix()
		{
			//IL_0482: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				Mod.LogInfo("SetPhaseCompletePrefix", debug: false);
				if (Mod.currentTNHInstance.controller != GameManager.ID)
				{
					Mod.LogInfo("\tWe are not controller, this was an order, setting from data", debug: false);
					Mod.currentTNHInstance.manager.Phase = (TNH_Phase)2;
					Mod.currentTNHInstance.manager.m_patrolSquads.Clear();
					Mod.currentTNHInstance.manager.FMODController.SwitchTo(0, 2f, false, false);
					for (int i = 0; i < Mod.currentTNHInstance.manager.HoldPoints.Count; i++)
					{
						Mod.currentTNHInstance.manager.HoldPoints[i].m_isInHold = false;
						Mod.currentTNHInstance.manager.HoldPoints[i].m_state = (HoldState)0;
						Mod.currentTNHInstance.manager.HoldPoints[i].NavBlockers.SetActive(false);
						Mod.currentTNHInstance.manager.HoldPoints[i].m_phaseIndex = 0;
						Mod.currentTNHInstance.manager.HoldPoints[i].m_maxPhases = 0;
						Mod.currentTNHInstance.manager.HoldPoints[i].m_curPhase = null;
						Mod.currentTNHInstance.manager.HoldPoints[i].DeleteSystemNode();
						Mod.currentTNHInstance.manager.HoldPoints[i].m_activeTargets.Clear();
						Mod.currentTNHInstance.manager.HoldPoints[i].DeleteAllActiveWarpIns();
						Mod.currentTNHInstance.manager.HoldPoints[i].DeleteBarriers();
						Mod.currentTNHInstance.manager.HoldPoints[i].m_activeSosigs.Clear();
						Mod.currentTNHInstance.manager.HoldPoints[i].m_activeTurrets.Clear();
					}
					for (int j = 0; j < Mod.currentTNHInstance.manager.SupplyPoints.Count; j++)
					{
						TNH_SupplyPoint val = Mod.currentTNHInstance.manager.SupplyPoints[j];
						val.m_activeSosigs.Clear();
						val.m_activeTurrets.Clear();
						if (val.m_trackedObjects.Count > 0)
						{
							for (int num = val.m_trackedObjects.Count - 1; num >= 0; num--)
							{
								if ((Object)(object)val.m_trackedObjects[num] != (Object)null)
								{
									Object.Destroy((Object)(object)val.m_trackedObjects[num]);
								}
							}
						}
						if ((Object)(object)val.m_constructor != (Object)null)
						{
							val.m_constructor.GetComponent<TNH_ObjectConstructor>().ClearCase();
							Object.Destroy((Object)(object)val.m_constructor);
							val.m_constructor = null;
						}
						if ((Object)(object)val.m_panel != (Object)null)
						{
							Object.Destroy((Object)(object)val.m_panel);
							val.m_panel = null;
						}
						for (int num2 = val.m_panels.Count - 1; num2 >= 0; num2--)
						{
							if ((Object)(object)val.m_panels[num2] != (Object)null)
							{
								Object.Destroy((Object)(object)val.m_panels[num2]);
							}
							val.m_panels.RemoveAt(num2);
						}
						val.m_panels.Clear();
					}
					Mod.currentTNHInstance.manager.EnqueueLine((TNH_VoiceLineID)121);
					GM.CurrentMovementManager.TeleportToPoint(GM.CurrentSceneSettings.DeathResetPoint.position, false);
					Mod.currentTNHInstance.manager.ItemSpawner.SetActive(true);
					Mod.currentTNHInstance.manager.ItemSpawner.transform.position = Mod.currentTNHInstance.manager.FinalItemSpawnerPoint.position;
					Mod.currentTNHInstance.manager.ItemSpawner.transform.rotation = Mod.currentTNHInstance.manager.FinalItemSpawnerPoint.rotation;
					Mod.currentTNHInstance.manager.DispatchScore(true);
					return false;
				}
				Mod.currentTNHInstance.phase = (TNH_Phase)2;
			}
			return true;
		}

		private static void SetPhaseCompletePostfix()
		{
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("SetPhaseCompletePostfix, we are controller, sending", debug: false);
				Mod.currentTNHInstance.Reset();
				if (ThreadManager.host)
				{
					ServerSend.TNHSetPhaseComplete(Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.TNHSetPhaseComplete(Mod.currentTNHInstance.instance);
				}
			}
		}

		private static bool UpdatePrefix()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Invalid comparison between Unknown and I4
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Invalid comparison between Unknown and I4
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Invalid comparison between Unknown and I4
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Invalid comparison between Unknown and I4
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				bool hasInit = Mod.currentTNHInstance.manager.m_hasInit;
				Mod.currentTNHInstance.manager.DelayedInit();
				if ((int)Mod.currentTNHInstance.manager.BGAudioMode == 0)
				{
					Mod.currentTNHInstance.manager.FMODController.Tick(Time.deltaTime);
				}
				if ((int)Mod.currentTNHInstance.manager.RadarHand == 1)
				{
					((Component)Mod.currentTNHInstance.manager.TAHReticle).transform.position = GM.CurrentPlayerBody.RightHand.position + GM.CurrentPlayerBody.RightHand.forward * -0.2f;
				}
				else
				{
					((Component)Mod.currentTNHInstance.manager.TAHReticle).transform.position = GM.CurrentPlayerBody.LeftHand.position + GM.CurrentPlayerBody.LeftHand.forward * -0.2f;
				}
				Mod.currentTNHInstance.manager.VoiceUpdate();
				Mod.currentTNHInstance.manager.FMODController.SetMasterVolume(0.25f * GM.CurrentPlayerBody.GlobalHearing);
				if ((int)Mod.currentTNHInstance.manager.Phase == 0)
				{
					for (int i = 0; i < Mod.currentTNHInstance.manager.SupplyPoints.Count; i++)
					{
						Mod.currentTNHInstance.manager.SupplyPoints[i].TestVisited();
					}
				}
				if (Mod.currentTNHInstance.initializer != -1 && Mod.currentTNHInstance.initializer != GameManager.ID && (int)Mod.currentTNHInstance.phase != -1 && !hasInit && Mod.currentTNHInstance.manager.m_hasInit && Mod.currentTNHInstance.manager.AIManager.HasInit)
				{
					Mod.LogInfo("TNH_Manager update, we were waiting for init and just got it, initing with data");
					InitJoinTNH();
				}
				return false;
			}
			return true;
		}

		private static bool DelayedInitPrefix(bool ___m_hasInit)
		{
			inDelayedInit = true;
			if (Mod.currentTNHInstance == null)
			{
				return true;
			}
			if (!___m_hasInit)
			{
				if (Mod.currentTNHInstance.initializer == -1 && Mod.currentTNHInstance.controller == GameManager.ID)
				{
					Mod.LogInfo("DelayedInitPrefix: No initializer yet and we are controller", debug: false);
					if (ThreadManager.host)
					{
						Mod.LogInfo("\tWe are server, taking initialization. Scene still loading?: " + GameManager.sceneLoading, debug: false);
						Mod.currentTNHInstance.initializer = 0;
						TNHInitializing = true;
						return !GameManager.sceneLoading;
					}
					if (!Mod.currentTNHInstance.initializationRequested)
					{
						Mod.LogInfo("\tWe are client and have not yet requested init perm, requesting", debug: false);
						ClientSend.RequestTNHInitialization(Mod.currentTNHInstance.instance);
						Mod.currentTNHInstance.initializationRequested = true;
					}
					return false;
				}
				if (Mod.currentTNHInstance.initializer == GameManager.ID)
				{
					Mod.LogInfo("DelayedInitPrefix: We are initializer", debug: false);
					if (Mod.currentTNHInstance.initializationRequested)
					{
						Mod.LogInfo("\tWe were waiting for perm, initializing. Scene still loading?: " + GameManager.sceneLoading, debug: false);
						Mod.currentTNHInstance.initializationRequested = false;
						TNHInitializing = true;
					}
					return !GameManager.sceneLoading;
				}
				Mod.LogInfo("DelayedInitPrefix: Waiting for initialization. Scene loading?: " + GameManager.sceneLoading + ", initializer: " + Mod.currentTNHInstance.initializer + ", requested: " + Mod.currentTNHInstance.initializationRequested, debug: false);
				return !GameManager.sceneLoading && Mod.currentTNHInstance.initializer != -1 && !Mod.currentTNHInstance.initializationRequested;
			}
			return true;
		}

		private static void DelayedInitPostfix(bool ___m_hasInit)
		{
			if (TNHInitializing && TNHInitialized)
			{
				Mod.LogInfo("DelayedInitPostfix: We were initializing and are now initialized, sending initializer", debug: false);
				TNHInitializing = false;
				TNHInitialized = false;
				if (ThreadManager.host)
				{
					ServerSend.TNHInitializer(Mod.currentTNHInstance.instance, 0);
				}
				else
				{
					ClientSend.TNHInitializer(Mod.currentTNHInstance.instance);
				}
			}
			inDelayedInit = false;
		}

		private static bool OnShotFiredPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				return false;
			}
			return true;
		}

		private static bool OnBotShotFiredPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				return false;
			}
			return true;
		}

		private static bool AddFVRObjectToTrackedListPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				return false;
			}
			return true;
		}

		public static void InitJoinTNH()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Expected I4, but got Unknown
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0800: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a95: Invalid comparison between Unknown and I4
			//IL_0aa1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa7: Invalid comparison between Unknown and I4
			//IL_0afe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b08: Expected O, but got Unknown
			//IL_0a37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0919: Unknown result type (might be due to invalid IL or missing references)
			//IL_091e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0928: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cf: Unknown result type (might be due to invalid IL or missing references)
			Mod.LogInfo("InitJoinTNH called", debug: false);
			Mod.currentTNHInstance.manager.Phase = Mod.currentTNHInstance.phase;
			TNH_HoldPoint val = Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex];
			Mod.currentTNHInstance.manager.m_curHoldPoint = val;
			Mod.currentTNHInstance.manager.m_curHoldIndex = Mod.currentTNHInstance.curHoldIndex;
			Mod.currentTNHInstance.manager.m_activeSupplyPointIndicies = Mod.currentTNHInstance.activeSupplyPointIndices;
			if (Mod.currentTNHInstance.holdOngoing)
			{
				Mod.LogInfo("\tHold " + Mod.currentTNHInstance.curHoldIndex + " ongoing", debug: false);
				Level curLevel = Mod.currentTNHInstance.manager.m_curLevel;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].ConfigureAsSystemNode(curLevel.TakeChallenge, curLevel.HoldChallenge, curLevel.NumOverrideTokensForHold, Mod.currentTNHInstance.manager.m_level);
				TNH_HoldPointPatch.beginHoldSendSkip++;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasActivated = true;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasInitiatedHold = true;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].BeginHoldChallenge();
				TNH_HoldPointPatch.beginHoldSendSkip--;
				GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].SpawnPoint_SystemNode.position, true);
				if (Mod.currentTNHInstance.raisedBarriers != null)
				{
					for (int i = 0; i < Mod.currentTNHInstance.raisedBarriers.Count; i++)
					{
						TNH_DestructibleBarrierPoint val2 = Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].BarrierPoints[Mod.currentTNHInstance.raisedBarriers[i]];
						BarrierDataSet val3 = val2.BarrierDataSets[Mod.currentTNHInstance.raisedBarrierPrefabIndices[i]];
						GameObject val4 = Object.Instantiate<GameObject>(val3.BarrierPrefab, ((Component)val2).transform.position, ((Component)val2).transform.rotation);
						TNH_DestructibleBarrier val5 = (val2.m_curBarrier = val4.GetComponent<TNH_DestructibleBarrier>());
						val5.InitToPlace(((Component)val2).transform.position, ((Component)val2).transform.forward);
						val5.SetBarrierPoint(val2);
						val2.SetCoverPointData(Mod.currentTNHInstance.raisedBarrierPrefabIndices[i]);
					}
				}
				HoldState holdState = Mod.currentTNHInstance.holdState;
				HoldState val6 = holdState;
				switch (val6 - 1)
				{
				case 0:
				{
					val.BeginAnalyzing();
					for (int j = 0; j < Mod.currentTNHInstance.warpInData.Count; j += 2)
					{
						val.m_warpInTargets.Add(Object.Instantiate<GameObject>(val.M.Prefab_TargetWarpingIn, Mod.currentTNHInstance.warpInData[j], Quaternion.Euler(Mod.currentTNHInstance.warpInData[j + 1])));
					}
					break;
				}
				case 2:
					SM.PlayCoreSound((FVRPooledAudioType)11, val.AUDEvent_HoldWave, ((Component)val).transform.position);
					Object.Instantiate<GameObject>(val.VFX_HoldWave, val.m_systemNode.NodeCenter.position, val.m_systemNode.NodeCenter.rotation);
					val.M.EnqueueLine((TNH_VoiceLineID)50);
					val.m_state = (HoldState)3;
					val.LowerAllBarriers();
					val.m_systemNode.SetNodeMode((SystemNodeMode)1);
					break;
				case 1:
					val.M.EnqueueEncryptionLine((TNH_EncryptionType)0);
					val.m_state = (HoldState)2;
					val.m_systemNode.SetNodeMode((SystemNodeMode)3);
					break;
				}
			}
			else
			{
				Mod.LogInfo("\tNo hold ongoing", debug: false);
				Level curLevel2 = Mod.currentTNHInstance.manager.m_curLevel;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].ConfigureAsSystemNode(curLevel2.TakeChallenge, curLevel2.HoldChallenge, curLevel2.NumOverrideTokensForHold, Mod.currentTNHInstance.manager.m_level);
				Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].SpawnPoint_SystemNode, (ContactType)1);
				object obj = null;
				if (PatchController.TNHTweakerAsmIdx > -1)
				{
					object obj2 = ((IDictionary)PatchController.TNHTweaker_LoadedTemplateManager_LoadedCharactersDict.GetValue(PatchController.TNHTweaker_LoadedTemplateManager))[GM.TNH_Manager.C];
					obj = PatchController.TNHTweaker_CustomCharacter_GetCurrentLevel.Invoke(obj2, new object[1] { GM.TNH_Manager.m_curLevel });
					((List<int>)PatchController.TNHTweaker_TNHTweaker_SpawnedBossIndexes.GetValue(PatchController.TNHTweaker_TNHTweaker)).Clear();
					PatchController.TNHTweaker_TNHTweaker_PreventOutfitFunctionality.SetValue(PatchController.TNHTweaker_TNHTweaker, PatchController.TNHTweaker_CustomCharacter_ForceDisableOutfitFunctionality.GetValue(obj2));
				}
				bool flag = true;
				int num = 0;
				if (PatchController.TNHTweakerAsmIdx > -1)
				{
					if (Mod.currentTNHInstance.manager.m_curPointSequence.UsesExplicitSingleSupplyPoints)
					{
						for (int k = 0; k < Mod.currentTNHInstance.activeSupplyPointIndices.Count; k++)
						{
							TNH_SupplyPoint val7 = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[k]];
							PatchController.TNHTweaker_TNHPatches_ConfigureSupplyPoint.Invoke(PatchController.TNHTweaker_TNHPatches, new object[3]
							{
								val7,
								obj,
								(object)(SupplyPanelType)3
							});
							TAH_ReticleContact contact = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val7.SpawnPoint_PlayerSpawn, (ContactType)3);
							val7.SetContact(contact);
						}
					}
					else
					{
						for (int l = 0; l < Mod.currentTNHInstance.activeSupplyPointIndices.Count; l++)
						{
							TNH_SupplyPoint val8 = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[l]];
							PatchController.TNHTweaker_TNHPatches_ConfigureSupplyPoint.Invoke(PatchController.TNHTweaker_TNHPatches, new object[3] { val8, obj, num });
							TAH_ReticleContact contact2 = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val8.SpawnPoint_PlayerSpawn, (ContactType)3);
							val8.SetContact(contact2);
						}
					}
				}
				else if (Mod.currentTNHInstance.manager.m_curPointSequence.UsesExplicitSingleSupplyPoints)
				{
					for (int m = 0; m < Mod.currentTNHInstance.activeSupplyPointIndices.Count; m++)
					{
						TNH_SupplyPoint val9 = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[m]];
						val9.Configure(curLevel2.SupplyChallenge, false, false, true, (SupplyPanelType)3, 0, 0, true);
						TAH_ReticleContact contact3 = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val9.SpawnPoint_PlayerSpawn, (ContactType)3);
						val9.SetContact(contact3);
					}
				}
				else
				{
					for (int n = 0; n < Mod.currentTNHInstance.activeSupplyPointIndices.Count; n++)
					{
						TNH_SupplyPoint val10 = Mod.currentTNHInstance.manager.SupplyPoints[Mod.currentTNHInstance.activeSupplyPointIndices[n]];
						int num2 = n;
						if (n > 0)
						{
							num2 = num;
							num++;
							if (num > 2)
							{
								num = 1;
							}
						}
						SupplyPanelType val11 = (SupplyPanelType)num2;
						val10.Configure(curLevel2.SupplyChallenge, false, false, true, val11, 0, 0, flag);
						flag = false;
						TAH_ReticleContact contact4 = Mod.currentTNHInstance.manager.TAHReticle.RegisterTrackedObject(val10.SpawnPoint_PlayerSpawn, (ContactType)3);
						val10.SetContact(contact4);
					}
				}
				if (Mod.currentTNHInstance.activeSupplyPointIndices != null && Mod.currentTNHInstance.activeSupplyPointIndices.Contains(Mod.currentTNHInstance.manager.m_curPointSequence.StartSupplyPointIndex))
				{
					bool flag2 = false;
					if (Mod.currentTNHInstance.currentlyPlaying != null && Mod.currentTNHInstance.currentlyPlaying.Count > 0)
					{
						for (int num3 = 0; num3 < Mod.currentTNHInstance.currentlyPlaying.Count; num3++)
						{
							if (Mod.currentTNHInstance.currentlyPlaying[num3] != GameManager.ID)
							{
								Mod.TNHSpawnPoint = ((Component)GameManager.players[Mod.currentTNHInstance.currentlyPlaying[num3]]).transform.position;
								GM.CurrentMovementManager.TeleportToPoint(Mod.TNHSpawnPoint, true);
								Mod.LogInfo("\t\tSpawning on player " + num3, debug: false);
								flag2 = true;
								break;
							}
						}
					}
					if (!flag2)
					{
						for (int num4 = 0; num4 < Mod.currentTNHInstance.manager.SupplyPoints.Count; num4++)
						{
							if (!Mod.currentTNHInstance.activeSupplyPointIndices.Contains(num4))
							{
								Mod.TNHSpawnPoint = Mod.currentTNHInstance.manager.SupplyPoints[num4].SpawnPoint_PlayerSpawn.position;
								GM.CurrentMovementManager.TeleportToPoint(Mod.TNHSpawnPoint, true);
								Mod.LogInfo("\t\tSpawning on inactive supply point: " + num4, debug: false);
								flag2 = true;
								break;
							}
						}
					}
					if (!flag2)
					{
						Mod.TNHSpawnPoint = ((Component)GM.CurrentPlayerBody).transform.position;
						Mod.LogWarning("Not valid supply point or player to spawn on, spawning on default start point, which might be active");
					}
				}
			}
			if (!Mod.currentTNHInstance.spawnedStartEquip && (Object)(object)Mod.TNHStartEquipButton == (Object)null && ((int)Mod.currentTNHInstance.manager.GameMode == 0 || (int)Mod.currentTNHInstance.manager.GameMode == 2 || (int)Mod.currentTNHInstance.manager.GameMode == 1))
			{
				Mod.LogInfo("\tSpawning init start button", debug: false);
				Mod.TNHStartEquipButton = Object.Instantiate<GameObject>(Mod.TNHStartEquipButtonPrefab, GM.CurrentPlayerBody.Head);
				((UnityEvent)((Component)Mod.TNHStartEquipButton.transform.GetChild(0)).GetComponent<FVRPointableButton>().Button.onClick).AddListener(new UnityAction(Mod.OnTNHSpawnStartEquipClicked));
			}
		}

		private static bool InitBeginEquipPrefix()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.currentlyPlaying.Count > 1)
			{
				if (!Mod.currentTNHInstance.spawnedStartEquip && (Object)(object)Mod.TNHStartEquipButton == (Object)null)
				{
					Mod.LogInfo("InitBeginEquipPrefix Spawning init start button", debug: false);
					Mod.TNHStartEquipButton = Object.Instantiate<GameObject>(Mod.TNHStartEquipButtonPrefab, GM.CurrentPlayerBody.Head);
					((UnityEvent)((Component)Mod.TNHStartEquipButton.transform.GetChild(0)).GetComponent<FVRPointableButton>().Button.onClick).AddListener(new UnityAction(Mod.OnTNHSpawnStartEquipClicked));
				}
				return false;
			}
			return true;
		}

		private static void GenerateSentryPatrolPrefix(List<Vector3> PatrolPoints)
		{
			inGenerateSentryPatrol = true;
			patrolIndex++;
			patrolPoints = PatrolPoints;
		}

		private static void GenerateSentryPatrolPostfix()
		{
			inGenerateSentryPatrol = false;
		}

		private static void GeneratePatrolPrefix()
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null))
			{
				return;
			}
			inGeneratePatrol = true;
			patrolIndex++;
			List<int> list = new List<int>();
			int num = 0;
			int num2 = 0;
			while (num < 5)
			{
				int item = Random.Range(0, GM.TNH_Manager.HoldPoints.Count);
				if (!list.Contains(item))
				{
					list.Add(item);
					num++;
				}
				num2++;
				if (num2 > 200)
				{
					break;
				}
			}
			patrolPoints = new List<Vector3>();
			for (int i = 0; i < list.Count; i++)
			{
				patrolPoints.Add(GM.TNH_Manager.HoldPoints[list[i]].SpawnPoints_Sosigs_Defense[Random.Range(0, GM.TNH_Manager.HoldPoints[list[i]].SpawnPoints_Sosigs_Defense.Count)].position);
			}
		}

		private static void GeneratePatrolPostfix()
		{
			inGeneratePatrol = false;
		}

		private static void SpawnEnemySosigPrefix()
		{
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				Mod.LogWarning("Manager spawned enemy sosig: " + Environment.StackTrace);
			}
		}

		private static bool ObjectCleanupInHoldPrefix(TNH_Manager __instance)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Invalid comparison between Unknown and I4
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			if (__instance.m_knownObjs.Count <= 0)
			{
				return false;
			}
			__instance.knownObjectCheckIndex++;
			if (__instance.knownObjectCheckIndex >= __instance.m_knownObjs.Count)
			{
				__instance.knownObjectCheckIndex = 0;
			}
			if ((Object)(object)__instance.m_knownObjs[__instance.knownObjectCheckIndex] == (Object)null)
			{
				__instance.m_knownObjsHash.Remove(__instance.m_knownObjs[__instance.knownObjectCheckIndex]);
				__instance.m_knownObjs.RemoveAt(__instance.knownObjectCheckIndex);
			}
			else
			{
				FVRPhysicalObject val = __instance.m_knownObjs[__instance.knownObjectCheckIndex];
				Vector3 position = ((Component)val).transform.position;
				if (!__instance.m_curHoldPoint.IsPointInBounds(position))
				{
					float num = Vector3.Distance(position, ((Component)GM.CurrentPlayerBody).transform.position);
					if (num > 10f)
					{
						if (val is PinnedGrenade || !((Component)val).gameObject.activeSelf || val is FVRGrenade || val.IsKinematicLocked || val.IsPivotLocked || val is FVRCappedGrenade || val is Camcorder || val is SLAM || val is FVRPivotLocker || (val is SosigWeaponPlayerInterface && (int)((SosigWeaponPlayerInterface)((val is SosigWeaponPlayerInterface) ? val : null)).W.Type == 2))
						{
							return false;
						}
						TrackedItem trackedItem = (GameManager.trackedItemByItem.TryGetValue(val, out trackedItem) ? trackedItem : ((Component)val).GetComponent<TrackedItem>());
						if ((Object)(object)trackedItem != (Object)null && trackedItem.data.controller != GameManager.ID && (!GameManager.players.TryGetValue(trackedItem.data.controller, out var value) || Vector3.Distance(position, value.head.position) <= 10f))
						{
							return false;
						}
						__instance.m_knownObjsHash.Remove(__instance.m_knownObjs[__instance.knownObjectCheckIndex]);
						Object.Destroy((Object)(object)((Component)__instance.m_knownObjs[__instance.knownObjectCheckIndex]).gameObject);
						__instance.m_knownObjs.RemoveAt(__instance.knownObjectCheckIndex);
					}
				}
			}
			return false;
		}
	}
	public class TNH_HoldPointPatch
	{
		public static bool spawnEntitiesSkip;

		public static int beginHoldSendSkip;

		public static int beginPhaseSkip;

		public static bool inSpawnEnemyGroup;

		public static bool inSpawnTurrets;

		private static bool UpdatePrefix(ref TNH_HoldPoint __instance, bool ___m_isInHold, ref TNH_HoldPointSystemNode ___m_systemNode, ref bool ___m_hasPlayedTimeWarning1, ref bool ___m_hasPlayedTimeWarning2, ref int ___m_numWarnings)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected I4, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			if ((Object)(object)Mod.managerObject != (Object)null && ___m_isInHold && Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				try
				{
					HoldState holdState = Mod.currentTNHInstance.holdState;
					HoldState val = holdState;
					switch ((int)val)
					{
					case 0:
						___m_systemNode.SetDisplayString("SCANNING SYSTEM");
						break;
					case 1:
						Mod.currentTNHInstance.tickDownToID -= Time.deltaTime;
						if ((int)__instance.M.TargetMode == 2)
						{
							___m_systemNode.SetDisplayString("ANALYZING " + __instance.FloatToTime(Mod.currentTNHInstance.tickDownToID, "0:00.00"));
						}
						else
						{
							___m_systemNode.SetDisplayString("ANALYZING");
						}
						break;
					case 2:
						Mod.currentTNHInstance.tickDownToFailure -= Time.deltaTime;
						if (!___m_hasPlayedTimeWarning1 && Mod.currentTNHInstance.tickDownToFailure < 60f)
						{
							___m_hasPlayedTimeWarning1 = true;
							__instance.M.EnqueueLine((TNH_VoiceLineID)60);
						}
						if (!___m_hasPlayedTimeWarning2 && Mod.currentTNHInstance.tickDownToFailure < 30f)
						{
							___m_hasPlayedTimeWarning2 = true;
							__instance.M.EnqueueLine((TNH_VoiceLineID)61);
							___m_numWarnings++;
						}
						___m_systemNode.SetDisplayString("FAILURE IN: " + __instance.FloatToTime(Mod.currentTNHInstance.tickDownToFailure, "0:00.00"));
						break;
					case 3:
						if ((Object)(object)___m_systemNode != (Object)null)
						{
							___m_systemNode.SetDisplayString("SCANNING SYSTEM");
						}
						break;
					}
				}
				catch (Exception ex)
				{
					Mod.LogError("Caught " + ex.Message + "\nIn Holdpoint patch update prefix\nDebug:");
					Mod.LogError("Hold state: " + ((object)Unsafe.As<HoldState, HoldState>(ref Mod.currentTNHInstance.holdState)/*cast due to .constrained prefix*/).ToString());
					Mod.LogError("Instance M null?: " + ((Object)(object)__instance.M == (Object)null));
					Mod.LogError("Sys node null?: " + ((Object)(object)___m_systemNode == (Object)null));
				}
				return false;
			}
			return true;
		}

		private static void ConfigureAsSystemNodePrefix(ref TNH_HoldPoint __instance)
		{
			if (!((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			if ((TNH_ManagerPatch.inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !TNH_ManagerPatch.inDelayedInit))
			{
				Mod.LogInfo("ConfigureAsSystemNodePrefix and we init or control, setting and sending", debug: false);
				int num = -1;
				for (int i = 0; i < __instance.M.HoldPoints.Count; i++)
				{
					if ((Object)(object)__instance.M.HoldPoints[i] == (Object)(object)__instance)
					{
						num = i;
						break;
					}
				}
				Mod.currentTNHInstance.curHoldIndex = num;
				Mod.currentTNHInstance.level = GM.TNH_Manager.m_level;
				if (ThreadManager.host)
				{
					ServerSend.TNHHoldPointSystemNode(Mod.currentTNHInstance.instance, Mod.currentTNHInstance.level, num);
				}
				else
				{
					ClientSend.TNHHoldPointSystemNode(Mod.currentTNHInstance.instance, Mod.currentTNHInstance.level, num);
				}
			}
			else
			{
				Mod.LogInfo("ConfigureAsSystemNodePrefix and we DO NOT init or control, skipping next entities spawn", debug: false);
				spawnEntitiesSkip = true;
			}
		}

		private static bool SpawnTakeChallengeEntitiesPrefix()
		{
			if (spawnEntitiesSkip)
			{
				Mod.LogInfo("SpawnTakeChallengeEntitiesPrefix skipped", debug: false);
				spawnEntitiesSkip = false;
				return false;
			}
			Mod.LogInfo("SpawnTakeChallengeEntitiesPrefix not being skipped", debug: false);
			return true;
		}

		private static bool BeginHoldPrefix(TNH_HoldPoint __instance, List<Sosig> ___m_activeSosigs, List<AutoMeater> ___m_activeTurrets, List<TNH_EncryptionTarget> ___m_activeTargets, ref int ___m_phaseIndex, ref int ___m_maxPhases, ref bool ___m_isInHold, ref int ___m_numWarnings)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				Mod.LogInfo("BeginHoldPrefix", debug: false);
				Mod.currentTNHInstance.holdOngoing = true;
				Mod.currentTNHInstance.holdState = (HoldState)0;
				if (Mod.currentTNHInstance.controller != GameManager.ID)
				{
					Mod.LogInfo("\tWe are not controller", debug: false);
					if (beginHoldSendSkip == 0)
					{
						Mod.LogInfo("\t\tNot skipped, sending to controller: " + Mod.currentTNHInstance.controller, debug: false);
						if (ThreadManager.host)
						{
							ServerSend.TNHHoldBeginChallenge(Mod.currentTNHInstance.instance, controller: false, toAll: false, Mod.currentTNHInstance.controller);
						}
						else
						{
							ClientSend.TNHHoldBeginChallenge(Mod.currentTNHInstance.instance, controller: false);
						}
					}
					else
					{
						Mod.LogInfo("\t\tSkipped, prepping", debug: false);
						if (Mod.currentTNHInstance.manager.ShouldGetGuardBonus())
						{
							float num = Mathf.Clamp(Mod.currentTNHInstance.manager.GetGuardKillTimeDelta(), 5f, 25f);
							int num2 = Mathf.Clamp(20 - (Mathf.RoundToInt(num) - 5), 0, 20);
							Mod.currentTNHInstance.manager.IncrementScoringStat((ScoringEvent)14, 1);
						}
						int num3 = Mathf.RoundToInt(Mathf.Clamp(100f - 100f * Mod.currentTNHInstance.manager.PlayerTakenDamagePercentageThisPhase(), 0f, 100f));
						Mod.currentTNHInstance.manager.IncrementScoringStat((ScoringEvent)11, num3);
						___m_activeSosigs.Clear();
						Mod.currentTNHInstance.manager.m_miscEnemies.Clear();
						Mod.currentTNHInstance.manager.ClearGuards();
						Mod.currentTNHInstance.manager.ResetAlertedThisPhase();
						Mod.currentTNHInstance.manager.ResetPlayerTookDamageThisPhase();
						Mod.currentTNHInstance.manager.ResetGuardKillTimes();
						___m_activeTargets.Clear();
						__instance.DeleteAllActiveWarpIns();
						__instance.DeleteBarriers();
						___m_activeTurrets.Clear();
						__instance.NavBlockers.SetActive(true);
						___m_phaseIndex = 0;
						___m_maxPhases = __instance.H.Phases.Count;
						__instance.M.EnqueueLine((TNH_VoiceLineID)500);
						__instance.M.EnqueueLine((TNH_VoiceLineID)1);
						__instance.M.EnqueueLine((TNH_VoiceLineID)501);
						___m_isInHold = true;
						___m_numWarnings = 0;
					}
					return false;
				}
				Mod.LogInfo("\tWe are controller", debug: false);
				if (beginHoldSendSkip == 0)
				{
					Mod.LogInfo("\t\tNot skipped sending", debug: false);
					if (ThreadManager.host)
					{
						ServerSend.TNHHoldBeginChallenge(Mod.currentTNHInstance.instance, controller: true, toAll: true, 0);
					}
					else
					{
						ClientSend.TNHHoldBeginChallenge(Mod.currentTNHInstance.instance, controller: true);
					}
				}
			}
			return true;
		}

		private static void BeginPhasePostfix()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("BeginPhasePostfix and we control, sending", debug: false);
				Mod.currentTNHInstance.holdState = (HoldState)0;
				if (ThreadManager.host)
				{
					ServerSend.TNHHoldPointBeginPhase(Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.TNHHoldPointBeginPhase(Mod.currentTNHInstance.instance);
				}
			}
		}

		private static bool RaiseRandomBarriersPrefix(int howMany)
		{
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				Mod.LogInfo("RaiseRandomBarriersPrefix", debug: false);
				if (Mod.currentTNHInstance.controller == GameManager.ID)
				{
					Mod.LogInfo("\tWe are controller, raising manually", debug: false);
					List<int> list = new List<int>();
					for (int i = 0; i < Mod.currentTNHInstance.manager.m_curHoldPoint.BarrierPoints.Count; i++)
					{
						list.Add(i);
					}
					IListExtensions.Shuffle<int>((IList<int>)list);
					Mod.currentTNHInstance.raisedBarriers = new List<int>();
					Mod.currentTNHInstance.raisedBarrierPrefabIndices = new List<int>();
					for (int j = 0; j < howMany; j++)
					{
						if (list.Count <= 0)
						{
							break;
						}
						int index = Random.Range(0, list.Count);
						int num = list[index];
						list.RemoveAt(index);
						Mod.currentTNHInstance.manager.m_curHoldPoint.BarrierPoints[num].SpawnRandomBarrier();
						Mod.currentTNHInstance.raisedBarriers.Add(num);
					}
				}
				else
				{
					Mod.LogInfo("\tWe are not controller, raising from data", debug: false);
					for (int k = 0; k < Mod.currentTNHInstance.raisedBarriers.Count; k++)
					{
						TNH_DestructibleBarrierPoint val = Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].BarrierPoints[Mod.currentTNHInstance.raisedBarriers[k]];
						BarrierDataSet val2 = val.BarrierDataSets[Mod.currentTNHInstance.raisedBarrierPrefabIndices[k]];
						GameObject val3 = Object.Instantiate<GameObject>(val2.BarrierPrefab, ((Component)val).transform.position, ((Component)val).transform.rotation);
						TNH_DestructibleBarrier val4 = (val.m_curBarrier = val3.GetComponent<TNH_DestructibleBarrier>());
						val4.InitToPlace(((Component)val).transform.position, ((Component)val).transform.forward);
						val4.SetBarrierPoint(val);
						val.SetCoverPointData(Mod.currentTNHInstance.raisedBarrierPrefabIndices[k]);
					}
				}
				return false;
			}
			return true;
		}

		private static void RaiseRandomBarriersPostfix()
		{
			if (!((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			Mod.LogInfo("RaiseRandomBarriersPostfix", debug: false);
			if (Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("\tWe are controller, sending", debug: false);
				if (ThreadManager.host)
				{
					ServerSend.TNHHoldPointRaiseBarriers(0, Mod.currentTNHInstance.instance, Mod.currentTNHInstance.raisedBarriers, Mod.currentTNHInstance.raisedBarrierPrefabIndices);
				}
				else
				{
					ClientSend.TNHHoldPointRaiseBarriers(Mod.currentTNHInstance.instance, Mod.currentTNHInstance.raisedBarriers, Mod.currentTNHInstance.raisedBarrierPrefabIndices);
				}
			}
		}

		private static void BarrierSetCoverPointDataPrefix(int index)
		{
			if (index == -1 || !((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			Mod.LogInfo("BarrierSetCoverPointDataPrefix", debug: false);
			if (Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("\tWe are controller, collecting index", debug: false);
				if (Mod.currentTNHInstance.raisedBarrierPrefabIndices == null)
				{
					Mod.currentTNHInstance.raisedBarrierPrefabIndices = new List<int>();
				}
				Mod.currentTNHInstance.raisedBarrierPrefabIndices.Add(index);
			}
		}

		private static void BeginAnalyzingPostfix(ref TNH_HoldPoint __instance, ref List<GameObject> ___m_warpInTargets, float ___m_tickDownToIdentification)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			Mod.LogInfo("BeginAnalyzingPostfix", debug: false);
			if (Mod.currentTNHInstance.controller != GameManager.ID)
			{
				return;
			}
			Mod.LogInfo("\tWe are controller, sending", debug: false);
			Mod.currentTNHInstance.holdState = (HoldState)1;
			Mod.currentTNHInstance.warpInData = new List<Vector3>();
			foreach (GameObject ___m_warpInTarget in ___m_warpInTargets)
			{
				if ((Object)(object)___m_warpInTarget != (Object)null)
				{
					Mod.currentTNHInstance.warpInData.Add(___m_warpInTarget.transform.position);
					List<Vector3> warpInData = Mod.currentTNHInstance.warpInData;
					Quaternion rotation = ___m_warpInTarget.transform.rotation;
					warpInData.Add(((Quaternion)(ref rotation)).eulerAngles);
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.TNHHoldPointBeginAnalyzing(0, Mod.currentTNHInstance.instance, Mod.currentTNHInstance.warpInData, ___m_tickDownToIdentification);
			}
			else
			{
				ClientSend.TNHHoldPointBeginAnalyzing(Mod.currentTNHInstance.instance, Mod.currentTNHInstance.warpInData, ___m_tickDownToIdentification);
			}
		}

		private static bool CompletePhasePrefix(TNH_HoldPoint __instance, List<Sosig> ___m_activeSosigs, TNH_HoldPointSystemNode ___m_systemNode, ref int ___m_phaseIndex, ref HoldState ___m_state, ref float ___m_tickDownTransition)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null)
			{
				Mod.LogInfo("CompletePhasePrefix", debug: false);
				Mod.currentTNHInstance.holdState = (HoldState)3;
				if (Mod.currentTNHInstance.controller != GameManager.ID)
				{
					Mod.LogInfo("\tWe are not controller, using data", debug: false);
					___m_activeSosigs.Clear();
					Mod.currentTNHInstance.manager.m_miscEnemies.Clear();
					SM.PlayCoreSound((FVRPooledAudioType)11, __instance.AUDEvent_HoldWave, ((Component)__instance).transform.position);
					Object.Instantiate<GameObject>(__instance.VFX_HoldWave, ___m_systemNode.NodeCenter.position, ___m_systemNode.NodeCenter.rotation);
					Mod.currentTNHInstance.manager.EnqueueLine((TNH_VoiceLineID)50);
					Mod.currentTNHInstance.manager.IncrementScoringStat((ScoringEvent)1, (int)(__instance.m_tickDownToFailure * 10f));
					___m_phaseIndex++;
					___m_state = (HoldState)3;
					___m_tickDownTransition = 5f;
					__instance.LowerAllBarriers();
					___m_systemNode.SetNodeMode((SystemNodeMode)1);
					return false;
				}
				Mod.LogInfo("\tWe are controller, sending", debug: false);
				if (ThreadManager.host)
				{
					ServerSend.TNHHoldCompletePhase(Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.TNHHoldCompletePhase(Mod.currentTNHInstance.instance);
				}
			}
			return true;
		}

		private static bool SpawnTargetGroupPrefix()
		{
			return (Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null || Mod.currentTNHInstance.controller == GameManager.ID;
		}

		private static void IdentifyEncryptionPostfix(TNH_HoldPoint __instance)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			Mod.LogInfo("IdentifyEncryptionPostfix", debug: false);
			Mod.currentTNHInstance.holdState = (HoldState)2;
			if (Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("\tWe are controller, sending", debug: false);
				if (ThreadManager.host)
				{
					ServerSend.TNHHoldIdentifyEncryption(0, Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.TNHHoldIdentifyEncryption(Mod.currentTNHInstance.instance);
				}
			}
			else
			{
				Mod.LogInfo("\tWe are not controller, deleting warp ins", debug: false);
				__instance.DeleteAllActiveWarpIns();
			}
		}

		private static bool SpawnWarpInMarkersPrefix()
		{
			return (Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null || Mod.currentTNHInstance.controller == GameManager.ID;
		}

		private static void FailOutPrefix()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			Mod.LogInfo("FailOutPrefix", debug: false);
			Mod.currentTNHInstance.holdOngoing = false;
			Mod.currentTNHInstance.holdState = (HoldState)0;
			if (Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("\tWe are controller, sending", debug: false);
				if (ThreadManager.host)
				{
					ServerSend.TNHHoldPointFailOut(Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.TNHHoldPointFailOut(Mod.currentTNHInstance.instance);
				}
			}
		}

		private static bool ShutDownHoldPointPrefix(TNH_HoldPoint __instance, List<Sosig> ___m_activeSosigs, List<AutoMeater> ___m_activeTurrets, List<TNH_EncryptionTarget> ___m_activeTargets, ref HoldState ___m_state, ref int ___m_phaseIndex, ref int ___m_maxPhases, ref bool ___m_isInHold, ref Phase ___m_curPhase, List<GameObject> ___m_warpInTargets)
		{
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				Mod.LogInfo("ShutDownHoldPointPrefix and not controller, shutting down", debug: false);
				___m_isInHold = false;
				___m_state = (HoldState)0;
				__instance.NavBlockers.SetActive(false);
				___m_phaseIndex = 0;
				___m_maxPhases = 0;
				___m_curPhase = null;
				__instance.DeleteSystemNode();
				___m_activeTargets.Clear();
				__instance.DeleteAllActiveWarpIns();
				___m_warpInTargets.Clear();
				___m_activeSosigs.Clear();
				___m_activeTurrets.Clear();
				__instance.LowerAllBarriers();
				__instance.ClearLights();
				return false;
			}
			return true;
		}

		private static void CompleteHoldPrefix()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Mod.managerObject != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			Mod.LogInfo("CompleteHoldPrefix", debug: false);
			Mod.currentTNHInstance.holdOngoing = false;
			Mod.currentTNHInstance.holdState = (HoldState)0;
			if (Mod.currentTNHInstance.controller == GameManager.ID)
			{
				Mod.LogInfo("\tWe are controller, sending", debug: false);
				if (ThreadManager.host)
				{
					ServerSend.TNHHoldPointCompleteHold(Mod.currentTNHInstance.instance);
				}
				else
				{
					ClientSend.TNHHoldPointCompleteHold(Mod.currentTNHInstance.instance);
				}
			}
			else
			{
				Mod.LogInfo("\tWe are not controller, skipping token gain", debug: false);
				TNH_ManagerPatch.completeTokenSkip++;
			}
		}

		private static void CompleteHoldPostfix()
		{
			if ((Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				TNH_ManagerPatch.completeTokenSkip--;
			}
		}

		private static bool SpawnHoldEnemyGroupPrefix()
		{
			inSpawnEnemyGroup = true;
			return !H3MPWristMenuSection.disabledHoldSosigs;
		}

		private static void SpawnEnemyGroupPrefix()
		{
			inSpawnEnemyGroup = true;
		}

		private static void SpawnEnemyGroupPostfix()
		{
			inSpawnEnemyGroup = false;
		}

		private static void SpawnTurretsPrefix()
		{
			inSpawnTurrets = true;
		}

		private static void SpawnTurretsPostfix()
		{
			inSpawnTurrets = false;
		}

		private static bool DeletionBurstPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			return Mod.currentTNHInstance == null || Mod.currentTNHInstance.controller == GameManager.ID;
		}

		private static bool DeleteAllActiveEntitiesPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			return Mod.currentTNHInstance == null || Mod.currentTNHInstance.controller == GameManager.ID;
		}

		private static bool DeleteAllActiveTargetsPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			return Mod.currentTNHInstance == null || Mod.currentTNHInstance.controller == GameManager.ID;
		}

		private static bool DeleteSosigsPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			return Mod.currentTNHInstance == null || Mod.currentTNHInstance.controller == GameManager.ID;
		}

		private static bool DeleteTurretsPrefix()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			return Mod.currentTNHInstance == null || Mod.currentTNHInstance.controller == GameManager.ID;
		}

		private static void SpawnSystemNodePrefix()
		{
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				Mod.LogWarning("SpawnSystemNodePrefix called: " + Environment.StackTrace);
			}
		}
	}
	internal class TNH_SupplyPointPatch
	{
		public static bool inSpawnTakeEnemyGroup;

		public static bool inSpawnDefenses;

		public static bool inSpawnBoxes;

		public static int supplyPointIndex;

		public static TNH_SupplyPoint supplyPointInstance;

		private static bool SpawnTakeEnemyGroupPrefix(TNH_SupplyPoint __instance)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(((object)__instance).GetType(), "$this");
			supplyPointInstance = (TNH_SupplyPoint)fieldInfo.GetValue(__instance);
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null)
			{
				return true;
			}
			if ((TNH_ManagerPatch.inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !TNH_ManagerPatch.inDelayedInit))
			{
				Mod.LogInfo("SpawnTakeEnemyGroupPrefix and we init or control, trying to find supply point " + (((Object)(object)supplyPointInstance == (Object)null) ? "null" : ((Object)supplyPointInstance).name), debug: false);
				inSpawnTakeEnemyGroup = true;
				supplyPointIndex = -1;
				for (int i = 0; i < GM.TNH_Manager.SupplyPoints.Count; i++)
				{
					Mod.LogInfo("\t Checking supply point " + (((Object)(object)GM.TNH_Manager.SupplyPoints[i] == (Object)null) ? "null" : ((Object)GM.TNH_Manager.SupplyPoints[i]).name), debug: false);
					if ((Object)(object)supplyPointInstance == (Object)(object)GM.TNH_Manager.SupplyPoints[i])
					{
						supplyPointIndex = i;
						break;
					}
				}
				return true;
			}
			return false;
		}

		private static void SpawnTakeEnemyGroupPostfix()
		{
			Mod.LogInfo("SpawnTakeEnemyGroupPostfix", debug: false);
			supplyPointInstance = null;
			inSpawnTakeEnemyGroup = false;
		}

		private static bool SpawnDefensesPrefix(TNH_SupplyPoint __instance)
		{
			supplyPointInstance = __instance;
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null)
			{
				return true;
			}
			if ((TNH_ManagerPatch.inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !TNH_ManagerPatch.inDelayedInit))
			{
				Mod.LogInfo("SpawnDefensesPrefix and we init or control", debug: false);
				inSpawnDefenses = true;
				supplyPointIndex = -1;
				for (int i = 0; i < GM.TNH_Manager.SupplyPoints.Count; i++)
				{
					if ((Object)(object)__instance == (Object)(object)GM.TNH_Manager.SupplyPoints[i])
					{
						supplyPointIndex = i;
						break;
					}
				}
				return true;
			}
			return false;
		}

		private static void SpawnDefensesPostfix()
		{
			supplyPointInstance = null;
			inSpawnDefenses = false;
		}

		private static bool SpawnBoxesPrefix(TNH_SupplyPoint __instance)
		{
			supplyPointInstance = __instance;
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null)
			{
				return true;
			}
			if ((TNH_ManagerPatch.inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !TNH_ManagerPatch.inDelayedInit))
			{
				Mod.LogInfo("SpawnBoxesPrefix and we init or control", debug: false);
				inSpawnBoxes = true;
				supplyPointIndex = -1;
				for (int i = 0; i < GM.TNH_Manager.SupplyPoints.Count; i++)
				{
					if ((Object)(object)__instance == (Object)(object)GM.TNH_Manager.SupplyPoints[i])
					{
						supplyPointIndex = i;
						break;
					}
				}
				return true;
			}
			return false;
		}

		private static void SpawnBoxesPostfix(TNH_SupplyPoint __instance)
		{
			supplyPointInstance = null;
			inSpawnBoxes = false;
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null || !__instance.M.UsesUberShatterableCrates)
			{
				return;
			}
			for (int i = 0; i < __instance.m_spawnBoxes.Count; i++)
			{
				UberShatterable component = __instance.m_spawnBoxes[i].GetComponent<UberShatterable>();
				if (!((Object)(object)component != (Object)null))
				{
					continue;
				}
				for (int j = 0; j < component.SpawnOnShatter.Count; j++)
				{
					if ((Object)(object)component.SpawnOnShatter[j] == (Object)(object)__instance.M.ResourceLib.Prefab_Token)
					{
						TrackedItem component2 = __instance.m_spawnBoxes[i].GetComponent<TrackedItem>();
						if ((Object)(object)component2 != (Object)null)
						{
							component2.itemData.additionalData[38] = 1;
							byte value;
							if (ThreadManager.host)
							{
								ServerSend.ShatterableCrateSetHoldingToken(component2.data.trackedID);
							}
							else if (component2.data.trackedID != -1)
							{
								ClientSend.ShatterableCrateSetHoldingToken(component2.data.trackedID);
							}
							else if (TrackedItem.unknownCrateHolding.TryGetValue(component2.data.localWaitingIndex, out value) && value == 0)
							{
								TrackedItem.unknownCrateHolding[component2.data.localWaitingIndex] = 2;
							}
							else
							{
								TrackedItem.unknownCrateHolding.Add(component2.data.localWaitingIndex, 1);
							}
						}
					}
					else if ((Object)(object)component.SpawnOnShatter[j] == (Object)(object)__instance.M.ResourceLib.Prefab_HealthMinor)
					{
						TrackedItem component3 = __instance.m_spawnBoxes[i].GetComponent<TrackedItem>();
						if ((Object)(object)component3 != (Object)null)
						{
							component3.itemData.additionalData[37] = 1;
							byte value2;
							if (ThreadManager.host)
							{
								ServerSend.ShatterableCrateSetHoldingHealth(component3.data.trackedID);
							}
							else if (component3.data.trackedID != -1)
							{
								ClientSend.ShatterableCrateSetHoldingHealth(component3.data.trackedID);
							}
							else if (TrackedItem.unknownCrateHolding.TryGetValue(component3.data.localWaitingIndex, out value2) && value2 == 1)
							{
								TrackedItem.unknownCrateHolding[component3.data.localWaitingIndex] = 2;
							}
							else
							{
								TrackedItem.unknownCrateHolding.Add(component3.data.localWaitingIndex, 0);
							}
						}
					}
					else
					{
						if (!component.m_usesTNHLoot)
						{
							continue;
						}
						TrackedItem component4 = __instance.m_spawnBoxes[i].GetComponent<TrackedItem>();
						if ((Object)(object)component4 != (Object)null)
						{
							component4.itemData.additionalData[39] = 1;
							byte value3;
							if (ThreadManager.host)
							{
								ServerSend.ShatterableCrateSetUsesLoot(component4.data.trackedID);
							}
							else if (component4.data.trackedID != -1)
							{
								ClientSend.ShatterableCrateSetUsesLoot(component4.data.trackedID);
							}
							else if (TrackedItem.unknownCrateHolding.TryGetValue(component4.data.localWaitingIndex, out value3) && value3 == 1)
							{
								TrackedItem.unknownCrateHolding[component4.data.localWaitingIndex] = 2;
							}
							else
							{
								TrackedItem.unknownCrateHolding.Add(component4.data.localWaitingIndex, 2);
							}
						}
					}
				}
			}
		}

		private static bool TNHTweaker_SpawnTakeEnemyGroupPrefix(TNH_SupplyPoint point)
		{
			supplyPointInstance = point;
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null)
			{
				return true;
			}
			if ((TNH_ManagerPatch.inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !TNH_ManagerPatch.inDelayedInit))
			{
				Mod.LogInfo("TNHTweaker_SpawnTakeEnemyGroupPrefix and we init or control", debug: false);
				inSpawnTakeEnemyGroup = true;
				supplyPointIndex = -1;
				for (int i = 0; i < GM.TNH_Manager.SupplyPoints.Count; i++)
				{
					if ((Object)(object)point == (Object)(object)GM.TNH_Manager.SupplyPoints[i])
					{
						supplyPointIndex = i;
						break;
					}
				}
				return true;
			}
			return false;
		}

		private static void TNHTweaker_SpawnTakeEnemyGroupPostfix()
		{
			supplyPointInstance = null;
			inSpawnTakeEnemyGroup = false;
		}

		private static bool TNHTweaker_SpawnDefensesPrefix(TNH_SupplyPoint point)
		{
			supplyPointInstance = point;
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null)
			{
				return true;
			}
			if ((TNH_ManagerPatch.inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !TNH_ManagerPatch.inDelayedInit))
			{
				Mod.LogInfo("TNHTweaker_SpawnDefensesPrefix and we init or control", debug: false);
				inSpawnDefenses = true;
				supplyPointIndex = -1;
				for (int i = 0; i < GM.TNH_Manager.SupplyPoints.Count; i++)
				{
					if ((Object)(object)point == (Object)(object)GM.TNH_Manager.SupplyPoints[i])
					{
						supplyPointIndex = i;
						break;
					}
				}
				return true;
			}
			return false;
		}

		private static void TNHTweaker_SpawnDefensesPostfix()
		{
			supplyPointInstance = null;
			inSpawnDefenses = false;
		}

		private static bool TNHTweaker_SpawnBoxesPrefix(TNH_SupplyPoint point)
		{
			supplyPointInstance = point;
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null)
			{
				return true;
			}
			if ((TNH_ManagerPatch.inDelayedInit && Mod.currentTNHInstance.initializer == GameManager.ID) || (Mod.currentTNHInstance.controller == GameManager.ID && !TNH_ManagerPatch.inDelayedInit))
			{
				Mod.LogInfo("TNHTweaker_SpawnBoxesPrefix and we init or control", debug: false);
				inSpawnBoxes = true;
				supplyPointIndex = -1;
				for (int i = 0; i < GM.TNH_Manager.SupplyPoints.Count; i++)
				{
					if ((Object)(object)point == (Object)(object)GM.TNH_Manager.SupplyPoints[i])
					{
						supplyPointIndex = i;
						break;
					}
				}
				return true;
			}
			return false;
		}

		private static void TNHTweaker_SpawnBoxesPostfix(TNH_SupplyPoint point)
		{
			supplyPointInstance = null;
			inSpawnBoxes = false;
			if ((Object)(object)Mod.managerObject == (Object)null || Mod.currentTNHInstance == null || !point.M.UsesUberShatterableCrates)
			{
				return;
			}
			for (int i = 0; i < point.m_spawnBoxes.Count; i++)
			{
				UberShatterable component = point.m_spawnBoxes[i].GetComponent<UberShatterable>();
				if (!((Object)(object)component != (Object)null))
				{
					continue;
				}
				for (int j = 0; j < component.SpawnOnShatter.Count; j++)
				{
					if ((Object)(object)component.SpawnOnShatter[j] == (Object)(object)point.M.ResourceLib.Prefab_Token)
					{
						TrackedItem component2 = point.m_spawnBoxes[i].GetComponent<TrackedItem>();
						if ((Object)(object)component2 != (Object)null)
						{
							component2.itemData.additionalData[38] = 1;
							byte value;
							if (ThreadManager.host)
							{
								ServerSend.ShatterableCrateSetHoldingToken(component2.data.trackedID);
							}
							else if (component2.data.trackedID != -1)
							{
								ClientSend.ShatterableCrateSetHoldingToken(component2.data.trackedID);
							}
							else if (TrackedItem.unknownCrateHolding.TryGetValue(component2.data.localWaitingIndex, out value) && value == 0)
							{
								TrackedItem.unknownCrateHolding[component2.data.localWaitingIndex] = 2;
							}
							else
							{
								TrackedItem.unknownCrateHolding.Add(component2.data.localWaitingIndex, 1);
							}
						}
					}
					else
					{
						if (!((Object)(object)component.SpawnOnShatter[j] == (Object)(object)point.M.ResourceLib.Prefab_HealthMinor))
						{
							continue;
						}
						TrackedItem component3 = point.m_spawnBoxes[i].GetComponent<TrackedItem>();
						if ((Object)(object)component3 != (Object)null)
						{
							component3.itemData.additionalData[37] = 1;
							byte value2;
							if (ThreadManager.host)
							{
								ServerSend.ShatterableCrateSetHoldingHealth(component3.data.trackedID);
							}
							else if (component3.data.trackedID != -1)
							{
								ClientSend.ShatterableCrateSetHoldingHealth(component3.data.trackedID);
							}
							else if (TrackedItem.unknownCrateHolding.TryGetValue(component3.data.localWaitingIndex, out value2) && value2 == 1)
							{
								TrackedItem.unknownCrateHolding[component3.data.localWaitingIndex] = 2;
							}
							else
							{
								TrackedItem.unknownCrateHolding.Add(component3.data.localWaitingIndex, 0);
							}
						}
					}
				}
			}
		}
	}
	internal class TAHReticleContactPatch
	{
		private static bool SetContactTypePrefix(ref TAH_ReticleContact __instance, ContactType t)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				return true;
			}
			int num = (int)t;
			if (num <= -2)
			{
				if (__instance.Type != t)
				{
					__instance.Type = t;
					__instance.M_Arrow.mesh = __instance.Meshes_Arrow[4];
					__instance.M_Icon.mesh = __instance.Meshes_Icon[4];
					__instance.R_Arrow.material = Mod.reticleFriendlyContactArrowMat;
					__instance.R_Icon.material = Mod.reticleFriendlyContactIconMat;
					__instance.R_Arrow.material.color = (Color)(num switch
					{
						-3 => Color.red, 
						-2 => Color.green, 
						_ => GameManager.colors[Mathf.Abs(num) - 4], 
					});
					__instance.R_Icon.material.color = (Color)(num switch
					{
						-3 => Color.red, 
						-2 => Color.green, 
						_ => GameManager.colors[Mathf.Abs(num) - 4], 
					});
				}
				return false;
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> TickTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			List<CodeInstruction> list2 = new List<CodeInstruction>();
			list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(TAH_ReticleContact), "TrackedTransform")));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Component), "get_gameObject", (Type[])null, (Type[])null)));
			list2.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GameObject), "get_activeInHierarchy", (Type[])null, (Type[])null)));
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Brfalse)
				{
					list2.Add(new CodeInstruction(OpCodes.Brtrue, val.operand));
					list2.Add(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
					list2.Add(new CodeInstruction(OpCodes.Ret, (object)null));
				}
				if (val.opcode == OpCodes.Ret)
				{
					list.InsertRange(i + 1, list2);
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Mod.LogError("TAHReticleContactPatch TickTranspiler not applied!");
			}
			return list;
		}
	}
	internal class TNHWeaponCrateSpawnObjectsPatch
	{
		private static void SpawnObjectsRawPrefix(ref TNH_WeaponCrate __instance)
		{
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				TimerDestroyer component = ((Component)__instance).GetComponent<TimerDestroyer>();
				if ((Object)(object)component != (Object)null)
				{
					component.triggered = true;
				}
			}
		}
	}
	internal class SceneLoaderPatch
	{
		private static bool LoadMGPrefix(SceneLoader __instance)
		{
			if ((Object)(object)Mod.managerObject != (Object)null && !GameManager.spectatorHost && !GameManager.sceneLoading && GameManager.scene.Equals("TakeAndHold_Lobby_2") && Mod.currentTNHInstance != null && Mod.currentTNHInstance.playerIDs.Count > 0 && GameManager.spectatorHosts.Contains(Mod.currentTNHInstance.playerIDs[0]) && !Mod.currentTNHInstance.currentlyPlaying.Contains(Mod.currentTNHInstance.playerIDs[0]))
			{
				if (ThreadManager.host)
				{
					ServerSend.SpectatorHostStartTNH(Mod.currentTNHInstance.playerIDs[0]);
				}
				else
				{
					ClientSend.SpectatorHostStartTNH(Mod.currentTNHInstance.playerIDs[0]);
				}
				((Component)__instance).gameObject.SetActive(false);
				Mod.TNHMenuPages[4].SetActive(false);
				Mod.TNHMenuPages[6].SetActive(true);
				Mod.waitingForTNHGameStart = true;
				return false;
			}
			return true;
		}
	}
}
namespace H3MP.Tracking
{
	public class TrackedAutoMeater : TrackedObject
	{
		public AutoMeater physicalAutoMeater;

		public TrackedAutoMeaterData autoMeaterData;

		public override void Awake()
		{
			base.Awake();
			GameManager.OnInstanceJoined += OnInstanceJoined;
		}

		protected override void OnDestroy()
		{
			GameManager.OnInstanceJoined -= OnInstanceJoined;
			if (!skipFullDestroy)
			{
				GameManager.trackedAutoMeaterByAutoMeater.Remove(physicalAutoMeater);
				FVRPhysicalObject[] componentsInChildren = ((Component)this).GetComponentsInChildren<FVRPhysicalObject>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)componentsInChildren[i]);
				}
				AutoMeaterHitZone[] componentsInChildren2 = ((Component)physicalAutoMeater).GetComponentsInChildren<AutoMeaterHitZone>();
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)componentsInChildren2[j]);
				}
				EnsureUncontrolled();
				base.OnDestroy();
			}
		}

		public override void EnsureUncontrolled()
		{
			if ((Object)(object)physicalAutoMeater.PO != (Object)null && (Object)(object)((FVRInteractiveObject)physicalAutoMeater.PO).m_hand != (Object)null)
			{
				((FVRInteractiveObject)physicalAutoMeater.PO).ForceBreakInteraction();
			}
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			if (data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.GiveObjectControl(data.trackedID, GameManager.ID, null);
				}
				else
				{
					ClientSend.GiveObjectControl(data.trackedID, GameManager.ID, null);
				}
				data.controller = GameManager.ID;
				data.localTrackedID = GameManager.objects.Count;
				GameManager.objects.Add(data);
			}
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.GiveObjectControl(data.trackedID, Mod.currentTNHInstance.controller, null);
				}
				else
				{
					ClientSend.GiveObjectControl(data.trackedID, Mod.currentTNHInstance.controller, null);
				}
				data.RemoveFromLocal();
			}
		}

		protected virtual void OnInstanceJoined(int instance, int source)
		{
			if (GameManager.sceneLoading)
			{
				return;
			}
			TrackedObjectData.ObjectBringType bring = TrackedObjectData.ObjectBringType.No;
			data.ShouldBring(scene: false, ref bring);
			GameManager.giveControlOfDestroyed++;
			int interactionID2;
			if (bring == TrackedObjectData.ObjectBringType.Yes)
			{
				if (data.IsControlled(out var _))
				{
					data.SetInstance(instance, send: true);
				}
				else
				{
					Object.DestroyImmediate((Object)(object)this);
					GameManager.SyncTrackedObjects(((Component)this).transform, controlEverything: true, null);
				}
			}
			else if (bring == TrackedObjectData.ObjectBringType.OnlyInteracted && data.IsControlled(out interactionID2))
			{
				data.SetInstance(instance, send: true);
			}
			else
			{
				Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
			}
			GameManager.giveControlOfDestroyed--;
		}
	}
	public class TrackedAutoMeaterData : TrackedObjectData
	{
		public TrackedAutoMeater physicalAutoMeater;

		public byte ID;

		public Vector3 previousPos;

		public Quaternion previousRot;

		public Vector3 position;

		public Quaternion rotation;

		public float previousMotorHingeSpringTarget;

		public float motorHingeSpringTarget;

		public Quaternion previousSideToSideRotation;

		public Quaternion sideToSideRotation;

		public float previousMotorUpDownTarget;

		public float motorUpDownTarget;

		public Quaternion previousUpDownMotorRotation;

		public Quaternion upDownMotorRotation;

		public byte previousIFF;

		public byte IFF;

		public byte[] data;

		public Dictionary<AMHitZoneType, AutoMeaterHitZone> hitZones = new Dictionary<AMHitZoneType, AutoMeaterHitZone>();

		public TrackedAutoMeaterData()
		{
		}

		public TrackedAutoMeaterData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			IFF = packet.ReadByte();
			motorHingeSpringTarget = packet.ReadFloat();
			sideToSideRotation = packet.ReadQuaternion();
			motorUpDownTarget = packet.ReadFloat();
			upDownMotorRotation = packet.ReadQuaternion();
			ID = packet.ReadByte();
			int num = packet.ReadInt();
			if (num > 0)
			{
				data = packet.ReadBytes(num);
			}
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<AutoMeater>() != (Object)null;
		}

		public static bool IsControlled(Transform root)
		{
			return (Object)(object)((FVRInteractiveObject)((Component)root).GetComponent<AutoMeater>().PO).m_hand != (Object)null;
		}

		public override bool IsControlled(out int interactionID)
		{
			interactionID = -1;
			if ((Object)(object)((FVRInteractiveObject)physicalAutoMeater.physicalAutoMeater.PO).m_hand != (Object)null)
			{
				if (((FVRInteractiveObject)physicalAutoMeater.physicalAutoMeater.PO).m_hand.IsThisTheRightHand)
				{
					interactionID = 2;
				}
				else
				{
					interactionID = 1;
				}
			}
			return (Object)(object)((FVRInteractiveObject)physicalAutoMeater.physicalAutoMeater.PO).m_hand != (Object)null;
		}

		public static TrackedAutoMeater MakeTracked(Transform root, TrackedObjectData parent)
		{
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			TrackedAutoMeater trackedAutoMeater = ((Component)root).gameObject.AddComponent<TrackedAutoMeater>();
			TrackedAutoMeaterData trackedAutoMeaterData = (trackedAutoMeater.autoMeaterData = (TrackedAutoMeaterData)(trackedAutoMeater.data = new TrackedAutoMeaterData()));
			trackedAutoMeaterData.physicalAutoMeater = trackedAutoMeater;
			trackedAutoMeaterData.physical = trackedAutoMeater;
			AutoMeater component = ((Component)root).GetComponent<AutoMeater>();
			trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater = component;
			trackedAutoMeaterData.physical.physical = (MonoBehaviour)(object)component;
			trackedAutoMeaterData.typeIdentifier = "TrackedAutoMeaterData";
			trackedAutoMeaterData.active = ((Component)trackedAutoMeater).gameObject.activeInHierarchy;
			trackedAutoMeaterData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedAutoMeaterData.instance = GameManager.instance;
			trackedAutoMeaterData.controller = GameManager.ID;
			trackedAutoMeaterData.initTracker = GameManager.ID;
			trackedAutoMeaterData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedAutoMeaterByAutoMeater.Add(component, trackedAutoMeater);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)component, trackedAutoMeater);
			FVRPhysicalObject[] componentsInChildren = ((Component)component).GetComponentsInChildren<FVRPhysicalObject>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)componentsInChildren[i], trackedAutoMeater);
			}
			AutoMeaterHitZone[] componentsInChildren2 = ((Component)component).GetComponentsInChildren<AutoMeaterHitZone>();
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)componentsInChildren2[j], trackedAutoMeater);
			}
			trackedAutoMeaterData.position = ((Component)component).transform.position;
			trackedAutoMeaterData.rotation = ((Component)component).transform.rotation;
			trackedAutoMeaterData.IFF = (byte)component.E.IFFCode;
			if (((Object)component).name.Contains("SMG"))
			{
				trackedAutoMeaterData.ID = 0;
			}
			else if (((Object)component).name.Contains("Flak"))
			{
				trackedAutoMeaterData.ID = 1;
			}
			else if (((Object)component).name.Contains("Flamethrower"))
			{
				trackedAutoMeaterData.ID = 2;
			}
			else if (((Object)component).name.Contains("Machinegun") || ((Object)component).name.Contains("MachineGun"))
			{
				trackedAutoMeaterData.ID = 3;
			}
			else if (((Object)component).name.Contains("Suppresion") || ((Object)component).name.Contains("Suppression"))
			{
				trackedAutoMeaterData.ID = 4;
			}
			else if (((Object)component).name.Contains("Blue"))
			{
				trackedAutoMeaterData.ID = 5;
			}
			else if (((Object)component).name.Contains("Red"))
			{
				trackedAutoMeaterData.ID = 6;
			}
			else
			{
				Mod.LogWarning("Unsupported AutoMeater type tracked");
				trackedAutoMeaterData.ID = 7;
			}
			if (component.m_hasMotor)
			{
				trackedAutoMeaterData.motorHingeSpringTarget = component.Motor.m_hingeJoint.spring.targetPosition;
				trackedAutoMeaterData.sideToSideRotation = component.Motor.m_sideToSideTransform.rotation;
				if (component.m_usesUpDownTransform)
				{
					if (component.Motor.usesUpDownHinger)
					{
						trackedAutoMeaterData.motorUpDownTarget = component.Motor.m_upDownJoint.spring.targetPosition;
					}
					trackedAutoMeaterData.upDownMotorRotation = component.Motor.m_upAndDownMotor.rotation;
				}
			}
			AutoMeaterHitZone[] componentsInChildren3 = ((Component)trackedAutoMeater).GetComponentsInChildren<AutoMeaterHitZone>();
			AutoMeaterHitZone[] array = componentsInChildren3;
			foreach (AutoMeaterHitZone val in array)
			{
				trackedAutoMeaterData.hitZones.Add(val.Type, val);
			}
			trackedAutoMeaterData.CollectExternalData();
			trackedAutoMeaterData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedAutoMeaterData);
			if (trackedAutoMeater.awoken)
			{
				trackedAutoMeater.data.Update(full: true);
			}
			return trackedAutoMeater;
		}

		private void CollectExternalData()
		{
			data = new byte[4];
			data[0] = (byte)(TNH_HoldPointPatch.inSpawnTurrets ? 1 : 1);
			data[1] = (byte)(TNH_SupplyPointPatch.inSpawnDefenses ? 1 : 1);
			BitConverter.GetBytes((short)TNH_SupplyPointPatch.supplyPointIndex).CopyTo(data, 2);
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating AutoMeater " + trackedID, debug: false);
			string itemID = AutoMeaterIDToItemID(ID);
			yield return ((AnvilAsset)IM.OD[itemID]).GetGameObjectAsync();
			GameObject autoMeaterPrefab = ((AnvilAsset)IM.OD[itemID]).GetGameObject();
			if ((Object)(object)autoMeaterPrefab == (Object)null)
			{
				Mod.LogError($"Attempted to instantiate AutoMeater sent from {base.controller} but failed to get prefab.");
				awaitingInstantiation = false;
			}
			else
			{
				if (!awaitingInstantiation)
				{
					yield break;
				}
				Mod.skipAllInstantiates++;
				if (Mod.skipAllInstantiates <= 0)
				{
					Mod.LogError("SkipAllInstantiates negative or 0 at automeater instantiation, setting to 1");
					Mod.skipAllInstantiates = 1;
				}
				GameObject autoMeaterInstance = Object.Instantiate<GameObject>(autoMeaterPrefab, position, rotation);
				Mod.skipAllInstantiates--;
				physicalAutoMeater = autoMeaterInstance.AddComponent<TrackedAutoMeater>();
				physical = physicalAutoMeater;
				physicalAutoMeater.physicalAutoMeater = autoMeaterInstance.GetComponent<AutoMeater>();
				physical.physical = (MonoBehaviour)(object)physicalAutoMeater.physicalAutoMeater;
				awaitingInstantiation = false;
				physicalAutoMeater.autoMeaterData = this;
				physical.data = this;
				GameManager.trackedAutoMeaterByAutoMeater.Add(physicalAutoMeater.physicalAutoMeater, physicalAutoMeater);
				GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalAutoMeater.physicalAutoMeater, physicalAutoMeater);
				FVRPhysicalObject[] pos = ((Component)physicalAutoMeater.physicalAutoMeater).GetComponentsInChildren<FVRPhysicalObject>();
				int i = 0;
				while (i < pos.Length)
				{
					GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)pos[i], physicalAutoMeater);
					int num = i + 1;
					i = num;
				}
				AutoMeaterHitZone[] tempHitZones = ((Component)physicalAutoMeater).GetComponentsInChildren<AutoMeaterHitZone>();
				int i2 = 0;
				while (i2 < tempHitZones.Length)
				{
					GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)tempHitZones[i2], physicalAutoMeater);
					int num = i2 + 1;
					i2 = num;
				}
				if (base.controller != GameManager.ID)
				{
					if ((Object)(object)GM.CurrentAIManager != (Object)null)
					{
						GM.CurrentAIManager.DeRegisterAIEntity(physicalAutoMeater.physicalAutoMeater.E);
					}
					Rigidbody[] rbs = ((Component)physicalAutoMeater).GetComponentsInChildren<Rigidbody>();
					int i3 = 0;
					while (i3 < rbs.Length)
					{
						rbs[i3].isKinematic = true;
						int num = i3 + 1;
						i3 = num;
					}
				}
				physicalAutoMeater.physicalAutoMeater.E.IFFCode = IFF;
				AutoMeaterHitZone[] hitZoneArr = ((Component)physicalAutoMeater).GetComponentsInChildren<AutoMeaterHitZone>();
				AutoMeaterHitZone[] array = hitZoneArr;
				foreach (AutoMeaterHitZone hitZone in array)
				{
					hitZones.Add(hitZone.Type, hitZone);
				}
				ProcessData();
				UpdateFromData(this);
			}
		}

		private void ProcessData()
		{
			if ((Object)(object)GM.TNH_Manager != (Object)null && Mod.currentTNHInstance != null)
			{
				if (data[0] == 1)
				{
					GM.TNH_Manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_activeTurrets.Add(physicalAutoMeater.physicalAutoMeater);
				}
				else if (data[1] == 1)
				{
					GM.TNH_Manager.SupplyPoints[BitConverter.ToInt16(data, 2)].m_activeTurrets.Add(physicalAutoMeater.physicalAutoMeater);
				}
			}
		}

		public static string AutoMeaterIDToItemID(byte ID)
		{
			switch (ID)
			{
			case 0:
				return "Turburgert_SMG";
			case 1:
				return "Turburgert_Flak";
			case 2:
				return "Turburgert_Flamethrower";
			case 3:
				return "Turburgert_MachineGun";
			case 4:
				return "Turburgert_Suppression";
			case 5:
				return "TurburgertMFBlue";
			case 6:
				return "TurburgertMFRed";
			default:
				Mod.LogInfo("AutoMeaterIDToItemID: Invalid auto meater ID: " + ID, debug: false);
				return "Turburgert_SMG";
			}
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedAutoMeaterData trackedAutoMeaterData = updatedObject as TrackedAutoMeaterData;
			if (full)
			{
				ID = trackedAutoMeaterData.ID;
				data = trackedAutoMeaterData.data;
			}
			previousPos = position;
			previousRot = rotation;
			position = trackedAutoMeaterData.position;
			rotation = trackedAutoMeaterData.rotation;
			previousIFF = IFF;
			IFF = trackedAutoMeaterData.IFF;
			previousMotorHingeSpringTarget = motorHingeSpringTarget;
			motorHingeSpringTarget = trackedAutoMeaterData.motorHingeSpringTarget;
			previousSideToSideRotation = sideToSideRotation;
			sideToSideRotation = trackedAutoMeaterData.sideToSideRotation;
			previousMotorUpDownTarget = motorUpDownTarget;
			motorUpDownTarget = trackedAutoMeaterData.motorUpDownTarget;
			previousUpDownMotorRotation = upDownMotorRotation;
			upDownMotorRotation = trackedAutoMeaterData.upDownMotorRotation;
			if (!((Object)(object)physicalAutoMeater != (Object)null))
			{
				return;
			}
			((Component)physicalAutoMeater.physicalAutoMeater).transform.position = position;
			((Component)physicalAutoMeater.physicalAutoMeater).transform.rotation = rotation;
			physicalAutoMeater.physicalAutoMeater.E.IFFCode = IFF;
			if (!physicalAutoMeater.physicalAutoMeater.m_hasMotor)
			{
				return;
			}
			JointSpring spring = physicalAutoMeater.physicalAutoMeater.Motor.m_hingeJoint.spring;
			spring.targetPosition = motorHingeSpringTarget;
			physicalAutoMeater.physicalAutoMeater.Motor.m_hingeJoint.spring = spring;
			physicalAutoMeater.physicalAutoMeater.Motor.m_sideToSideTransform.rotation = sideToSideRotation;
			if (physicalAutoMeater.physicalAutoMeater.m_usesUpDownTransform)
			{
				if (physicalAutoMeater.physicalAutoMeater.Motor.usesUpDownHinger)
				{
					JointSpring spring2 = physicalAutoMeater.physicalAutoMeater.Motor.m_upDownJoint.spring;
					spring2.targetPosition = motorUpDownTarget;
					physicalAutoMeater.physicalAutoMeater.Motor.m_upDownJoint.spring = spring2;
				}
				physicalAutoMeater.physicalAutoMeater.Motor.m_upAndDownMotor.rotation = upDownMotorRotation;
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			previousPos = position;
			previousRot = rotation;
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			previousIFF = IFF;
			IFF = packet.ReadByte();
			previousMotorHingeSpringTarget = motorHingeSpringTarget;
			motorHingeSpringTarget = packet.ReadFloat();
			previousSideToSideRotation = sideToSideRotation;
			sideToSideRotation = packet.ReadQuaternion();
			previousMotorUpDownTarget = motorUpDownTarget;
			motorUpDownTarget = packet.ReadFloat();
			previousUpDownMotorRotation = upDownMotorRotation;
			upDownMotorRotation = packet.ReadQuaternion();
			if (full)
			{
				ID = packet.ReadByte();
				int num = packet.ReadInt();
				if (num > 0)
				{
					data = packet.ReadBytes(num);
				}
				else
				{
					data = null;
				}
			}
			if (!((Object)(object)physicalAutoMeater != (Object)null))
			{
				return;
			}
			((Component)physicalAutoMeater.physicalAutoMeater).transform.position = position;
			((Component)physicalAutoMeater.physicalAutoMeater).transform.rotation = rotation;
			physicalAutoMeater.physicalAutoMeater.E.IFFCode = IFF;
			if (!physicalAutoMeater.physicalAutoMeater.m_hasMotor)
			{
				return;
			}
			JointSpring spring = physicalAutoMeater.physicalAutoMeater.Motor.m_hingeJoint.spring;
			spring.targetPosition = motorHingeSpringTarget;
			physicalAutoMeater.physicalAutoMeater.Motor.m_hingeJoint.spring = spring;
			physicalAutoMeater.physicalAutoMeater.Motor.m_sideToSideTransform.rotation = sideToSideRotation;
			if (physicalAutoMeater.physicalAutoMeater.m_usesUpDownTransform)
			{
				if (physicalAutoMeater.physicalAutoMeater.Motor.usesUpDownHinger)
				{
					JointSpring spring2 = physicalAutoMeater.physicalAutoMeater.Motor.m_upDownJoint.spring;
					spring2.targetPosition = motorUpDownTarget;
					physicalAutoMeater.physicalAutoMeater.Motor.m_upDownJoint.spring = spring2;
				}
				physicalAutoMeater.physicalAutoMeater.Motor.m_upAndDownMotor.rotation = upDownMotorRotation;
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			base.Update(full);
			if ((Object)(object)physicalAutoMeater == (Object)null)
			{
				return false;
			}
			previousPos = position;
			previousRot = rotation;
			position = ((Component)physicalAutoMeater.physicalAutoMeater).transform.position;
			rotation = ((Component)physicalAutoMeater.physicalAutoMeater).transform.rotation;
			previousIFF = IFF;
			IFF = (byte)physicalAutoMeater.physicalAutoMeater.E.IFFCode;
			if (physicalAutoMeater.physicalAutoMeater.m_hasMotor)
			{
				previousMotorHingeSpringTarget = motorHingeSpringTarget;
				motorHingeSpringTarget = physicalAutoMeater.physicalAutoMeater.Motor.m_hingeJoint.spring.targetPosition;
				previousSideToSideRotation = sideToSideRotation;
				sideToSideRotation = physicalAutoMeater.physicalAutoMeater.Motor.m_sideToSideTransform.rotation;
				if (physicalAutoMeater.physicalAutoMeater.m_usesUpDownTransform)
				{
					if (physicalAutoMeater.physicalAutoMeater.Motor.usesUpDownHinger)
					{
						previousMotorUpDownTarget = motorUpDownTarget;
						motorUpDownTarget = physicalAutoMeater.physicalAutoMeater.Motor.m_upDownJoint.spring.targetPosition;
					}
					previousUpDownMotorRotation = upDownMotorRotation;
					upDownMotorRotation = physicalAutoMeater.physicalAutoMeater.Motor.m_upAndDownMotor.rotation;
				}
			}
			return NeedsUpdate();
		}

		public override bool NeedsUpdate()
		{
			//IL_0013: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (!base.NeedsUpdate())
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2) && previousMotorHingeSpringTarget == motorHingeSpringTarget)
					{
						ref Quaternion reference3 = ref previousSideToSideRotation;
						object obj3 = sideToSideRotation;
						if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference3)/*cast due to .constrained prefix*/).Equals(obj3) && previousMotorUpDownTarget == motorUpDownTarget)
						{
							ref Quaternion reference4 = ref previousUpDownMotorRotation;
							object obj4 = upDownMotorRotation;
							result = ((!((object)Unsafe.As<Quaternion, Quaternion>(ref reference4)/*cast due to .constrained prefix*/).Equals(obj4)) ? 1 : 0);
							goto IL_00a4;
						}
					}
				}
			}
			result = 1;
			goto IL_00a4;
			IL_00a4:
			return (byte)result != 0;
		}

		public override void OnControlChanged(int newController)
		{
			base.OnControlChanged(newController);
			if (newController == GameManager.ID)
			{
				if ((Object)(object)physicalAutoMeater != (Object)null && (Object)(object)physicalAutoMeater.physicalAutoMeater != (Object)null)
				{
					if ((Object)(object)GM.CurrentAIManager != (Object)null)
					{
						GM.CurrentAIManager.RegisterAIEntity(physicalAutoMeater.physicalAutoMeater.E);
					}
					Rigidbody[] componentsInChildren = ((Component)physicalAutoMeater).GetComponentsInChildren<Rigidbody>();
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						componentsInChildren[i].isKinematic = false;
					}
				}
			}
			else if (base.controller == GameManager.ID && (Object)(object)physicalAutoMeater != (Object)null && (Object)(object)physicalAutoMeater.physicalAutoMeater != (Object)null)
			{
				physicalAutoMeater.EnsureUncontrolled();
				if ((Object)(object)GM.CurrentAIManager != (Object)null)
				{
					GM.CurrentAIManager.DeRegisterAIEntity(physicalAutoMeater.physicalAutoMeater.E);
				}
				Rigidbody[] componentsInChildren2 = ((Component)physicalAutoMeater).GetComponentsInChildren<Rigidbody>();
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					componentsInChildren2[j].isKinematic = true;
				}
			}
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
			packet.Write(IFF);
			packet.Write(motorHingeSpringTarget);
			packet.Write(sideToSideRotation);
			packet.Write(motorUpDownTarget);
			packet.Write(upDownMotorRotation);
			if (full)
			{
				packet.Write(ID);
				if (data == null || data.Length == 0)
				{
					packet.Write(0);
					return;
				}
				packet.Write(data.Length);
				packet.Write(data);
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalAutoMeater != (Object)null && (Object)(object)physicalAutoMeater.physicalAutoMeater != (Object)null)
			{
				GameManager.trackedAutoMeaterByAutoMeater.Remove(physicalAutoMeater.physicalAutoMeater);
				FVRPhysicalObject[] componentsInChildren = ((Component)physicalAutoMeater).GetComponentsInChildren<FVRPhysicalObject>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)componentsInChildren[i]);
				}
				AutoMeaterHitZone[] componentsInChildren2 = ((Component)physicalAutoMeater).GetComponentsInChildren<AutoMeaterHitZone>();
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)componentsInChildren2[j]);
				}
			}
		}
	}
	public class TrackedBlister : TrackedObject
	{
		public Construct_Blister physicalBlister;

		public TrackedBlisterData blisterData;

		public static List<uint> unknownBlisterShatter = new List<uint>();

		public override bool HandleShatter(UberShatterable shatterable, Vector3 point, Vector3 dir, float intensity, bool received, int clientID, byte[] data)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (received)
			{
				UberShatterableShatterPatch.skip++;
				((Component)physicalBlister).GetComponentInChildren<UberShatterable>().Shatter(point, dir, intensity);
				UberShatterableShatterPatch.skip--;
				if (ThreadManager.host)
				{
					ServerSend.UberShatterableShatter(blisterData.trackedID, point, dir, intensity, data, clientID);
				}
			}
			else if (ThreadManager.host)
			{
				ServerSend.UberShatterableShatter(blisterData.trackedID, point, dir, intensity, data);
			}
			else if (blisterData.trackedID != -1)
			{
				ClientSend.UberShatterableShatter(blisterData.trackedID, point, dir, intensity, data);
			}
			return true;
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedBlisterByBlister.Remove(physicalBlister);
				GameManager.trackedObjectByShatterable.Remove(((Component)physicalBlister).GetComponentInChildren<UberShatterable>());
				base.OnDestroy();
			}
		}
	}
	public class TrackedBlisterData : TrackedObjectData
	{
		public TrackedBlister physicalBlister;

		public Vector3 position;

		public Quaternion rotation;

		public TrackedBlisterData()
		{
		}

		public TrackedBlisterData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<Construct_Blister>() != (Object)null;
		}

		private static TrackedBlister MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedBlister trackedBlister = ((Component)root).gameObject.AddComponent<TrackedBlister>();
			TrackedBlisterData trackedBlisterData = (TrackedBlisterData)(trackedBlister.data = (trackedBlister.blisterData = new TrackedBlisterData()));
			trackedBlisterData.physicalBlister = trackedBlister;
			trackedBlisterData.physical = trackedBlister;
			Construct_Blister component = ((Component)root).GetComponent<Construct_Blister>();
			trackedBlisterData.physicalBlister.physicalBlister = component;
			trackedBlisterData.physical.physical = (MonoBehaviour)(object)component;
			trackedBlisterData.typeIdentifier = "TrackedBlisterData";
			trackedBlisterData.active = ((Component)trackedBlister).gameObject.activeInHierarchy;
			trackedBlisterData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedBlisterData.instance = GameManager.instance;
			trackedBlisterData.controller = GameManager.ID;
			trackedBlisterData.initTracker = GameManager.ID;
			trackedBlisterData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedBlisterByBlister.Add(trackedBlister.physicalBlister, trackedBlister);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedBlister.physicalBlister, trackedBlister);
			GameManager.trackedObjectByShatterable.Add(((Component)trackedBlister).GetComponentInChildren<UberShatterable>(), trackedBlister);
			trackedBlisterData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedBlisterData);
			if (trackedBlister.awoken)
			{
				trackedBlister.data.Update(full: true);
			}
			Mod.LogInfo("Made blister " + ((Object)trackedBlister).name + " tracked", debug: false);
			return trackedBlister;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			if (full)
			{
				packet.Write(position);
				packet.Write(rotation);
			}
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating blister at " + trackedID, debug: false);
			Construct_Blister_Volume blisterVolume = Object.FindObjectOfType<Construct_Blister_Volume>();
			GameObject prefab;
			if ((Object)(object)blisterVolume == (Object)null)
			{
				SosigSpawner sosigSpawner = Object.FindObjectOfType<SosigSpawner>();
				if (!((Object)(object)sosigSpawner != (Object)null))
				{
					Mod.LogError("Failed to instantiate blister: " + trackedID + ": Could not find suitable blister volume or SosigSpawner to get prefab from");
					yield break;
				}
				prefab = sosigSpawner.SpawnerGroups[19].Furnitures[1];
			}
			else
			{
				prefab = blisterVolume.Blister_Prefab;
			}
			Mod.skipAllInstantiates++;
			GameObject blisterInstance = Object.Instantiate<GameObject>(prefab, position, rotation);
			Mod.skipAllInstantiates--;
			physicalBlister = blisterInstance.AddComponent<TrackedBlister>();
			physical = physicalBlister;
			physicalBlister.physicalBlister = blisterInstance.GetComponent<Construct_Blister>();
			physical.physical = (MonoBehaviour)(object)physicalBlister.physicalBlister;
			awaitingInstantiation = false;
			physicalBlister.blisterData = this;
			physicalBlister.data = this;
			GameManager.trackedBlisterByBlister.Add(physicalBlister.physicalBlister, physicalBlister);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalBlister.physicalBlister, physicalBlister);
			GameManager.trackedObjectByShatterable.Add(((Component)physicalBlister).GetComponentInChildren<UberShatterable>(), physicalBlister);
			UpdateFromData(this, full: true);
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedBlisterData trackedBlisterData = updatedObject as TrackedBlisterData;
			if (full)
			{
				position = trackedBlisterData.position;
				rotation = trackedBlisterData.rotation;
			}
			if ((Object)(object)physicalBlister != (Object)null && full)
			{
				((Component)physicalBlister.physicalBlister).transform.position = position;
				((Component)physicalBlister.physicalBlister).transform.rotation = rotation;
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			if (full)
			{
				position = packet.ReadVector3();
				rotation = packet.ReadQuaternion();
			}
			if ((Object)(object)physicalBlister != (Object)null && full)
			{
				((Component)physicalBlister.physicalBlister).transform.position = position;
				((Component)physicalBlister.physicalBlister).transform.rotation = rotation;
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			bool result = base.Update(full);
			if ((Object)(object)physicalBlister == (Object)null)
			{
				return false;
			}
			if (full)
			{
				position = ((Component)physicalBlister.physicalBlister).transform.position;
				rotation = ((Component)physicalBlister.physicalBlister).transform.rotation;
				result = true;
			}
			return result;
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalBlister != (Object)null && (Object)(object)physicalBlister.physicalBlister != (Object)null)
			{
				GameManager.trackedBlisterByBlister.Remove(physicalBlister.physicalBlister);
				GameManager.trackedObjectByShatterable.Remove(((Component)physicalBlister).GetComponentInChildren<UberShatterable>());
			}
		}
	}
	public class TrackedBreakableGlass : TrackedObject
	{
		public BreakableGlass physicalBreakableGlass;

		public TrackedBreakableGlassData breakableGlassData;

		public override void Awake()
		{
			base.Awake();
			GameManager.OnInstanceJoined += OnInstanceJoined;
		}

		public void PlayerShatterAudio(int mode)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)breakableGlassData.damager != (Object)null)
			{
				float num = Vector3.Distance(GM.CurrentPlayerBody.Head.position, ((Component)this).transform.position) / 343f;
				FVRPooledAudioType val = (FVRPooledAudioType)((breakableGlassData.breakDepth > 0) ? 41 : 0);
				switch (mode)
				{
				case 0:
					SM.PlayCoreSoundDelayed(val, breakableGlassData.damager.AudEvent_Shatter_BlowOut, ((Component)this).transform.position, num);
					break;
				case 1:
					SM.PlayCoreSoundDelayed(val, breakableGlassData.damager.AudEvent_Head_Projectile, ((Component)this).transform.position, num);
					SM.PlayCoreSoundDelayed(val, breakableGlassData.damager.AudEvent_Tail, ((Component)this).transform.position, num);
					break;
				case 2:
					SM.PlayCoreSoundDelayed(val, breakableGlassData.damager.AudEvent_Head_Melee, ((Component)this).transform.position, num);
					SM.PlayCoreSoundDelayed(val, breakableGlassData.damager.AudEvent_Tail, ((Component)this).transform.position, num);
					break;
				}
			}
		}

		protected override void OnDestroy()
		{
			GameManager.OnInstanceJoined -= OnInstanceJoined;
			if (!skipFullDestroy)
			{
				GameManager.trackedBreakableGlassByBreakableGlass.Remove(physicalBreakableGlass);
				GameManager.trackedBreakableGlassByBreakableGlassDamager.Remove(breakableGlassData.damager);
				GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)breakableGlassData.damager);
				base.OnDestroy();
			}
		}

		protected virtual void OnInstanceJoined(int instance, int source)
		{
			if (!GameManager.sceneLoading)
			{
				TrackedObjectData.ObjectBringType bring = TrackedObjectData.ObjectBringType.No;
				data.ShouldBring(scene: false, ref bring);
				GameManager.giveControlOfDestroyed++;
				if (bring == TrackedObjectData.ObjectBringType.Yes)
				{
					Object.DestroyImmediate((Object)(object)this);
					GameManager.SyncTrackedObjects(((Component)this).transform, controlEverything: true, null);
				}
				else
				{
					Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
				}
				GameManager.giveControlOfDestroyed--;
			}
		}
	}
	public class TrackedBreakableGlassData : TrackedObjectData
	{
		public TrackedBreakableGlass physicalBreakableGlass;

		public BreakableGlassDamager damager;

		public List<Vector2> shape;

		public List<Vector2> baseShape;

		public Vector3 previousPos;

		public Vector3 position;

		public Quaternion previousRot;

		public Quaternion rotation;

		public float deletionTimer;

		public float deletionTimerStart;

		public bool tickingDownToDeletion;

		public float thickness;

		public bool isAttached;

		public int breakDepth;

		public bool hasWrapper;

		public int wrapperID = -1;

		public int localWrapperID = -1;

		public static int wrapperIDCounter = 0;

		public static Dictionary<int, DestructibleWindowWrapper> localWrappersByID = new Dictionary<int, DestructibleWindowWrapper>();

		public static Dictionary<DestructibleWindowWrapper, int> localWrapperIDsbyWrapper = new Dictionary<DestructibleWindowWrapper, int>();

		public static Dictionary<int, DestructibleWindowWrapper> wrappersByID = new Dictionary<int, DestructibleWindowWrapper>();

		public static Dictionary<DestructibleWindowWrapper, int> wrapperIDsbyWrapper = new Dictionary<DestructibleWindowWrapper, int>();

		public TrackedBreakableGlassData()
		{
		}

		public TrackedBreakableGlassData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			int num = packet.ReadByte();
			if (num > 0)
			{
				shape = new List<Vector2>();
				for (int i = 0; i < num; i++)
				{
					shape.Add(packet.ReadVector2());
				}
			}
			num = packet.ReadByte();
			if (num > 0)
			{
				baseShape = new List<Vector2>();
				for (int j = 0; j < num; j++)
				{
					baseShape.Add(packet.ReadVector2());
				}
			}
			deletionTimer = packet.ReadFloat();
			deletionTimerStart = packet.ReadFloat();
			tickingDownToDeletion = packet.ReadBool();
			thickness = packet.ReadFloat();
			isAttached = packet.ReadBool();
			breakDepth = packet.ReadInt();
			wrapperID = packet.ReadInt();
			localWrapperID = packet.ReadInt();
			hasWrapper = packet.ReadBool();
			if (ThreadManager.host && wrapperID == -1 && hasWrapper)
			{
				wrapperID = wrapperIDCounter++;
			}
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<BreakableGlass>() != (Object)null && (Object)(object)((Component)t).GetComponent<BreakableGlassDamager>() != (Object)null && (Object)(object)((Component)t).GetComponent<MeshFilter>() != (Object)null;
		}

		public static TrackedBreakableGlass MakeTracked(Transform root, TrackedObjectData parent)
		{
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			TrackedBreakableGlass trackedBreakableGlass = ((Component)root).gameObject.AddComponent<TrackedBreakableGlass>();
			TrackedBreakableGlassData trackedBreakableGlassData = (trackedBreakableGlass.breakableGlassData = (TrackedBreakableGlassData)(trackedBreakableGlass.data = new TrackedBreakableGlassData()));
			trackedBreakableGlassData.physicalBreakableGlass = trackedBreakableGlass;
			trackedBreakableGlassData.physical = trackedBreakableGlass;
			trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass = ((Component)root).GetComponent<BreakableGlass>();
			trackedBreakableGlassData.physical.physical = (MonoBehaviour)(object)trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass;
			trackedBreakableGlassData.typeIdentifier = "TrackedBreakableGlassData";
			trackedBreakableGlassData.active = ((Component)trackedBreakableGlass).gameObject.activeInHierarchy;
			trackedBreakableGlassData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedBreakableGlassData.instance = GameManager.instance;
			trackedBreakableGlassData.controller = GameManager.ID;
			trackedBreakableGlassData.initTracker = GameManager.ID;
			trackedBreakableGlassData.sceneInit = GameManager.InSceneInit();
			trackedBreakableGlassData.damager = ((Component)root).GetComponent<BreakableGlassDamager>();
			if ((Object)(object)trackedBreakableGlassData.damager.m_wrapper != (Object)null)
			{
				trackedBreakableGlassData.hasWrapper = true;
				int value3;
				if (wrapperIDsbyWrapper.TryGetValue(trackedBreakableGlassData.damager.m_wrapper, out var value))
				{
					trackedBreakableGlassData.wrapperID = value;
				}
				else if (ThreadManager.host)
				{
					if (wrapperIDsbyWrapper.TryGetValue(trackedBreakableGlassData.damager.m_wrapper, out var value2))
					{
						trackedBreakableGlassData.wrapperID = value2;
					}
					else
					{
						trackedBreakableGlassData.wrapperID = wrapperIDCounter;
						wrappersByID.Add(trackedBreakableGlassData.wrapperID, trackedBreakableGlassData.damager.m_wrapper);
						wrapperIDsbyWrapper.Add(trackedBreakableGlassData.damager.m_wrapper, trackedBreakableGlassData.wrapperID);
					}
				}
				else if (localWrapperIDsbyWrapper.TryGetValue(trackedBreakableGlassData.damager.m_wrapper, out value3))
				{
					trackedBreakableGlassData.localWrapperID = value3;
				}
				else
				{
					trackedBreakableGlassData.localWrapperID = wrapperIDCounter;
					localWrappersByID.Add(trackedBreakableGlassData.localWrapperID, trackedBreakableGlassData.damager.m_wrapper);
					localWrapperIDsbyWrapper.Add(trackedBreakableGlassData.damager.m_wrapper, trackedBreakableGlassData.localWrapperID);
				}
				wrapperIDCounter++;
			}
			else
			{
				trackedBreakableGlassData.hasWrapper = false;
			}
			GameManager.trackedBreakableGlassByBreakableGlass.Add(trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass, trackedBreakableGlass);
			GameManager.trackedBreakableGlassByBreakableGlassDamager.Add(trackedBreakableGlassData.damager, trackedBreakableGlass);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass, trackedBreakableGlass);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)trackedBreakableGlassData.damager, trackedBreakableGlass);
			List<Vector3> list = new List<Vector3>();
			((Component)root).GetComponent<MeshFilter>().mesh.GetVertices(list);
			trackedBreakableGlassData.shape = CynGlass.MeshToShape(list, trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.thickness);
			trackedBreakableGlassData.baseShape = trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.baseShape;
			trackedBreakableGlassData.position = ((Component)trackedBreakableGlass).transform.position;
			trackedBreakableGlassData.rotation = ((Component)trackedBreakableGlass).transform.rotation;
			trackedBreakableGlassData.deletionTimer = trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.m_deletionTimer;
			trackedBreakableGlassData.deletionTimerStart = trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.m_deletionTimerStart;
			trackedBreakableGlassData.tickingDownToDeletion = trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.m_tickingDownToDeletion;
			trackedBreakableGlassData.thickness = trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.thickness;
			trackedBreakableGlassData.isAttached = trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.isAttached;
			trackedBreakableGlassData.breakDepth = trackedBreakableGlassData.physicalBreakableGlass.physicalBreakableGlass.breakDepth;
			trackedBreakableGlassData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedBreakableGlassData);
			return trackedBreakableGlass;
		}

		public override IEnumerator Instantiate()
		{
			Mod.skipAllInstantiates++;
			GameObject objectInstance = Object.Instantiate<GameObject>(Mod.glassPrefab);
			((Object)objectInstance).name = "TrackedBreakableGlassInstance" + trackedID;
			Mod.skipAllInstantiates--;
			physicalBreakableGlass = objectInstance.AddComponent<TrackedBreakableGlass>();
			physical = physicalBreakableGlass;
			physicalBreakableGlass.physicalBreakableGlass = objectInstance.GetComponent<BreakableGlass>();
			physical.physical = (MonoBehaviour)(object)physicalBreakableGlass.physicalBreakableGlass;
			physicalBreakableGlass.breakableGlassData = this;
			physical.data = this;
			awaitingInstantiation = false;
			MeshFilter mf = objectInstance.GetComponent<MeshFilter>();
			Rigidbody rb = objectInstance.GetComponent<Rigidbody>();
			damager = objectInstance.GetComponent<BreakableGlassDamager>();
			MeshCollider collider = objectInstance.GetComponent<MeshCollider>();
			Mesh mesh = new Mesh();
			CynGlass.ShapeToMesh(shape, thickness, shape[0], mesh);
			mf.sharedMesh = mesh;
			((Collider)collider).enabled = true;
			collider.convex = true;
			collider.sharedMesh = mesh;
			rb.isKinematic = true;
			physicalBreakableGlass.physicalBreakableGlass.shardPrefab = Mod.glassPrefab;
			physicalBreakableGlass.physicalBreakableGlass.area = CynGlass.AreaOf(shape);
			rb.mass = Mathf.Lerp(0.05f, 0.2f, Mathf.InverseLerp(0.025f, 0.1f, physicalBreakableGlass.physicalBreakableGlass.area));
			if (hasWrapper)
			{
				if (wrappersByID.TryGetValue(wrapperID, out var currentWrapper))
				{
					damager.SetWrapper(currentWrapper);
					objectInstance.transform.parent = ((Component)currentWrapper).transform;
				}
				else
				{
					GameObject wrapperObject = new GameObject("WindowWrapper");
					wrapperObject.SetActive(false);
					DestructibleWindowWrapper newWrapper = wrapperObject.AddComponent<DestructibleWindowWrapper>();
					wrappersByID.Add(wrapperID, newWrapper);
					wrapperIDsbyWrapper.Add(newWrapper, wrapperID);
					objectInstance.transform.parent = wrapperObject.transform;
					newWrapper.GlassDamager = damager;
					wrapperObject.SetActive(true);
				}
			}
			physicalBreakableGlass.physicalBreakableGlass.shape = shape;
			physicalBreakableGlass.physicalBreakableGlass.thickness = thickness;
			physicalBreakableGlass.physicalBreakableGlass.isAttached = isAttached;
			physicalBreakableGlass.physicalBreakableGlass.breakDepth = breakDepth;
			if (breakDepth == 0)
			{
				physicalBreakableGlass.physicalBreakableGlass.baseShape = shape;
			}
			else
			{
				physicalBreakableGlass.physicalBreakableGlass.baseShape = baseShape;
			}
			physicalBreakableGlass.physicalBreakableGlass.m_deletionTimer = deletionTimer;
			physicalBreakableGlass.physicalBreakableGlass.m_deletionTimerStart = deletionTimerStart;
			physicalBreakableGlass.physicalBreakableGlass.m_tickingDownToDeletion = tickingDownToDeletion;
			GameManager.trackedBreakableGlassByBreakableGlass.Add(physicalBreakableGlass.physicalBreakableGlass, physicalBreakableGlass);
			GameManager.trackedBreakableGlassByBreakableGlassDamager.Add(damager, physicalBreakableGlass);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalBreakableGlass.physicalBreakableGlass, physicalBreakableGlass);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)damager, physicalBreakableGlass);
			UpdateFromData(this);
			yield break;
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedBreakableGlassData trackedBreakableGlassData = updatedObject as TrackedBreakableGlassData;
			if (full)
			{
				shape = trackedBreakableGlassData.shape;
				baseShape = trackedBreakableGlassData.baseShape;
				deletionTimer = trackedBreakableGlassData.deletionTimer;
				deletionTimerStart = trackedBreakableGlassData.deletionTimerStart;
				tickingDownToDeletion = trackedBreakableGlassData.tickingDownToDeletion;
				thickness = trackedBreakableGlassData.thickness;
				isAttached = trackedBreakableGlassData.isAttached;
				breakDepth = trackedBreakableGlassData.breakDepth;
				wrapperID = trackedBreakableGlassData.wrapperID;
				hasWrapper = trackedBreakableGlassData.hasWrapper;
			}
			previousPos = position;
			previousRot = rotation;
			position = trackedBreakableGlassData.position;
			rotation = trackedBreakableGlassData.rotation;
			if ((Object)(object)physicalBreakableGlass != (Object)null)
			{
				((Component)physicalBreakableGlass).transform.position = position;
				((Component)physicalBreakableGlass).transform.rotation = rotation;
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			if (full)
			{
				int num = packet.ReadByte();
				if (num > 0)
				{
					shape = new List<Vector2>();
					for (int i = 0; i < num; i++)
					{
						shape.Add(packet.ReadVector2());
					}
				}
				num = packet.ReadByte();
				if (num > 0)
				{
					baseShape = new List<Vector2>();
					for (int j = 0; j < num; j++)
					{
						baseShape.Add(packet.ReadVector2());
					}
				}
				deletionTimer = packet.ReadFloat();
				deletionTimerStart = packet.ReadFloat();
				tickingDownToDeletion = packet.ReadBool();
				thickness = packet.ReadFloat();
				isAttached = packet.ReadBool();
				breakDepth = packet.ReadInt();
				wrapperID = packet.ReadInt();
				packet.readPos += 4;
				hasWrapper = packet.ReadBool();
				if (ThreadManager.host && wrapperID == -1 && hasWrapper)
				{
					wrapperID = wrapperIDCounter++;
				}
			}
			if ((Object)(object)physicalBreakableGlass != (Object)null)
			{
				((Component)physicalBreakableGlass).transform.position = position;
				((Component)physicalBreakableGlass).transform.rotation = rotation;
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			base.Update(full);
			if ((Object)(object)physical == (Object)null)
			{
				return false;
			}
			if (full)
			{
				List<Vector3> list = new List<Vector3>();
				((Component)physicalBreakableGlass.physicalBreakableGlass).GetComponent<MeshFilter>().mesh.GetVertices(list);
				shape = CynGlass.MeshToShape(list, physicalBreakableGlass.physicalBreakableGlass.thickness);
				baseShape = physicalBreakableGlass.physicalBreakableGlass.baseShape;
				deletionTimer = physicalBreakableGlass.physicalBreakableGlass.m_deletionTimer;
				deletionTimerStart = physicalBreakableGlass.physicalBreakableGlass.m_deletionTimerStart;
				tickingDownToDeletion = physicalBreakableGlass.physicalBreakableGlass.m_tickingDownToDeletion;
				thickness = physicalBreakableGlass.physicalBreakableGlass.thickness;
				isAttached = physicalBreakableGlass.physicalBreakableGlass.isAttached;
				breakDepth = physicalBreakableGlass.physicalBreakableGlass.breakDepth;
			}
			previousPos = position;
			previousRot = rotation;
			position = ((Component)physicalBreakableGlass).transform.position;
			rotation = ((Component)physicalBreakableGlass).transform.rotation;
			return NeedsUpdate();
		}

		public override bool NeedsUpdate()
		{
			//IL_0010: 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)
			int result;
			if (!base.NeedsUpdate())
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					result = ((!((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2)) ? 1 : 0);
					goto IL_0049;
				}
			}
			result = 1;
			goto IL_0049;
			IL_0049:
			return (byte)result != 0;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
			if (!full)
			{
				return;
			}
			if (shape == null || shape.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)shape.Count);
				for (int i = 0; i < shape.Count; i++)
				{
					packet.Write(shape[i]);
				}
			}
			if (baseShape == null || baseShape.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)baseShape.Count);
				for (int j = 0; j < baseShape.Count; j++)
				{
					packet.Write(baseShape[j]);
				}
			}
			packet.Write(deletionTimer);
			packet.Write(deletionTimerStart);
			packet.Write(tickingDownToDeletion);
			packet.Write(thickness);
			packet.Write(isAttached);
			packet.Write(breakDepth);
			packet.Write(wrapperID);
			packet.Write(localWrapperID);
			packet.Write(hasWrapper);
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			base.OnTrackedIDReceived(newData);
			TrackedBreakableGlassData trackedBreakableGlassData = newData as TrackedBreakableGlassData;
			if (wrapperID == -1 && localWrapperID > -1 && localWrappersByID.TryGetValue(localWrapperID, out var value))
			{
				if (wrapperIDsbyWrapper.TryGetValue(value, out var value2))
				{
					wrapperID = value2;
					return;
				}
				wrapperID = trackedBreakableGlassData.wrapperID;
				wrappersByID.Add(wrapperID, value);
				wrapperIDsbyWrapper.Add(value, wrapperID);
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalBreakableGlass != (Object)null && (Object)(object)physicalBreakableGlass.physicalBreakableGlass != (Object)null)
			{
				GameManager.trackedBreakableGlassByBreakableGlass.Remove(physicalBreakableGlass.physicalBreakableGlass);
				GameManager.trackedBreakableGlassByBreakableGlassDamager.Remove(damager);
				GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)damager);
			}
		}

		public static void ClearWrapperDicts(bool loading)
		{
			if (!loading)
			{
				wrappersByID.Clear();
				wrapperIDsbyWrapper.Clear();
				localWrappersByID.Clear();
				localWrapperIDsbyWrapper.Clear();
			}
		}
	}
	public class TrackedBrutBlockSystem : TrackedObject
	{
		public BrutBlockSystem physicalBrutBlockSystem;

		public TrackedBrutBlockSystemData brutBlockSystemData;

		public override void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			base.Awake();
			GameObject val = new GameObject();
			val.transform.parent = ((Component)this).transform;
			TrackedObjectReference trackedObjectReference = val.AddComponent<TrackedObjectReference>();
			val.SetActive(false);
			CheckReferenceSize();
			int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
			TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
			TrackedObject.trackedReferenceObjects[num] = val;
			TrackedObject.trackedReferences[num] = this;
			((Object)val).name = num.ToString();
			trackedObjectReference.refIndex = num;
			((Component)this).GetComponent<BrutBlockSystem>().BlockPointUppers.Add(val.transform);
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedBrutBlockSystemByBrutBlockSystem.Remove(physicalBrutBlockSystem);
				base.OnDestroy();
			}
		}
	}
	public class TrackedBrutBlockSystemData : TrackedObjectData
	{
		public TrackedBrutBlockSystem physicalBrutBlockSystem;

		public static bool firstInScene;

		public static List<BrutBlockSystem> sceneBrutBlockSystems = new List<BrutBlockSystem>();

		public int index;

		public TrackedBrutBlockSystemData()
		{
		}

		public TrackedBrutBlockSystemData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<BrutBlockSystem>() != (Object)null;
		}

		public static bool TrackSkipped(Transform t)
		{
			if (firstInScene)
			{
				sceneBrutBlockSystems.Clear();
				firstInScene = false;
			}
			sceneBrutBlockSystems.Add(((Component)t).GetComponent<BrutBlockSystem>());
			return false;
		}

		public static TrackedBrutBlockSystem MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedBrutBlockSystem trackedBrutBlockSystem = ((Component)root).gameObject.AddComponent<TrackedBrutBlockSystem>();
			TrackedBrutBlockSystemData trackedBrutBlockSystemData = (trackedBrutBlockSystem.brutBlockSystemData = (TrackedBrutBlockSystemData)(trackedBrutBlockSystem.data = new TrackedBrutBlockSystemData()));
			trackedBrutBlockSystemData.physicalBrutBlockSystem = trackedBrutBlockSystem;
			trackedBrutBlockSystemData.physical = trackedBrutBlockSystem;
			trackedBrutBlockSystemData.physicalBrutBlockSystem.physicalBrutBlockSystem = ((Component)root).GetComponent<BrutBlockSystem>();
			trackedBrutBlockSystemData.physical.physical = (MonoBehaviour)(object)trackedBrutBlockSystemData.physicalBrutBlockSystem.physicalBrutBlockSystem;
			trackedBrutBlockSystemData.typeIdentifier = "TrackedBrutBlockSystemData";
			trackedBrutBlockSystemData.active = ((Component)trackedBrutBlockSystem).gameObject.activeInHierarchy;
			trackedBrutBlockSystemData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedBrutBlockSystemData.instance = GameManager.instance;
			trackedBrutBlockSystemData.controller = GameManager.ID;
			trackedBrutBlockSystemData.initTracker = GameManager.ID;
			trackedBrutBlockSystemData.sceneInit = GameManager.InSceneInit();
			if (firstInScene)
			{
				sceneBrutBlockSystems.Clear();
				firstInScene = false;
			}
			trackedBrutBlockSystemData.index = sceneBrutBlockSystems.Count;
			sceneBrutBlockSystems.Add(trackedBrutBlockSystemData.physicalBrutBlockSystem.physicalBrutBlockSystem);
			trackedBrutBlockSystemData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedBrutBlockSystemData);
			if (trackedBrutBlockSystem.awoken)
			{
				trackedBrutBlockSystem.data.Update(full: true);
			}
			return trackedBrutBlockSystem;
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating BrutBlockSystem");
			if (sceneBrutBlockSystems.Count > index)
			{
				BrutBlockSystem physicalBrutBlockSystemScript = sceneBrutBlockSystems[index];
				if ((Object)(object)physicalBrutBlockSystemScript == (Object)null)
				{
					Mod.LogError("Attempted to instantiate BrutBlockSystem " + index + " sent from " + base.controller + " but list at index is null.");
				}
				else
				{
					GameObject brutBlockSystemInstance = ((Component)physicalBrutBlockSystemScript).gameObject;
					physicalBrutBlockSystem = brutBlockSystemInstance.AddComponent<TrackedBrutBlockSystem>();
					physical = physicalBrutBlockSystem;
					physicalBrutBlockSystem.physicalBrutBlockSystem = physicalBrutBlockSystemScript;
					physical.physical = (MonoBehaviour)(object)physicalBrutBlockSystemScript;
					awaitingInstantiation = false;
					physicalBrutBlockSystem.brutBlockSystemData = this;
					physical.data = this;
					UpdateFromData(this, full: true);
				}
			}
			else
			{
				Mod.LogError("Attempted to instantiate BrutBlockSystem " + index + " sent from " + base.controller + " but index does not fit in scene gatling gun list.");
			}
			yield break;
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalBrutBlockSystem != (Object)null && (Object)(object)physicalBrutBlockSystem.physicalBrutBlockSystem != (Object)null)
			{
				GameManager.trackedBrutBlockSystemByBrutBlockSystem.Remove(physicalBrutBlockSystem.physicalBrutBlockSystem);
			}
		}
	}
	public class TrackedEncryption : TrackedObject
	{
		public TNH_EncryptionTarget physicalEncryption;

		public TrackedEncryptionData encryptionData;

		public static Dictionary<uint, List<int>> unknownInit = new Dictionary<uint, List<int>>();

		public static Dictionary<uint, List<int>> unknownSpawnSubTarg = new Dictionary<uint, List<int>>();

		public static Dictionary<uint, List<int>> unknownSpawnSubTargGeo = new Dictionary<uint, List<int>>();

		public static Dictionary<uint, List<int>> unknownDisableSubTarg = new Dictionary<uint, List<int>>();

		public static Dictionary<uint, List<KeyValuePair<int, Vector3>>> unknownSpawnGrowth = new Dictionary<uint, List<KeyValuePair<int, Vector3>>>();

		public static Dictionary<uint, List<KeyValuePair<int, Vector3>>> unknownResetGrowth = new Dictionary<uint, List<KeyValuePair<int, Vector3>>>();

		public static Dictionary<uint, int> unknownUpdateDisplay = new Dictionary<uint, int>();

		public static Dictionary<uint, Vector3> unknownPreviewPos = new Dictionary<uint, Vector3>();

		public static Dictionary<uint, Quaternion> unknownShieldRot = new Dictionary<uint, Quaternion>();

		public static TrackedEncryption[] trackedEncryptionReferences = new TrackedEncryption[100];

		public static List<int> availableTrackedEncryptionRefIndices = new List<int>
		{
			1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
			11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
			21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
			31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
			41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
			51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
			61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
			71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
			81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
			91, 92, 93, 94, 95, 96, 97, 98, 99
		};

		public override void Awake()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			base.Awake();
			GameManager.OnInstanceJoined += OnInstanceJoined;
			TNH_EncryptionTarget component = ((Component)this).GetComponent<TNH_EncryptionTarget>();
			if (component.SpawnPoints == null)
			{
				component.SpawnPoints = new List<Transform>();
			}
			GameObject val = new GameObject();
			val.SetActive(false);
			if (availableTrackedEncryptionRefIndices.Count == 0)
			{
				TrackedEncryption[] array = trackedEncryptionReferences;
				trackedEncryptionReferences = new TrackedEncryption[array.Length + 100];
				for (int i = 0; i < array.Length; i++)
				{
					trackedEncryptionReferences[i] = array[i];
				}
				for (int j = array.Length; j < trackedEncryptionReferences.Length; j++)
				{
					availableTrackedEncryptionRefIndices.Add(j);
				}
			}
			int num = availableTrackedEncryptionRefIndices[availableTrackedEncryptionRefIndices.Count - 1];
			availableTrackedEncryptionRefIndices.RemoveAt(availableTrackedEncryptionRefIndices.Count - 1);
			trackedEncryptionReferences[num] = this;
			((Object)val).name = num.ToString();
			component.SpawnPoints.Add(val.transform);
		}

		protected override void OnDestroy()
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			GameManager.OnInstanceJoined -= OnInstanceJoined;
			if (skipFullDestroy)
			{
				return;
			}
			GameManager.trackedEncryptionByEncryption.Remove(physicalEncryption);
			GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalEncryption);
			for (int i = 0; i < physicalEncryption.SubTargs.Count; i++)
			{
				IFVRDamageable component = physicalEncryption.SubTargs[i].GetComponent<IFVRDamageable>();
				if (component != null)
				{
					GameManager.trackedObjectByDamageable.Remove(component);
				}
			}
			if (data.controller != GameManager.ID)
			{
				if (physicalEncryption.UsesRegenerativeSubTarg)
				{
					for (int j = 0; j < physicalEncryption.Tendrils.Count; j++)
					{
						Object.Destroy((Object)(object)physicalEncryption.Tendrils[j]);
						Object.Destroy((Object)(object)physicalEncryption.SubTargs[j]);
					}
				}
				if ((Object)(object)physicalEncryption.m_returnToSpawnLine != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)physicalEncryption.m_returnToSpawnLine).gameObject);
				}
				if (physicalEncryption.FlashOnDestroy)
				{
					FXM instance = ManagerSingleton<FXM>.Instance;
					if ((Object)(object)instance.MuzzleFireLight != (Object)null && (Object)(object)instance.MuzzleFireLightOG != (Object)null)
					{
						FXM.InitiateMuzzleFlash(((Component)this).transform.position, Vector3.up, physicalEncryption.FlashIntensity, physicalEncryption.FlashColor, physicalEncryption.FlashRange);
					}
				}
				if ((Object)(object)physicalEncryption.m_point != (Object)null)
				{
					physicalEncryption.m_point.m_activeTargets.Remove(physicalEncryption);
				}
			}
			base.OnDestroy();
		}

		protected virtual void OnInstanceJoined(int instance, int source)
		{
			if (!GameManager.sceneLoading)
			{
				TrackedObjectData.ObjectBringType bring = TrackedObjectData.ObjectBringType.No;
				data.ShouldBring(scene: false, ref bring);
				GameManager.giveControlOfDestroyed++;
				if (bring == TrackedObjectData.ObjectBringType.Yes)
				{
					Object.DestroyImmediate((Object)(object)this);
					GameManager.SyncTrackedObjects(((Component)this).transform, controlEverything: true, null);
				}
				else
				{
					Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
				}
				GameManager.giveControlOfDestroyed--;
			}
		}
	}
	public class TrackedEncryptionData : TrackedObjectData
	{
		public TrackedEncryption physicalEncryption;

		public TNH_EncryptionType type;

		public bool simple;

		public Vector3 previousPos;

		public Quaternion previousRot;

		public Vector3 position;

		public Quaternion rotation;

		public Vector3 refractivePreviewPos;

		public Quaternion refractiveShieldRot;

		public bool[] subTargsActive;

		public bool[] subTargGeosActive;

		public Vector3 previousAgilePointerScale;

		public Vector3 agilePointerScale;

		public bool previousIsOrthagonalBeamFiring;

		public bool isOrthagonalBeamFiring;

		public int numHitsLeft;

		public Vector3 initialPos;

		public byte cascadingIndex;

		public byte cascadingDepth;

		public TrackedEncryptionData()
		{
		}

		public TrackedEncryptionData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			agilePointerScale = packet.ReadVector3();
			isOrthagonalBeamFiring = packet.ReadBool();
			type = (TNH_EncryptionType)packet.ReadByte();
			simple = packet.ReadBool();
			int num = packet.ReadInt();
			if (num > 0)
			{
				subTargsActive = new bool[num];
				for (int i = 0; i < num; i++)
				{
					subTargsActive[i] = packet.ReadBool();
				}
			}
			num = packet.ReadInt();
			if (num > 0)
			{
				subTargGeosActive = new bool[num];
				for (int j = 0; j < num; j++)
				{
					subTargGeosActive[j] = packet.ReadBool();
				}
			}
			numHitsLeft = packet.ReadInt();
			initialPos = packet.ReadVector3();
			cascadingIndex = packet.ReadByte();
			cascadingDepth = packet.ReadByte();
			refractivePreviewPos = packet.ReadVector3();
			refractiveShieldRot = packet.ReadQuaternion();
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<TNH_EncryptionTarget>() != (Object)null;
		}

		public static TrackedEncryption MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedEncryption trackedEncryption = ((Component)root).gameObject.AddComponent<TrackedEncryption>();
			TrackedEncryptionData trackedEncryptionData = (trackedEncryption.encryptionData = (TrackedEncryptionData)(trackedEncryption.data = new TrackedEncryptionData()));
			trackedEncryptionData.physicalEncryption = trackedEncryption;
			trackedEncryptionData.physical = trackedEncryption;
			trackedEncryptionData.physicalEncryption.physicalEncryption = ((Component)root).GetComponent<TNH_EncryptionTarget>();
			trackedEncryptionData.physical.physical = (MonoBehaviour)(object)trackedEncryptionData.physicalEncryption.physicalEncryption;
			trackedEncryptionData.typeIdentifier = "TrackedEncryptionData";
			trackedEncryptionData.active = ((Component)trackedEncryption).gameObject.activeInHierarchy;
			trackedEncryptionData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedEncryptionData.instance = GameManager.instance;
			trackedEncryptionData.controller = GameManager.ID;
			trackedEncryptionData.initTracker = GameManager.ID;
			trackedEncryptionData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedEncryptionByEncryption.Add(trackedEncryptionData.physicalEncryption.physicalEncryption, trackedEncryption);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedEncryptionData.physicalEncryption.physicalEncryption, trackedEncryption);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)trackedEncryptionData.physicalEncryption.physicalEncryption, trackedEncryption);
			for (int i = 0; i < trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs.Count; i++)
			{
				IFVRDamageable component = trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[i].GetComponent<IFVRDamageable>();
				if (component != null)
				{
					GameManager.trackedObjectByDamageable.Add(component, trackedEncryption);
				}
			}
			trackedEncryptionData.subTargsActive = new bool[trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs.Count];
			trackedEncryptionData.subTargGeosActive = new bool[trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargGeo.Count];
			trackedEncryptionData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedEncryptionData);
			if (trackedEncryption.awoken)
			{
				trackedEncryption.data.Update(full: true);
			}
			return trackedEncryption;
		}

		public override IEnumerator Instantiate()
		{
			GameObject prefab = null;
			if ((Object)(object)prefab == (Object)null)
			{
				if ((Object)(object)GM.TNH_Manager == (Object)null)
				{
					if (IM.OD.TryGetValue(EncryptionTypeToID(type, simple), out var obj))
					{
						yield return ((AnvilAsset)obj).GetGameObjectAsync();
						prefab = ((AnvilAsset)obj).GetGameObject();
					}
				}
				else if (simple)
				{
					MethodInfo GetEncryptionPrefabSimple = typeof(TNH_Manager).GetMethod("GetEncryptionPrefabSimple", BindingFlags.Instance | BindingFlags.Public);
					object? obj2 = GetEncryptionPrefabSimple.Invoke(GM.TNH_Manager, new object[1] { type });
					FVRObject simpleEncryption = (FVRObject)((obj2 is FVRObject) ? obj2 : null);
					if ((Object)(object)simpleEncryption != (Object)null)
					{
						prefab = ((AnvilAsset)simpleEncryption).GetGameObject();
					}
				}
				else if ((Object)(object)GM.TNH_Manager.GetEncryptionPrefab(type) != (Object)null)
				{
					prefab = ((AnvilAsset)GM.TNH_Manager.GetEncryptionPrefab(type)).GetGameObject();
				}
			}
			if ((Object)(object)prefab == (Object)null)
			{
				Mod.LogError($"Attempted to instantiate encryption {type} sent from {base.controller} but failed to get prefab.");
				awaitingInstantiation = false;
				yield break;
			}
			if ((int)type == 8)
			{
				int i = 0;
				while (i < cascadingDepth)
				{
					TNH_EncryptionTarget encryptionScript = prefab.GetComponent<TNH_EncryptionTarget>();
					if ((Object)(object)encryptionScript == (Object)null)
					{
						break;
					}
					prefab = ((i == cascadingDepth - 1) ? encryptionScript.SpawnOnDestruction[cascadingIndex] : encryptionScript.SpawnOnDestruction[0]);
					int num = i + 1;
					i = num;
				}
			}
			if (!awaitingInstantiation)
			{
				yield break;
			}
			Mod.skipAllInstantiates++;
			if (Mod.skipAllInstantiates <= 0)
			{
				Mod.LogError("SkipAllInstantiates negative or 0 at encryption instantiation, setting to 1");
				Mod.skipAllInstantiates = 1;
			}
			GameObject encryptionInstance = Object.Instantiate<GameObject>(prefab, position, rotation);
			Mod.skipAllInstantiates--;
			physicalEncryption = encryptionInstance.AddComponent<TrackedEncryption>();
			physical = physicalEncryption;
			TNH_EncryptionTarget physicalEncryptionScript = encryptionInstance.GetComponent<TNH_EncryptionTarget>();
			physicalEncryption.physicalEncryption = physicalEncryptionScript;
			physical.physical = (MonoBehaviour)(object)physicalEncryptionScript;
			awaitingInstantiation = false;
			physicalEncryption.encryptionData = this;
			physical.data = this;
			GameManager.trackedEncryptionByEncryption.Add(physicalEncryption.physicalEncryption, physicalEncryption);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalEncryption.physicalEncryption, physicalEncryption);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)physicalEncryption.physicalEncryption, physicalEncryption);
			int i2 = 0;
			while (i2 < physicalEncryption.physicalEncryption.SubTargs.Count)
			{
				IFVRDamageable damageable = physicalEncryption.physicalEncryption.SubTargs[i2].GetComponent<IFVRDamageable>();
				if (damageable != null)
				{
					GameManager.trackedObjectByDamageable.Add(damageable, physicalEncryption);
				}
				int num = i2 + 1;
				i2 = num;
			}
			if ((Object)(object)GM.TNH_Manager != (Object)null)
			{
				physicalEncryption.physicalEncryption.SetHoldPoint(GM.TNH_Manager.m_curHoldPoint);
				GM.TNH_Manager.m_curHoldPoint.RegisterNewTarget(physicalEncryption.physicalEncryption);
			}
			if (subTargsActive == null)
			{
				subTargsActive = new bool[physicalEncryption.physicalEncryption.SubTargs.Count];
			}
			if (subTargGeosActive == null)
			{
				subTargGeosActive = new bool[physicalEncryption.physicalEncryption.SubTargGeo.Count];
			}
			UpdateFromData(this, full: true);
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Invalid comparison between Unknown and I4
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0726: Unknown result type (might be due to invalid IL or missing references)
			//IL_072d: Invalid comparison between Unknown and I4
			//IL_06c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0747: Unknown result type (might be due to invalid IL or missing references)
			//IL_0763: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedEncryptionData trackedEncryptionData = updatedObject as TrackedEncryptionData;
			if (full)
			{
				type = trackedEncryptionData.type;
				simple = trackedEncryptionData.simple;
				subTargsActive = trackedEncryptionData.subTargsActive;
				subTargGeosActive = trackedEncryptionData.subTargGeosActive;
				numHitsLeft = trackedEncryptionData.numHitsLeft;
				initialPos = trackedEncryptionData.initialPos;
				cascadingIndex = trackedEncryptionData.cascadingIndex;
				cascadingDepth = trackedEncryptionData.cascadingDepth;
				refractivePreviewPos = trackedEncryptionData.refractivePreviewPos;
				refractiveShieldRot = trackedEncryptionData.refractiveShieldRot;
			}
			previousAgilePointerScale = agilePointerScale;
			agilePointerScale = trackedEncryptionData.agilePointerScale;
			previousIsOrthagonalBeamFiring = isOrthagonalBeamFiring;
			isOrthagonalBeamFiring = trackedEncryptionData.isOrthagonalBeamFiring;
			previousPos = position;
			previousRot = rotation;
			position = trackedEncryptionData.position;
			rotation = trackedEncryptionData.rotation;
			if (!((Object)(object)physicalEncryption != (Object)null))
			{
				return;
			}
			physicalEncryption.physicalEncryption.AgilePointerScale = agilePointerScale.x;
			if ((Object)(object)physicalEncryption.physicalEncryption.AgilePointer != (Object)null)
			{
				physicalEncryption.physicalEncryption.AgilePointer.localScale = agilePointerScale;
			}
			if ((int)type == 9 && (full || previousIsOrthagonalBeamFiring != isOrthagonalBeamFiring))
			{
				physicalEncryption.physicalEncryption.isOrthagonalBeamFiring = isOrthagonalBeamFiring;
				if (isOrthagonalBeamFiring)
				{
					foreach (Transform orthagonalBeam in physicalEncryption.physicalEncryption.OrthagonalBeams)
					{
						((Component)orthagonalBeam).gameObject.SetActive(true);
					}
					for (int i = 0; i < physicalEncryption.physicalEncryption.HitPoints.Count; i++)
					{
						physicalEncryption.physicalEncryption.HitPoints[i].Geo.SetActive(true);
						EmissionModule emission = physicalEncryption.physicalEncryption.HitPoints[i].PSys.emission;
						((EmissionModule)(ref emission)).enabled = true;
					}
					if (!physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.isPlaying)
					{
						physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.Play();
					}
					SM.PlayCoreSound((FVRPooledAudioType)5, physicalEncryption.physicalEncryption.AudEvent_OrthagonalLaserStart, ((Component)physicalEncryption).transform.position);
				}
				else
				{
					foreach (Transform orthagonalBeam2 in physicalEncryption.physicalEncryption.OrthagonalBeams)
					{
						((Component)orthagonalBeam2).gameObject.SetActive(false);
					}
					for (int j = 0; j < physicalEncryption.physicalEncryption.HitPoints.Count; j++)
					{
						physicalEncryption.physicalEncryption.HitPoints[j].Geo.SetActive(false);
						EmissionModule emission2 = physicalEncryption.physicalEncryption.HitPoints[j].PSys.emission;
						((EmissionModule)(ref emission2)).enabled = false;
					}
					if (physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.isPlaying)
					{
						physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.Stop();
					}
					SM.PlayCoreSound((FVRPooledAudioType)5, physicalEncryption.physicalEncryption.AudEvent_OrthagonalLaserEnd, ((Component)physicalEncryption).transform.position);
				}
			}
			if ((Object)(object)physicalEncryption.physicalEncryption.RB != (Object)null)
			{
				physicalEncryption.physicalEncryption.RB.position = position;
				physicalEncryption.physicalEncryption.RB.rotation = rotation;
			}
			else
			{
				((Component)physicalEncryption.physicalEncryption).transform.position = position;
				((Component)physicalEncryption.physicalEncryption).transform.rotation = rotation;
			}
			if (!full)
			{
				return;
			}
			if (subTargsActive.Length == physicalEncryption.physicalEncryption.SubTargs.Count)
			{
				int num = 0;
				for (int k = 0; k < subTargsActive.Length; k++)
				{
					if (subTargsActive[k])
					{
						physicalEncryption.physicalEncryption.SubTargs[k].SetActive(true);
						num++;
					}
					else
					{
						physicalEncryption.physicalEncryption.SubTargs[k].SetActive(false);
					}
				}
				physicalEncryption.physicalEncryption.m_numSubTargsLeft = num;
			}
			if (subTargGeosActive.Length == physicalEncryption.physicalEncryption.SubTargGeo.Count)
			{
				for (int l = 0; l < subTargGeosActive.Length; l++)
				{
					if (subTargGeosActive[l])
					{
						((Component)physicalEncryption.physicalEncryption.SubTargGeo[l]).gameObject.SetActive(true);
					}
					else
					{
						((Component)physicalEncryption.physicalEncryption.SubTargGeo[l]).gameObject.SetActive(false);
					}
				}
			}
			physicalEncryption.physicalEncryption.m_numHitsLeft = numHitsLeft;
			if (physicalEncryption.physicalEncryption.UsesMultipleDisplay && physicalEncryption.physicalEncryption.DisplayList.Count > numHitsLeft && (Object)(object)physicalEncryption.physicalEncryption.DisplayList[numHitsLeft] != (Object)null)
			{
				EncryptionPatch.updateDisplaySkip++;
				physicalEncryption.physicalEncryption.UpdateDisplay();
				EncryptionPatch.updateDisplaySkip--;
			}
			if (physicalEncryption.physicalEncryption.UseReturnToSpawnForce && (Object)(object)physicalEncryption.physicalEncryption.m_returnToSpawnLine == (Object)null)
			{
				physicalEncryption.physicalEncryption.initialPos = initialPos;
				GameObject val = Object.Instantiate<GameObject>(physicalEncryption.physicalEncryption.ReturnToSpawnLineGO, ((Component)physicalEncryption).transform.position, Quaternion.identity);
				physicalEncryption.physicalEncryption.m_returnToSpawnLine = val.transform;
				physicalEncryption.physicalEncryption.UpdateLine();
			}
			if ((int)type == 10)
			{
				physicalEncryption.physicalEncryption.RefractivePreview.position = refractivePreviewPos;
				physicalEncryption.physicalEncryption.RefractiveShield.rotation = refractiveShieldRot;
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Invalid comparison between Unknown and I4
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07aa: Invalid comparison between Unknown and I4
			//IL_0743: Unknown result type (might be due to invalid IL or missing references)
			//IL_0748: Unknown result type (might be due to invalid IL or missing references)
			//IL_0768: Unknown result type (might be due to invalid IL or missing references)
			//IL_076d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e0: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			previousPos = position;
			previousRot = rotation;
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			previousAgilePointerScale = agilePointerScale;
			agilePointerScale = packet.ReadVector3();
			previousIsOrthagonalBeamFiring = isOrthagonalBeamFiring;
			isOrthagonalBeamFiring = packet.ReadBool();
			if (full)
			{
				type = (TNH_EncryptionType)packet.ReadByte();
				simple = packet.ReadBool();
				int num = packet.ReadInt();
				if (num > 0)
				{
					subTargsActive = new bool[num];
					for (int i = 0; i < num; i++)
					{
						subTargsActive[i] = packet.ReadBool();
					}
				}
				num = packet.ReadInt();
				if (num > 0)
				{
					subTargGeosActive = new bool[num];
					for (int j = 0; j < num; j++)
					{
						subTargGeosActive[j] = packet.ReadBool();
					}
				}
				numHitsLeft = packet.ReadInt();
				initialPos = packet.ReadVector3();
				cascadingIndex = packet.ReadByte();
				cascadingDepth = packet.ReadByte();
				refractivePreviewPos = packet.ReadVector3();
				refractiveShieldRot = packet.ReadQuaternion();
			}
			if (!((Object)(object)physicalEncryption != (Object)null))
			{
				return;
			}
			physicalEncryption.physicalEncryption.AgilePointerScale = agilePointerScale.x;
			if ((Object)(object)physicalEncryption.physicalEncryption.AgilePointer != (Object)null)
			{
				physicalEncryption.physicalEncryption.AgilePointer.localScale = agilePointerScale;
			}
			if ((int)type == 9 && (full || previousIsOrthagonalBeamFiring != isOrthagonalBeamFiring))
			{
				physicalEncryption.physicalEncryption.isOrthagonalBeamFiring = isOrthagonalBeamFiring;
				if (isOrthagonalBeamFiring)
				{
					foreach (Transform orthagonalBeam in physicalEncryption.physicalEncryption.OrthagonalBeams)
					{
						((Component)orthagonalBeam).gameObject.SetActive(true);
					}
					for (int k = 0; k < physicalEncryption.physicalEncryption.HitPoints.Count; k++)
					{
						physicalEncryption.physicalEncryption.HitPoints[k].Geo.SetActive(true);
						EmissionModule emission = physicalEncryption.physicalEncryption.HitPoints[k].PSys.emission;
						((EmissionModule)(ref emission)).enabled = true;
					}
					if (!physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.isPlaying)
					{
						physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.Play();
					}
					SM.PlayCoreSound((FVRPooledAudioType)5, physicalEncryption.physicalEncryption.AudEvent_OrthagonalLaserStart, ((Component)physicalEncryption).transform.position);
				}
				else
				{
					foreach (Transform orthagonalBeam2 in physicalEncryption.physicalEncryption.OrthagonalBeams)
					{
						((Component)orthagonalBeam2).gameObject.SetActive(false);
					}
					for (int l = 0; l < physicalEncryption.physicalEncryption.HitPoints.Count; l++)
					{
						physicalEncryption.physicalEncryption.HitPoints[l].Geo.SetActive(false);
						EmissionModule emission2 = physicalEncryption.physicalEncryption.HitPoints[l].PSys.emission;
						((EmissionModule)(ref emission2)).enabled = false;
					}
					if (physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.isPlaying)
					{
						physicalEncryption.physicalEncryption.AudSource_OrthagonalLaserLoop.Stop();
					}
					SM.PlayCoreSound((FVRPooledAudioType)5, physicalEncryption.physicalEncryption.AudEvent_OrthagonalLaserEnd, ((Component)physicalEncryption).transform.position);
				}
			}
			if ((Object)(object)physicalEncryption.physicalEncryption.RB != (Object)null)
			{
				physicalEncryption.physicalEncryption.RB.position = position;
				physicalEncryption.physicalEncryption.RB.rotation = rotation;
			}
			else
			{
				((Component)physicalEncryption.physicalEncryption).transform.position = position;
				((Component)physicalEncryption.physicalEncryption).transform.rotation = rotation;
			}
			if (!full)
			{
				return;
			}
			if (subTargsActive.Length == physicalEncryption.physicalEncryption.SubTargs.Count)
			{
				int num2 = 0;
				for (int m = 0; m < subTargsActive.Length; m++)
				{
					if (subTargsActive[m])
					{
						physicalEncryption.physicalEncryption.SubTargs[m].SetActive(true);
						num2++;
					}
					else
					{
						physicalEncryption.physicalEncryption.SubTargs[m].SetActive(false);
					}
				}
				physicalEncryption.physicalEncryption.m_numSubTargsLeft = num2;
			}
			if (subTargGeosActive.Length == physicalEncryption.physicalEncryption.SubTargGeo.Count)
			{
				for (int n = 0; n < subTargGeosActive.Length; n++)
				{
					if (subTargGeosActive[n])
					{
						((Component)physicalEncryption.physicalEncryption.SubTargGeo[n]).gameObject.SetActive(true);
					}
					else
					{
						((Component)physicalEncryption.physicalEncryption.SubTargGeo[n]).gameObject.SetActive(false);
					}
				}
			}
			physicalEncryption.physicalEncryption.m_numHitsLeft = numHitsLeft;
			if (physicalEncryption.physicalEncryption.UsesMultipleDisplay && physicalEncryption.physicalEncryption.DisplayList.Count > numHitsLeft && (Object)(object)physicalEncryption.physicalEncryption.DisplayList[numHitsLeft] != (Object)null)
			{
				EncryptionPatch.updateDisplaySkip++;
				physicalEncryption.physicalEncryption.UpdateDisplay();
				EncryptionPatch.updateDisplaySkip--;
			}
			if (physicalEncryption.physicalEncryption.UseReturnToSpawnForce && (Object)(object)physicalEncryption.physicalEncryption.m_returnToSpawnLine == (Object)null)
			{
				physicalEncryption.physicalEncryption.initialPos = initialPos;
				GameObject val = Object.Instantiate<GameObject>(physicalEncryption.physicalEncryption.ReturnToSpawnLineGO, ((Component)physicalEncryption).transform.position, Quaternion.identity);
				physicalEncryption.physicalEncryption.m_returnToSpawnLine = val.transform;
				physicalEncryption.physicalEncryption.UpdateLine();
			}
			if ((int)type == 10)
			{
				physicalEncryption.physicalEncryption.RefractivePreview.position = refractivePreviewPos;
				physicalEncryption.physicalEncryption.RefractiveShield.rotation = refractiveShieldRot;
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Invalid comparison between Unknown and I4
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			base.Update(full);
			if ((Object)(object)physical == (Object)null)
			{
				return false;
			}
			if (full)
			{
				type = physicalEncryption.physicalEncryption.Type;
				simple = ((Object)physicalEncryption).name.Contains("_Simple");
				subTargsActive = new bool[(physicalEncryption.physicalEncryption.SubTargs != null) ? physicalEncryption.physicalEncryption.SubTargs.Count : 0];
				subTargGeosActive = new bool[(physicalEncryption.physicalEncryption.SubTargGeo != null) ? physicalEncryption.physicalEncryption.SubTargGeo.Count : 0];
				if (physicalEncryption.physicalEncryption.SubTargs != null)
				{
					for (int i = 0; i < physicalEncryption.physicalEncryption.SubTargs.Count; i++)
					{
						subTargsActive[i] = physicalEncryption.physicalEncryption.SubTargs[i].activeSelf;
					}
				}
				if (physicalEncryption.physicalEncryption.SubTargGeo != null)
				{
					for (int j = 0; j < physicalEncryption.physicalEncryption.SubTargGeo.Count; j++)
					{
						subTargGeosActive[j] = ((Component)physicalEncryption.physicalEncryption.SubTargGeo[j]).gameObject.activeSelf;
					}
				}
				numHitsLeft = physicalEncryption.physicalEncryption.m_numHitsLeft;
				initialPos = physicalEncryption.physicalEncryption.initialPos;
				cascadingIndex = (byte)EncryptionPatch.cascadingDestroyIndex;
				cascadingDepth = (byte)EncryptionPatch.cascadingDestroyDepth;
				if ((int)type == 10)
				{
					refractivePreviewPos = physicalEncryption.physicalEncryption.RefractivePreview.position;
					refractiveShieldRot = physicalEncryption.physicalEncryption.RefractiveShield.rotation;
				}
			}
			previousAgilePointerScale = agilePointerScale;
			if ((Object)(object)physicalEncryption.physicalEncryption.AgilePointer != (Object)null)
			{
				agilePointerScale = physicalEncryption.physicalEncryption.AgilePointer.localScale;
			}
			previousIsOrthagonalBeamFiring = isOrthagonalBeamFiring;
			isOrthagonalBeamFiring = physicalEncryption.physicalEncryption.isOrthagonalBeamFiring;
			previousPos = position;
			previousRot = rotation;
			if ((Object)(object)physicalEncryption.physicalEncryption.RB != (Object)null)
			{
				position = physicalEncryption.physicalEncryption.RB.position;
				rotation = physicalEncryption.physicalEncryption.RB.rotation;
			}
			else
			{
				position = ((Component)physicalEncryption.physicalEncryption).transform.position;
				rotation = ((Component)physicalEncryption.physicalEncryption).transform.rotation;
			}
			return NeedsUpdate();
		}

		public override bool NeedsUpdate()
		{
			//IL_0010: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (!base.NeedsUpdate())
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2) && !(agilePointerScale != previousAgilePointerScale))
					{
						result = ((isOrthagonalBeamFiring != previousIsOrthagonalBeamFiring) ? 1 : 0);
						goto IL_006c;
					}
				}
			}
			result = 1;
			goto IL_006c;
			IL_006c:
			return (byte)result != 0;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
			packet.Write(agilePointerScale);
			packet.Write(isOrthagonalBeamFiring);
			if (!full)
			{
				return;
			}
			packet.Write((byte)type);
			packet.Write(simple);
			if (subTargsActive == null || subTargsActive.Length == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(subTargsActive.Length);
				for (int i = 0; i < subTargsActive.Length; i++)
				{
					packet.Write(subTargsActive[i]);
				}
			}
			if (subTargGeosActive == null || subTargGeosActive.Length == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(subTargGeosActive.Length);
				for (int j = 0; j < subTargGeosActive.Length; j++)
				{
					packet.Write(subTargGeosActive[j]);
				}
			}
			packet.Write(numHitsLeft);
			packet.Write(initialPos);
			packet.Write(cascadingIndex);
			packet.Write(cascadingDepth);
			packet.Write(refractivePreviewPos);
			packet.Write(refractiveShieldRot);
		}

		public unsafe static string EncryptionTypeToID(TNH_EncryptionType type, bool simple)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected I4, but got Unknown
			TNH_EncryptionType val = type;
			TNH_EncryptionType val2 = val;
			switch ((int)val2)
			{
			case 0:
				return "TNH_EncryptionTarget_1_Static";
			case 1:
				return "TNH_EncryptionTarget_2_Hardened";
			case 2:
				return "TNH_EncryptionTarget_3_Swarm";
			case 3:
				return "TNH_EncryptionTarget_4_Recursive";
			case 4:
				return "TNH_EncryptionTarget_5_Stealth";
			case 5:
				return "TNH_EncryptionTarget_6_Agile";
			case 6:
				return "TNH_EncryptionTarget_7_Regenerative" + (simple ? "_Simple" : "");
			case 7:
				return "TNH_EncryptionTarget_8_Polymorphic" + (simple ? "_Simple" : "");
			case 8:
				return "TNH_EncryptionTarget_9_Cascading" + (simple ? "_Simple" : "");
			case 9:
				return "TNH_EncryptionTarget_10_Orthagonal" + (simple ? "_Simple" : "");
			case 10:
				return "TNH_EncryptionTarget_11_Refractive";
			default:
				Mod.LogError("EncryptionTypeToID unhandled type: " + ((object)(*(TNH_EncryptionType*)(&type))/*cast due to .constrained prefix*/).ToString());
				return "TNH_EncryptionTarget_1_Static";
			}
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			base.OnTrackedIDReceived(newData);
			if (localTrackedID != -1 && TrackedEncryption.unknownInit.ContainsKey(localWaitingIndex))
			{
				List<int> indices = TrackedEncryption.unknownInit[localWaitingIndex];
				ClientSend.EncryptionInit(trackedID, indices, initialPos, numHitsLeft);
				TrackedEncryption.unknownInit.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownSpawnSubTarg.ContainsKey(localWaitingIndex))
			{
				List<int> list = TrackedEncryption.unknownSpawnSubTarg[localWaitingIndex];
				for (int i = 0; i < list.Count; i++)
				{
					ClientSend.EncryptionRespawnSubTarg(trackedID, list[i]);
				}
				TrackedEncryption.unknownSpawnSubTarg.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownSpawnSubTargGeo.ContainsKey(localWaitingIndex))
			{
				List<int> list2 = TrackedEncryption.unknownSpawnSubTargGeo[localWaitingIndex];
				for (int j = 0; j < list2.Count; j++)
				{
					ClientSend.EncryptionRespawnSubTargGeo(trackedID, list2[j]);
				}
				TrackedEncryption.unknownSpawnSubTargGeo.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownDisableSubTarg.ContainsKey(localWaitingIndex))
			{
				List<int> list3 = TrackedEncryption.unknownDisableSubTarg[localWaitingIndex];
				for (int k = 0; k < list3.Count; k++)
				{
					ClientSend.EncryptionDisableSubtarg(trackedID, list3[k]);
				}
				TrackedEncryption.unknownDisableSubTarg.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownSpawnGrowth.ContainsKey(localWaitingIndex))
			{
				List<KeyValuePair<int, Vector3>> list4 = TrackedEncryption.unknownSpawnGrowth[localWaitingIndex];
				for (int l = 0; l < list4.Count; l++)
				{
					ClientSend.EncryptionSpawnGrowth(trackedID, list4[l].Key, list4[l].Value);
				}
				TrackedEncryption.unknownSpawnGrowth.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownResetGrowth.ContainsKey(localWaitingIndex))
			{
				List<KeyValuePair<int, Vector3>> list5 = TrackedEncryption.unknownResetGrowth[localWaitingIndex];
				for (int m = 0; m < list5.Count; m++)
				{
					ClientSend.EncryptionResetGrowth(trackedID, list5[m].Key, list5[m].Value);
				}
				TrackedEncryption.unknownResetGrowth.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownUpdateDisplay.TryGetValue(localWaitingIndex, out var value))
			{
				ClientSend.UpdateEncryptionDisplay(trackedID, value);
				TrackedEncryption.unknownUpdateDisplay.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownPreviewPos.TryGetValue(localWaitingIndex, out var value2))
			{
				ClientSend.EncryptionNextPos(trackedID, value2);
				TrackedEncryption.unknownPreviewPos.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedEncryption.unknownShieldRot.TryGetValue(localWaitingIndex, out var value3))
			{
				ClientSend.EncryptionShieldRot(trackedID, value3);
				TrackedEncryption.unknownShieldRot.Remove(localWaitingIndex);
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID != -1)
			{
				return;
			}
			TrackedEncryption.unknownInit.Remove(localWaitingIndex);
			TrackedEncryption.unknownSpawnGrowth.Remove(localWaitingIndex);
			TrackedEncryption.unknownResetGrowth.Remove(localWaitingIndex);
			TrackedEncryption.unknownSpawnSubTarg.Remove(localWaitingIndex);
			TrackedEncryption.unknownSpawnSubTargGeo.Remove(localWaitingIndex);
			TrackedEncryption.unknownDisableSubTarg.Remove(localWaitingIndex);
			TrackedEncryption.unknownUpdateDisplay.Remove(localWaitingIndex);
			TrackedEncryption.unknownPreviewPos.Remove(localWaitingIndex);
			TrackedEncryption.unknownShieldRot.Remove(localWaitingIndex);
			if (!((Object)(object)physicalEncryption != (Object)null) || !((Object)(object)physicalEncryption.physicalEncryption != (Object)null))
			{
				return;
			}
			GameManager.trackedEncryptionByEncryption.Remove(physicalEncryption.physicalEncryption);
			GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalEncryption.physicalEncryption);
			for (int i = 0; i < physicalEncryption.physicalEncryption.SubTargs.Count; i++)
			{
				IFVRDamageable component = physicalEncryption.physicalEncryption.SubTargs[i].GetComponent<IFVRDamageable>();
				if (component != null)
				{
					GameManager.trackedObjectByDamageable.Remove(component);
				}
			}
		}
	}
	public class TrackedFloater : TrackedObject
	{
		public Construct_Floater physicalFloater;

		public TrackedFloaterData floaterData;

		public static List<uint> unknownFloaterBeginExploding = new List<uint>();

		public static List<uint> unknownFloaterBeginDefusing = new List<uint>();

		public static Dictionary<uint, bool> unknownFloaterExplode = new Dictionary<uint, bool>();

		public override void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			base.Awake();
			GameObject val = new GameObject();
			val.transform.parent = ((Component)this).transform;
			TrackedObjectReference trackedObjectReference = val.AddComponent<TrackedObjectReference>();
			val.SetActive(false);
			CheckReferenceSize();
			int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
			TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
			TrackedObject.trackedReferenceObjects[num] = val;
			TrackedObject.trackedReferences[num] = this;
			((Object)val).name = num.ToString();
			trackedObjectReference.refIndex = num;
			((Component)this).GetComponent<Construct_Floater>().SpawnOnSplode.Add(val);
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedFloaterByFloater.Remove(physicalFloater);
				GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalFloater);
				IFVRDamageable componentInChildren = (IFVRDamageable)(object)((Component)physicalFloater).GetComponentInChildren<Construct_Floater_Core>();
				if (componentInChildren != null)
				{
					GameManager.trackedObjectByDamageable.Remove(componentInChildren);
				}
				base.OnDestroy();
			}
		}
	}
	public class TrackedFloaterData : TrackedObjectData
	{
		public TrackedFloater physicalFloater;

		public Vector3 previousPos;

		public Vector3 position;

		public Quaternion previousRot;

		public Quaternion rotation;

		public TrackedFloaterData()
		{
		}

		public TrackedFloaterData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<Construct_Floater>() != (Object)null;
		}

		private static TrackedFloater MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedFloater trackedFloater = ((Component)root).gameObject.AddComponent<TrackedFloater>();
			TrackedFloaterData trackedFloaterData = (TrackedFloaterData)(trackedFloater.data = (trackedFloater.floaterData = new TrackedFloaterData()));
			trackedFloaterData.physicalFloater = trackedFloater;
			trackedFloaterData.physical = trackedFloater;
			Construct_Floater component = ((Component)root).GetComponent<Construct_Floater>();
			trackedFloaterData.physicalFloater.physicalFloater = component;
			trackedFloaterData.physical.physical = (MonoBehaviour)(object)component;
			trackedFloaterData.typeIdentifier = "TrackedFloaterData";
			trackedFloaterData.active = ((Component)trackedFloater).gameObject.activeInHierarchy;
			trackedFloaterData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedFloaterData.instance = GameManager.instance;
			trackedFloaterData.controller = GameManager.ID;
			trackedFloaterData.initTracker = GameManager.ID;
			trackedFloaterData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedFloaterByFloater.Add(trackedFloater.physicalFloater, trackedFloater);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedFloater.physicalFloater, trackedFloater);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)trackedFloater.physicalFloater, trackedFloater);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)((Component)trackedFloater).GetComponentInChildren<Construct_Floater_Core>(), trackedFloater);
			trackedFloaterData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedFloaterData);
			if (trackedFloater.awoken)
			{
				trackedFloater.data.Update(full: true);
			}
			Mod.LogInfo("Made floater " + ((Object)trackedFloater).name + " tracked", debug: false);
			return trackedFloater;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating floater at " + trackedID, debug: false);
			Construct_Floater_Volume floaterVolume = Object.FindObjectOfType<Construct_Floater_Volume>();
			GameObject prefab;
			if ((Object)(object)floaterVolume == (Object)null)
			{
				SosigSpawner sosigSpawner = Object.FindObjectOfType<SosigSpawner>();
				if (!((Object)(object)sosigSpawner != (Object)null))
				{
					Mod.LogError("Failed to instantiate floater: " + trackedID + ": Could not find suitable floater volume or sosig spawner to get prefab from");
					yield break;
				}
				prefab = sosigSpawner.SpawnerGroups[19].Furnitures[0];
			}
			else
			{
				prefab = floaterVolume.Floater_Prefab;
			}
			Mod.skipAllInstantiates++;
			GameObject floaterInstance = Object.Instantiate<GameObject>(prefab, position, rotation);
			Mod.skipAllInstantiates--;
			physicalFloater = floaterInstance.AddComponent<TrackedFloater>();
			physical = physicalFloater;
			physicalFloater.physicalFloater = floaterInstance.GetComponent<Construct_Floater>();
			physical.physical = (MonoBehaviour)(object)physicalFloater.physicalFloater;
			awaitingInstantiation = false;
			physicalFloater.floaterData = this;
			physicalFloater.data = this;
			GameManager.trackedFloaterByFloater.Add(physicalFloater.physicalFloater, physicalFloater);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalFloater.physicalFloater, physicalFloater);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)physicalFloater.physicalFloater, physicalFloater);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)((Component)physicalFloater).GetComponentInChildren<Construct_Floater_Core>(), physicalFloater);
			if (base.controller != GameManager.ID)
			{
				if ((Object)(object)GM.CurrentAIManager != (Object)null)
				{
					GM.CurrentAIManager.DeRegisterAIEntity(physicalFloater.physicalFloater.E);
				}
				physicalFloater.physicalFloater.RB.isKinematic = true;
			}
			UpdateFromData(this);
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedFloaterData trackedFloaterData = updatedObject as TrackedFloaterData;
			previousPos = position;
			position = trackedFloaterData.position;
			previousRot = rotation;
			rotation = trackedFloaterData.rotation;
			if ((Object)(object)physicalFloater != (Object)null)
			{
				((Component)physicalFloater.physicalFloater).transform.position = position;
				((Component)physicalFloater.physicalFloater).transform.rotation = rotation;
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			previousPos = position;
			position = packet.ReadVector3();
			previousRot = rotation;
			rotation = packet.ReadQuaternion();
			if ((Object)(object)physicalFloater != (Object)null)
			{
				((Component)physicalFloater.physicalFloater).transform.position = position;
				((Component)physicalFloater.physicalFloater).transform.rotation = rotation;
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			bool flag = base.Update(full);
			if ((Object)(object)physicalFloater == (Object)null)
			{
				return false;
			}
			previousPos = position;
			previousRot = rotation;
			position = ((Component)physicalFloater.physicalFloater).transform.position;
			rotation = ((Component)physicalFloater.physicalFloater).transform.rotation;
			int result;
			if (!flag)
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					result = ((!((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2)) ? 1 : 0);
					goto IL_00b2;
				}
			}
			result = 1;
			goto IL_00b2;
			IL_00b2:
			return (byte)result != 0;
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			base.OnTrackedIDReceived(newData);
			if (localTrackedID != -1 && TrackedFloater.unknownFloaterBeginExploding.Contains(localWaitingIndex))
			{
				ClientSend.FloaterBeginExploding(trackedID, control: true);
				TrackedFloater.unknownFloaterBeginExploding.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedFloater.unknownFloaterBeginDefusing.Contains(localWaitingIndex))
			{
				ClientSend.FloaterBeginDefusing(trackedID, control: true);
				TrackedFloater.unknownFloaterBeginDefusing.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedFloater.unknownFloaterExplode.TryGetValue(localWaitingIndex, out var value))
			{
				ClientSend.FloaterExplode(trackedID, value);
				TrackedFloater.unknownFloaterExplode.Remove(localWaitingIndex);
			}
		}

		public override void OnControlChanged(int newController)
		{
			base.OnControlChanged(newController);
			if (newController == GameManager.ID)
			{
				if ((Object)(object)physicalFloater != (Object)null && (Object)(object)physicalFloater.physicalFloater != (Object)null)
				{
					if ((Object)(object)GM.CurrentAIManager != (Object)null)
					{
						GM.CurrentAIManager.RegisterAIEntity(physicalFloater.physicalFloater.E);
					}
					physicalFloater.physicalFloater.RB.isKinematic = false;
				}
			}
			else if (base.controller == GameManager.ID && (Object)(object)physicalFloater != (Object)null && (Object)(object)physicalFloater.physicalFloater != (Object)null)
			{
				if ((Object)(object)GM.CurrentAIManager != (Object)null)
				{
					GM.CurrentAIManager.DeRegisterAIEntity(physicalFloater.physicalFloater.E);
				}
				physicalFloater.physicalFloater.RB.isKinematic = true;
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalFloater != (Object)null && (Object)(object)physicalFloater.physicalFloater != (Object)null)
			{
				GameManager.trackedFloaterByFloater.Remove(physicalFloater.physicalFloater);
				GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalFloater.physicalFloater);
				IFVRDamageable componentInChildren = (IFVRDamageable)(object)((Component)physicalFloater).GetComponentInChildren<Construct_Floater_Core>();
				if (componentInChildren != null)
				{
					GameManager.trackedObjectByDamageable.Remove(componentInChildren);
				}
			}
		}
	}
	public class TrackedGatlingGun : TrackedObject
	{
		public wwGatlingGun physicalGatlingGun;

		public TrackedGatlingGunData gatlingGunData;

		public override void EnsureUncontrolled()
		{
			if ((Object)(object)((FVRInteractiveObject)gatlingGunData.controlHandle).m_hand != (Object)null)
			{
				((FVRInteractiveObject)gatlingGunData.controlHandle).ForceBreakInteraction();
			}
			if ((Object)(object)((FVRInteractiveObject)gatlingGunData.crankHandle).m_hand != (Object)null)
			{
				((FVRInteractiveObject)gatlingGunData.crankHandle).ForceBreakInteraction();
			}
			if ((Object)(object)((FVRInteractiveObject)gatlingGunData.baseHandle).m_hand != (Object)null)
			{
				((FVRInteractiveObject)gatlingGunData.baseHandle).ForceBreakInteraction();
			}
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			if (data.controller != GameManager.ID)
			{
				data.TakeControlRecursive();
			}
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedGatlingGunByGatlingGun.Remove(physicalGatlingGun);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)gatlingGunData.controlHandle);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)gatlingGunData.crankHandle);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)gatlingGunData.baseHandle);
				base.OnDestroy();
			}
		}
	}
	public class TrackedGatlingGunData : TrackedObjectData
	{
		public TrackedGatlingGun physicalGatlingGun;

		public static bool firstInScene;

		public static List<wwGatlingGun> sceneGatlingGuns = new List<wwGatlingGun>();

		public int index;

		public Quaternion controlBracketRotation;

		public Quaternion previousControlBracketRotation;

		public Quaternion controlRotation;

		public Quaternion previousControlRotation;

		public Vector3 crankRotation;

		public Vector3 previousCrankRotation;

		public Quaternion baseRotation;

		public Quaternion previousBaseRotation;

		public wwGatlingControlHandle controlHandle;

		public wwGatlingGunHandle crankHandle;

		public wwGatlingGunBaseHandle baseHandle;

		public TrackedGatlingGunData()
		{
		}

		public TrackedGatlingGunData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			controlBracketRotation = packet.ReadQuaternion();
			controlRotation = packet.ReadQuaternion();
			crankRotation = packet.ReadVector3();
			baseRotation = packet.ReadQuaternion();
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<wwGatlingGun>() != (Object)null;
		}

		public static bool IsControlled(Transform root)
		{
			FVRInteractiveObject componentInChildren = (FVRInteractiveObject)(object)((Component)root).GetComponentInChildren<wwGatlingControlHandle>();
			if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.m_hand != (Object)null)
			{
				return true;
			}
			componentInChildren = (FVRInteractiveObject)(object)((Component)root).GetComponentInChildren<wwGatlingGunHandle>();
			if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.m_hand != (Object)null)
			{
				return true;
			}
			componentInChildren = (FVRInteractiveObject)(object)((Component)root).GetComponentInChildren<wwGatlingGunBaseHandle>();
			if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.m_hand != (Object)null)
			{
				return true;
			}
			return false;
		}

		public static bool TrackSkipped(Transform t)
		{
			if (firstInScene)
			{
				sceneGatlingGuns.Clear();
				firstInScene = false;
			}
			sceneGatlingGuns.Add(((Component)t).GetComponent<wwGatlingGun>());
			return false;
		}

		public static TrackedGatlingGun MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedGatlingGun trackedGatlingGun = ((Component)root).gameObject.AddComponent<TrackedGatlingGun>();
			TrackedGatlingGunData trackedGatlingGunData = (trackedGatlingGun.gatlingGunData = (TrackedGatlingGunData)(trackedGatlingGun.data = new TrackedGatlingGunData()));
			trackedGatlingGunData.physicalGatlingGun = trackedGatlingGun;
			trackedGatlingGunData.physical = trackedGatlingGun;
			trackedGatlingGunData.physicalGatlingGun.physicalGatlingGun = ((Component)root).GetComponent<wwGatlingGun>();
			trackedGatlingGunData.physical.physical = (MonoBehaviour)(object)trackedGatlingGunData.physicalGatlingGun.physicalGatlingGun;
			trackedGatlingGunData.typeIdentifier = "TrackedGatlingGunData";
			trackedGatlingGunData.active = ((Component)trackedGatlingGun).gameObject.activeInHierarchy;
			trackedGatlingGunData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedGatlingGunData.instance = GameManager.instance;
			trackedGatlingGunData.controller = GameManager.ID;
			trackedGatlingGunData.initTracker = GameManager.ID;
			trackedGatlingGunData.sceneInit = GameManager.InSceneInit();
			if (firstInScene)
			{
				sceneGatlingGuns.Clear();
				firstInScene = false;
			}
			trackedGatlingGunData.index = sceneGatlingGuns.Count;
			sceneGatlingGuns.Add(trackedGatlingGunData.physicalGatlingGun.physicalGatlingGun);
			trackedGatlingGunData.controlHandle = ((Component)trackedGatlingGunData.physicalGatlingGun).GetComponentInChildren<wwGatlingControlHandle>();
			trackedGatlingGunData.crankHandle = ((Component)trackedGatlingGunData.physicalGatlingGun).GetComponentInChildren<wwGatlingGunHandle>();
			trackedGatlingGunData.baseHandle = ((Component)trackedGatlingGunData.physicalGatlingGun).GetComponentInChildren<wwGatlingGunBaseHandle>();
			GameManager.trackedGatlingGunByGatlingGun.Add(trackedGatlingGunData.physicalGatlingGun.physicalGatlingGun, trackedGatlingGun);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedGatlingGunData.physicalGatlingGun.physicalGatlingGun, trackedGatlingGun);
			GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)trackedGatlingGunData.controlHandle, trackedGatlingGun);
			GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)trackedGatlingGunData.crankHandle, trackedGatlingGun);
			GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)trackedGatlingGunData.baseHandle, trackedGatlingGun);
			trackedGatlingGunData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedGatlingGunData);
			if (trackedGatlingGun.awoken)
			{
				trackedGatlingGun.data.Update(full: true);
			}
			return trackedGatlingGun;
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating gatling gun");
			if (sceneGatlingGuns.Count > index)
			{
				wwGatlingGun physicalGatlingGunScript = sceneGatlingGuns[index];
				if ((Object)(object)physicalGatlingGunScript == (Object)null)
				{
					Mod.LogError("Attempted to instantiate wwGatlingGun " + index + " sent from " + base.controller + " but list at index is null.");
					yield break;
				}
				GameObject gatlingGunInstance = ((Component)physicalGatlingGunScript).gameObject;
				physicalGatlingGun = gatlingGunInstance.AddComponent<TrackedGatlingGun>();
				physical = physicalGatlingGun;
				physicalGatlingGun.physicalGatlingGun = physicalGatlingGunScript;
				physical.physical = (MonoBehaviour)(object)physicalGatlingGunScript;
				awaitingInstantiation = false;
				physicalGatlingGun.gatlingGunData = this;
				physical.data = this;
				controlHandle = ((Component)physicalGatlingGun).GetComponentInChildren<wwGatlingControlHandle>();
				crankHandle = ((Component)physicalGatlingGun).GetComponentInChildren<wwGatlingGunHandle>();
				baseHandle = ((Component)physicalGatlingGun).GetComponentInChildren<wwGatlingGunBaseHandle>();
				GameManager.trackedGatlingGunByGatlingGun.Add(physicalGatlingGun.physicalGatlingGun, physicalGatlingGun);
				GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalGatlingGun.physicalGatlingGun, physicalGatlingGun);
				GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)controlHandle, physicalGatlingGun);
				GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)crankHandle, physicalGatlingGun);
				GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)baseHandle, physicalGatlingGun);
				UpdateFromData(this, full: true);
			}
			else
			{
				Mod.LogError("Attempted to instantiate wwGatlingGun " + index + " sent from " + base.controller + " but index does not fit in scene gatling gun list.");
			}
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedGatlingGunData trackedGatlingGunData = updatedObject as TrackedGatlingGunData;
			previousControlBracketRotation = controlBracketRotation;
			controlBracketRotation = trackedGatlingGunData.controlBracketRotation;
			previousControlRotation = controlRotation;
			controlRotation = trackedGatlingGunData.controlRotation;
			previousCrankRotation = crankRotation;
			crankRotation = trackedGatlingGunData.crankRotation;
			previousBaseRotation = baseRotation;
			baseRotation = trackedGatlingGunData.baseRotation;
			if ((Object)(object)physicalGatlingGun != (Object)null)
			{
				controlHandle.MountingBracket.rotation = controlBracketRotation;
				((Component)controlHandle).transform.rotation = controlRotation;
				((Component)crankHandle).transform.rotation = Quaternion.LookRotation(crankRotation, crankHandle.YUpTarget.up);
				((Component)baseHandle.GunBase).transform.rotation = baseRotation;
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			previousControlBracketRotation = controlBracketRotation;
			controlBracketRotation = packet.ReadQuaternion();
			previousControlRotation = controlRotation;
			controlRotation = packet.ReadQuaternion();
			previousCrankRotation = crankRotation;
			crankRotation = packet.ReadVector3();
			previousBaseRotation = baseRotation;
			baseRotation = packet.ReadQuaternion();
			if ((Object)(object)physicalGatlingGun != (Object)null)
			{
				controlHandle.MountingBracket.rotation = controlBracketRotation;
				((Component)controlHandle).transform.rotation = controlRotation;
				((Component)crankHandle).transform.rotation = Quaternion.LookRotation(crankRotation, crankHandle.YUpTarget.up);
				((Component)baseHandle.GunBase).transform.rotation = baseRotation;
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			base.Update(full);
			if ((Object)(object)physical == (Object)null)
			{
				return false;
			}
			previousControlBracketRotation = controlBracketRotation;
			controlBracketRotation = controlHandle.MountingBracket.rotation;
			previousControlRotation = controlRotation;
			controlRotation = ((Component)controlHandle).transform.rotation;
			previousCrankRotation = crankRotation;
			crankRotation = crankHandle.m_curCrankDir;
			previousBaseRotation = baseRotation;
			baseRotation = ((Component)baseHandle.GunBase).transform.rotation;
			return NeedsUpdate();
		}

		public override bool NeedsUpdate()
		{
			//IL_0010: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (!base.NeedsUpdate())
			{
				ref Quaternion reference = ref previousControlBracketRotation;
				object obj = controlBracketRotation;
				if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousControlRotation;
					object obj2 = controlRotation;
					if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2))
					{
						ref Vector3 reference3 = ref previousCrankRotation;
						object obj3 = crankRotation;
						if (((object)Unsafe.As<Vector3, Vector3>(ref reference3)/*cast due to .constrained prefix*/).Equals(obj3))
						{
							ref Quaternion reference4 = ref previousBaseRotation;
							object obj4 = baseRotation;
							result = ((!((object)Unsafe.As<Quaternion, Quaternion>(ref reference4)/*cast due to .constrained prefix*/).Equals(obj4)) ? 1 : 0);
							goto IL_0085;
						}
					}
				}
			}
			result = 1;
			goto IL_0085;
			IL_0085:
			return (byte)result != 0;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(controlBracketRotation);
			packet.Write(controlRotation);
			packet.Write(crankRotation);
			packet.Write(baseRotation);
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalGatlingGun != (Object)null && (Object)(object)physicalGatlingGun.physicalGatlingGun != (Object)null)
			{
				GameManager.trackedGatlingGunByGatlingGun.Remove(physicalGatlingGun.physicalGatlingGun);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)controlHandle);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)crankHandle);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)baseHandle);
			}
		}
	}
	public class TrackedHaze : TrackedObject
	{
		public Construct_Haze physicalHaze;

		public TrackedHazeData hazeData;

		public override void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			base.Awake();
			GameObject val = new GameObject();
			val.transform.parent = ((Component)this).transform;
			TrackedObjectReference trackedObjectReference = val.AddComponent<TrackedObjectReference>();
			ParticleSystem pSystem = val.AddComponent<ParticleSystem>();
			val.SetActive(false);
			CheckReferenceSize();
			int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
			TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
			TrackedObject.trackedReferenceObjects[num] = val;
			TrackedObject.trackedReferences[num] = this;
			((Object)val).name = num.ToString();
			trackedObjectReference.refIndex = num;
			((Component)this).GetComponent<Construct_Haze>().PSystem2 = pSystem;
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedHazeByHaze.Remove(physicalHaze);
				GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalHaze);
				base.OnDestroy();
			}
		}
	}
	public class TrackedHazeData : TrackedObjectData
	{
		public TrackedHaze physicalHaze;

		public Vector3 previousPos;

		public Vector3 position;

		public Quaternion previousRot;

		public Quaternion rotation;

		public float previousKEBattery;

		public float KEBattery;

		public TrackedHazeData()
		{
		}

		public TrackedHazeData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			KEBattery = packet.ReadFloat();
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<Construct_Haze>() != (Object)null;
		}

		private static TrackedHaze MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedHaze trackedHaze = ((Component)root).gameObject.AddComponent<TrackedHaze>();
			TrackedHazeData trackedHazeData = (TrackedHazeData)(trackedHaze.data = (trackedHaze.hazeData = new TrackedHazeData()));
			trackedHazeData.physicalHaze = trackedHaze;
			trackedHazeData.physical = trackedHaze;
			Construct_Haze component = ((Component)root).GetComponent<Construct_Haze>();
			trackedHazeData.physicalHaze.physicalHaze = component;
			trackedHazeData.physical.physical = (MonoBehaviour)(object)component;
			trackedHazeData.typeIdentifier = "TrackedHazeData";
			trackedHazeData.active = ((Component)trackedHaze).gameObject.activeInHierarchy;
			trackedHazeData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedHazeData.instance = GameManager.instance;
			trackedHazeData.controller = GameManager.ID;
			trackedHazeData.initTracker = GameManager.ID;
			trackedHazeData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedHazeByHaze.Add(trackedHaze.physicalHaze, trackedHaze);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedHaze.physicalHaze, trackedHaze);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)trackedHaze.physicalHaze, trackedHaze);
			trackedHazeData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedHazeData);
			if (trackedHaze.awoken)
			{
				trackedHaze.data.Update(full: true);
			}
			Mod.LogInfo("Made haze " + ((Object)trackedHaze).name + " tracked", debug: false);
			return trackedHaze;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
			packet.Write(KEBattery);
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating haze at " + trackedID, debug: false);
			Construct_Haze_Volume hazeVolume = Object.FindObjectOfType<Construct_Haze_Volume>();
			if ((Object)(object)hazeVolume == (Object)null)
			{
				Mod.LogError("Failed to instantiate haze: " + trackedID + ": Could not find suitable haze volume to get prefab from");
				yield break;
			}
			GameObject prefab = hazeVolume.Haze_Prefab;
			Mod.skipAllInstantiates++;
			GameObject hazeInstance = Object.Instantiate<GameObject>(prefab, position, rotation);
			Mod.skipAllInstantiates--;
			physicalHaze = hazeInstance.AddComponent<TrackedHaze>();
			physical = physicalHaze;
			physicalHaze.physicalHaze = hazeInstance.GetComponent<Construct_Haze>();
			physical.physical = (MonoBehaviour)(object)physicalHaze.physicalHaze;
			awaitingInstantiation = false;
			physicalHaze.hazeData = this;
			physicalHaze.data = this;
			GameManager.trackedHazeByHaze.Add(physicalHaze.physicalHaze, physicalHaze);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalHaze.physicalHaze, physicalHaze);
			GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)physicalHaze.physicalHaze, physicalHaze);
			if (base.controller != GameManager.ID)
			{
				if ((Object)(object)GM.CurrentAIManager != (Object)null)
				{
					GM.CurrentAIManager.DeRegisterAIEntity(physicalHaze.physicalHaze.E);
				}
				physicalHaze.physicalHaze.RB.isKinematic = true;
			}
			UpdateFromData(this);
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedHazeData trackedHazeData = updatedObject as TrackedHazeData;
			previousPos = position;
			position = trackedHazeData.position;
			previousRot = rotation;
			rotation = trackedHazeData.rotation;
			previousKEBattery = KEBattery;
			KEBattery = trackedHazeData.KEBattery;
			if ((Object)(object)physicalHaze != (Object)null)
			{
				((Component)physicalHaze.physicalHaze).transform.position = position;
				((Component)physicalHaze.physicalHaze).transform.rotation = rotation;
				physicalHaze.physicalHaze.KEBattery = KEBattery;
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			previousPos = position;
			position = packet.ReadVector3();
			previousRot = rotation;
			rotation = packet.ReadQuaternion();
			previousKEBattery = KEBattery;
			KEBattery = packet.ReadFloat();
			if ((Object)(object)physicalHaze != (Object)null)
			{
				((Component)physicalHaze.physicalHaze).transform.position = position;
				((Component)physicalHaze.physicalHaze).transform.rotation = rotation;
				physicalHaze.physicalHaze.KEBattery = KEBattery;
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			bool flag = base.Update(full);
			if ((Object)(object)physicalHaze == (Object)null)
			{
				return false;
			}
			previousPos = position;
			previousRot = rotation;
			position = ((Component)physicalHaze.physicalHaze).transform.position;
			rotation = ((Component)physicalHaze.physicalHaze).transform.rotation;
			previousKEBattery = KEBattery;
			KEBattery = physicalHaze.physicalHaze.KEBattery;
			int result;
			if (!flag)
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2))
					{
						result = ((KEBattery != previousKEBattery) ? 1 : 0);
						goto IL_00e4;
					}
				}
			}
			result = 1;
			goto IL_00e4;
			IL_00e4:
			return (byte)result != 0;
		}

		public override void OnControlChanged(int newController)
		{
			base.OnControlChanged(newController);
			if (newController == GameManager.ID)
			{
				if ((Object)(object)physicalHaze != (Object)null && (Object)(object)physicalHaze.physicalHaze != (Object)null)
				{
					if ((Object)(object)GM.CurrentAIManager != (Object)null)
					{
						GM.CurrentAIManager.RegisterAIEntity(physicalHaze.physicalHaze.E);
					}
					physicalHaze.physicalHaze.RB.isKinematic = false;
				}
			}
			else if (base.controller == GameManager.ID && (Object)(object)physicalHaze != (Object)null && (Object)(object)physicalHaze.physicalHaze != (Object)null)
			{
				if ((Object)(object)GM.CurrentAIManager != (Object)null)
				{
					GM.CurrentAIManager.DeRegisterAIEntity(physicalHaze.physicalHaze.E);
				}
				physicalHaze.physicalHaze.RB.isKinematic = true;
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalHaze != (Object)null && (Object)(object)physicalHaze.physicalHaze != (Object)null)
			{
				GameManager.trackedHazeByHaze.Remove(physicalHaze.physicalHaze);
				GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalHaze.physicalHaze);
			}
		}
	}
	public class TrackedIris : TrackedObject
	{
		public Construct_Iris physicalIris;

		public TrackedIrisData irisData;

		public static Dictionary<uint, List<object[]>> unknownIrisShatter = new Dictionary<uint, List<object[]>>();

		public static Dictionary<uint, IrisState> unknownIrisSetState = new Dictionary<uint, IrisState>();

		public override void Awake()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			base.Awake();
			CheckReferenceSize();
			int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
			TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
			TrackedObject.trackedReferences[num] = this;
			BParamType val = new BParamType();
			val.Mats = new List<MatBallisticType>();
			val.Pen = num;
			((Component)this).GetComponent<Construct_Iris>().BParams.Add(val);
		}

		public override bool HandleShatter(UberShatterable shatterable, Vector3 point, Vector3 dir, float intensity, bool received, int clientID, byte[] data)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			if (received)
			{
				UberShatterableShatterPatch.skip++;
				physicalIris.Rings[data[0]].Shatter(point, dir, intensity);
				UberShatterableShatterPatch.skip--;
				if (ThreadManager.host)
				{
					ServerSend.UberShatterableShatter(irisData.trackedID, point, dir, intensity, data, clientID);
				}
			}
			else
			{
				int num = -1;
				for (int i = 0; i < physicalIris.Rings.Count; i++)
				{
					if ((Object)(object)physicalIris.Rings[i] == (Object)(object)shatterable)
					{
						num = i;
						break;
					}
				}
				if (num > -1)
				{
					data = new byte[1] { (byte)num };
					if (ThreadManager.host)
					{
						ServerSend.UberShatterableShatter(irisData.trackedID, point, dir, intensity, data);
					}
					else if (irisData.trackedID != -1)
					{
						ClientSend.UberShatterableShatter(irisData.trackedID, point, dir, intensity, data);
					}
				}
				else
				{
					Mod.LogError("Iris HandleShatter, could not find shatterable in rings");
				}
			}
			return true;
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedIrisByIris.Remove(physicalIris);
				for (int i = 0; i < physicalIris.Rings.Count; i++)
				{
					GameManager.trackedObjectByShatterable.Remove(physicalIris.Rings[i]);
				}
				base.OnDestroy();
			}
		}
	}
	public class TrackedIrisData : TrackedObjectData
	{
		public TrackedIris physicalIris;

		public Vector3[] previousPositions;

		public Vector3[] positions;

		public Vector3[] previousAngles;

		public Vector3[] angles;

		public Vector3[] previousScales;

		public Vector3[] scales;

		public bool[] shattered;

		public IrisState state;

		public TrackedIrisData()
		{
		}

		public TrackedIrisData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			state = (IrisState)packet.ReadByte();
			int num = packet.ReadByte();
			shattered = new bool[num];
			previousPositions = (Vector3[])(object)new Vector3[num];
			previousAngles = (Vector3[])(object)new Vector3[num];
			previousScales = (Vector3[])(object)new Vector3[num];
			positions = (Vector3[])(object)new Vector3[num];
			angles = (Vector3[])(object)new Vector3[num];
			scales = (Vector3[])(object)new Vector3[num];
			for (int i = 0; i < positions.Length; i++)
			{
				positions[i] = packet.ReadVector3();
				angles[i] = packet.ReadVector3();
				scales[i] = packet.ReadVector3();
			}
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<Construct_Iris>() != (Object)null;
		}

		private static TrackedIris MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedIris trackedIris = ((Component)root).gameObject.AddComponent<TrackedIris>();
			TrackedIrisData trackedIrisData = (TrackedIrisData)(trackedIris.data = (trackedIris.irisData = new TrackedIrisData()));
			trackedIrisData.physicalIris = trackedIris;
			trackedIrisData.physical = trackedIris;
			Construct_Iris component = ((Component)root).GetComponent<Construct_Iris>();
			trackedIrisData.physicalIris.physicalIris = component;
			trackedIrisData.physical.physical = (MonoBehaviour)(object)component;
			trackedIrisData.typeIdentifier = "TrackedIrisData";
			trackedIrisData.active = ((Component)trackedIris).gameObject.activeInHierarchy;
			trackedIrisData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedIrisData.instance = GameManager.instance;
			trackedIrisData.controller = GameManager.ID;
			trackedIrisData.initTracker = GameManager.ID;
			trackedIrisData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedIrisByIris.Add(trackedIris.physicalIris, trackedIris);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedIris.physicalIris, trackedIris);
			for (int i = 0; i < trackedIris.physicalIris.Rings.Count; i++)
			{
				GameManager.trackedObjectByShatterable.Add(trackedIris.physicalIris.Rings[i], trackedIris);
			}
			trackedIrisData.shattered = new bool[component.Rings.Count];
			trackedIrisData.previousPositions = (Vector3[])(object)new Vector3[component.Rings.Count];
			trackedIrisData.positions = (Vector3[])(object)new Vector3[component.Rings.Count];
			trackedIrisData.previousAngles = (Vector3[])(object)new Vector3[component.Rings.Count];
			trackedIrisData.angles = (Vector3[])(object)new Vector3[component.Rings.Count];
			trackedIrisData.previousScales = (Vector3[])(object)new Vector3[component.Rings.Count];
			trackedIrisData.scales = (Vector3[])(object)new Vector3[component.Rings.Count];
			trackedIrisData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedIrisData);
			if (trackedIris.awoken)
			{
				trackedIris.data.Update(full: true);
			}
			Mod.LogInfo("Made iris " + ((Object)trackedIris).name + " tracked", debug: false);
			return trackedIris;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			if (full)
			{
				packet.Write((byte)state);
			}
			packet.Write((byte)positions.Length);
			for (int i = 0; i < positions.Length; i++)
			{
				if (full)
				{
					packet.Write(shattered[i]);
				}
				packet.Write(positions[i]);
				packet.Write(angles[i]);
				packet.Write(scales[i]);
			}
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating iris at " + trackedID, debug: false);
			Construct_Iris_Volume irisVolume = Object.FindObjectOfType<Construct_Iris_Volume>();
			GameObject prefab;
			if ((Object)(object)irisVolume == (Object)null)
			{
				SosigSpawner sosigSpawner = Object.FindObjectOfType<SosigSpawner>();
				if (!((Object)(object)sosigSpawner != (Object)null))
				{
					Mod.LogError("Failed to instantiate iris: " + trackedID + ": Could not find suitable iris volume or sosig spawner to get prefab from");
					yield break;
				}
				prefab = sosigSpawner.SpawnerGroups[19].Furnitures[2];
			}
			else
			{
				prefab = irisVolume.Iris_Prefab;
			}
			Mod.skipAllInstantiates++;
			GameObject irisInstance = Object.Instantiate<GameObject>(prefab, positions[0], Quaternion.Euler(angles[0]));
			Mod.skipAllInstantiates--;
			physicalIris = irisInstance.AddComponent<TrackedIris>();
			physical = physicalIris;
			physicalIris.physicalIris = irisInstance.GetComponent<Construct_Iris>();
			physical.physical = (MonoBehaviour)(object)physicalIris.physicalIris;
			awaitingInstantiation = false;
			physicalIris.irisData = this;
			physicalIris.data = this;
			GameManager.trackedIrisByIris.Add(physicalIris.physicalIris, physicalIris);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalIris.physicalIris, physicalIris);
			int i = 0;
			while (i < physicalIris.physicalIris.Rings.Count)
			{
				GameManager.trackedObjectByShatterable.Add(physicalIris.physicalIris.Rings[i], physicalIris);
				int num = i + 1;
				i = num;
			}
			UpdateFromData(this, full: true);
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedIrisData trackedIrisData = updatedObject as TrackedIrisData;
			if (full)
			{
				state = trackedIrisData.state;
				for (int i = 0; i < shattered.Length; i++)
				{
					shattered[i] = trackedIrisData.shattered[i];
				}
			}
			for (int j = 0; j < positions.Length; j++)
			{
				previousPositions[j] = positions[j];
				previousAngles[j] = angles[j];
				previousScales[j] = scales[j];
				positions[j] = trackedIrisData.positions[j];
				angles[j] = trackedIrisData.angles[j];
				scales[j] = trackedIrisData.scales[j];
			}
			if (!((Object)(object)physicalIris != (Object)null))
			{
				return;
			}
			if (full)
			{
				physicalIris.physicalIris.SetState(state);
				for (int k = 0; k < shattered.Length; k++)
				{
					if ((Object)(object)physicalIris.physicalIris.Rings[k] != (Object)null && shattered[k] && !physicalIris.physicalIris.Rings[k].HasShattered())
					{
						UberShatterableShatterPatch.skip++;
						physicalIris.physicalIris.Rings[k].Shatter(positions[k], Vector3.zero, 0f);
						UberShatterableShatterPatch.skip--;
					}
				}
			}
			((Component)physicalIris.physicalIris).transform.position = positions[0];
			for (int l = 0; l < positions.Length; l++)
			{
				if ((Object)(object)physicalIris.physicalIris.Rings[l] != (Object)null && ((Component)physicalIris.physicalIris.Rings[l]).gameObject.activeSelf)
				{
					((Component)physicalIris.physicalIris.Rings[l]).transform.position = positions[l];
					((Component)physicalIris.physicalIris.Rings[l]).transform.rotation = Quaternion.Euler(angles[l]);
					((Component)physicalIris.physicalIris.Rings[l]).transform.localScale = scales[l];
					((Component)physicalIris.physicalIris.RefPoints[l]).transform.position = positions[l];
					((Component)physicalIris.physicalIris.RefPoints[l]).transform.rotation = Quaternion.Euler(angles[l]);
					((Component)physicalIris.physicalIris.RefPoints[l]).transform.localScale = scales[l];
				}
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			if (full)
			{
				state = (IrisState)packet.ReadByte();
			}
			packet.ReadByte();
			for (int i = 0; i < positions.Length; i++)
			{
				previousPositions[i] = positions[i];
				previousAngles[i] = angles[i];
				previousScales[i] = scales[i];
				if (full)
				{
					shattered[i] = packet.ReadBool();
				}
				positions[i] = packet.ReadVector3();
				angles[i] = packet.ReadVector3();
				scales[i] = packet.ReadVector3();
			}
			if (!((Object)(object)physicalIris != (Object)null))
			{
				return;
			}
			if (full)
			{
				physicalIris.physicalIris.SetState(state);
				for (int j = 0; j < shattered.Length; j++)
				{
					if ((Object)(object)physicalIris.physicalIris.Rings[j] != (Object)null && shattered[j] && !physicalIris.physicalIris.Rings[j].HasShattered())
					{
						UberShatterableShatterPatch.skip++;
						physicalIris.physicalIris.Rings[j].Shatter(positions[j], Vector3.zero, 0f);
						UberShatterableShatterPatch.skip--;
					}
				}
			}
			((Component)physicalIris.physicalIris).transform.position = positions[0];
			for (int k = 0; k < positions.Length; k++)
			{
				if ((Object)(object)physicalIris.physicalIris.Rings[k] != (Object)null && ((Component)physicalIris.physicalIris.Rings[k]).gameObject.activeSelf)
				{
					((Component)physicalIris.physicalIris.Rings[k]).transform.position = positions[k];
					((Component)physicalIris.physicalIris.Rings[k]).transform.rotation = Quaternion.Euler(angles[k]);
					((Component)physicalIris.physicalIris.Rings[k]).transform.localScale = scales[k];
					((Component)physicalIris.physicalIris.RefPoints[k]).transform.position = positions[k];
					((Component)physicalIris.physicalIris.RefPoints[k]).transform.rotation = Quaternion.Euler(angles[k]);
					((Component)physicalIris.physicalIris.RefPoints[k]).transform.localScale = scales[k];
				}
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = base.Update(full);
			if ((Object)(object)physicalIris == (Object)null)
			{
				return false;
			}
			if (full)
			{
				state = physicalIris.physicalIris.IState;
				for (int i = 0; i < shattered.Length; i++)
				{
					shattered[i] = (Object)(object)physicalIris.physicalIris.Rings[i] == (Object)null || physicalIris.physicalIris.Rings[i].HasShattered();
				}
			}
			bool num2;
			int num3;
			for (int j = 0; j < positions.Length; flag = (byte)((num2 ? 1u : 0u) | (uint)num3) != 0, j++)
			{
				previousPositions[j] = positions[j];
				previousAngles[j] = angles[j];
				previousScales[j] = scales[j];
				if ((Object)(object)physicalIris.physicalIris.Rings[j] != (Object)null && ((Component)physicalIris.physicalIris.Rings[j]).gameObject.activeSelf)
				{
					positions[j] = ((Component)physicalIris.physicalIris.Rings[j]).transform.position;
					Vector3[] array = angles;
					int num = j;
					Quaternion rotation = ((Component)physicalIris.physicalIris.Rings[j]).transform.rotation;
					array[num] = ((Quaternion)(ref rotation)).eulerAngles;
					scales[j] = ((Component)physicalIris.physicalIris.Rings[j]).transform.localScale;
				}
				num2 = flag;
				ref Vector3 reference = ref previousPositions[j];
				object obj = positions[j];
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Vector3 reference2 = ref previousAngles[j];
					object obj2 = angles[j];
					if (((object)Unsafe.As<Vector3, Vector3>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2))
					{
						ref Vector3 reference3 = ref previousScales[j];
						object obj3 = scales[j];
						num3 = ((!((object)Unsafe.As<Vector3, Vector3>(ref reference3)/*cast due to .constrained prefix*/).Equals(obj3)) ? 1 : 0);
						continue;
					}
				}
				num3 = 1;
			}
			return flag;
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			base.OnTrackedIDReceived(newData);
			if (localTrackedID != -1 && TrackedIris.unknownIrisShatter.TryGetValue(localWaitingIndex, out var value))
			{
				for (int i = 0; i < value.Count; i++)
				{
					ClientSend.IrisShatter(trackedID, (byte)value[i][0], (Vector3)value[i][1], (Vector3)value[i][2], (float)value[i][3]);
				}
				TrackedIris.unknownIrisShatter.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedIris.unknownIrisSetState.TryGetValue(localWaitingIndex, out var value2))
			{
				ClientSend.IrisSetState(trackedID, value2);
				TrackedIris.unknownIrisSetState.Remove(localWaitingIndex);
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalIris != (Object)null && (Object)(object)physicalIris.physicalIris != (Object)null)
			{
				GameManager.trackedIrisByIris.Remove(physicalIris.physicalIris);
				GameManager.trackedObjectByShatterable.Remove(((Component)physicalIris.physicalIris).GetComponentInChildren<UberShatterable>());
				for (int i = 0; i < physicalIris.physicalIris.Rings.Count; i++)
				{
					GameManager.trackedObjectByShatterable.Remove(physicalIris.physicalIris.Rings[i]);
				}
			}
		}
	}
	public class TrackedItem : TrackedObject
	{
		public delegate bool UpdateData();

		public delegate bool UpdateDataWithGiven(byte[] newData);

		public delegate bool FireFirearm(int chamberIndex);

		public delegate void FirearmUpdateOverrideSetter(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex);

		public delegate bool FireSosigGun(float recoilMult);

		public delegate void FireAttachableFirearm(bool firedFromInterface);

		public delegate void FireAttachableFirearmChamberRound(FireArmRoundType roundType, FireArmRoundClass roundClass);

		public delegate FVRFireArmChamber FireAttachableFirearmGetChamber();

		public delegate void UpdateParent();

		public delegate void UpdateAttachmentInterface(FVRFireArmAttachment att, ref bool modified);

		public delegate void UpdateAttachmentInterfaceWithGiven(FVRFireArmAttachment att, byte[] newData, ref bool modified);

		public delegate int GetChamberIndex(FVRFireArmChamber chamber);

		public delegate void ChamberRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex);

		public delegate void RemoveTrackedDamageables();

		public delegate int FindSecondary(object secondary);

		public delegate object GetSecondary(int index);

		public delegate void ParentChanged();

		public delegate void OnDestruction();

		public delegate bool HandleShatterSpecific(UberShatterable shatterable, Vector3 point, Vector3 dir, float intensity, bool received, int clientID, byte[] data);

		public delegate void OnInitItemTypeDelegate(TrackedItem trackedItem, FVRPhysicalObject physObj, ref bool found);

		public delegate void AddModulPartDataDelegate(List<byte> buffer, string groupID, string selectedPart, IDictionary pointDict, TrackedItem trackedItem);

		public delegate void ReadModulPartDataDelegate(byte[] additionalData, int offset, string groupID, IDictionary pointDict, TrackedItem trackedItem);

		public delegate void PreConfigureModulPartDataDelegate(byte[] additionalData, int offset, string groupID, IDictionary pointDict, TrackedItem trackedItem);

		public TrackedItemData itemData;

		public FVRPhysicalObject physicalItem;

		public static float interpolationSpeed = 12f;

		public static bool interpolated = true;

		public int securedCode = -1;

		public static Dictionary<uint, byte> unknownCrateHolding = new Dictionary<uint, byte>();

		public static Dictionary<SosigWeapon, KeyValuePair<TrackedSosigData, int>> unknownSosigInventoryObjects = new Dictionary<SosigWeapon, KeyValuePair<TrackedSosigData, int>>();

		public static Dictionary<uint, KeyValuePair<TrackedSosigData, int>> unknownSosigInventoryItems = new Dictionary<uint, KeyValuePair<TrackedSosigData, int>>();

		public static Dictionary<uint, List<KeyValuePair<Vector3, Vector3>>> unknownGasCuboidGout = new Dictionary<uint, List<KeyValuePair<Vector3, Vector3>>>();

		public static List<uint> unknownGasCuboidDamageHandle = new List<uint>();

		public UpdateData updateFunc;

		public UpdateDataWithGiven updateGivenFunc;

		public FireFirearm fireFunc;

		public FirearmUpdateOverrideSetter setFirearmUpdateOverride;

		public FireAttachableFirearm attachableFirearmFireFunc;

		public FireAttachableFirearmChamberRound attachableFirearmChamberRoundFunc;

		public FireAttachableFirearmGetChamber attachableFirearmGetChamberFunc;

		public FireSosigGun sosigWeaponfireFunc;

		public UpdateParent updateParentFunc;

		public UpdateAttachmentInterface attachmentInterfaceUpdateFunc;

		public UpdateAttachmentInterfaceWithGiven attachmentInterfaceUpdateGivenFunc;

		public GetChamberIndex getChamberIndex;

		public ChamberRound chamberRound;

		public RemoveTrackedDamageables removeTrackedDamageables;

		public FindSecondary findSecondary;

		public GetSecondary getSecondary;

		public ParentChanged parentChanged;

		public OnDestruction onDestruction;

		public HandleShatterSpecific handleShatterSpecific;

		public object[] secondaries;

		public byte currentMountIndex = byte.MaxValue;

		public int mountObjectID;

		public Vector3 mountObjectScale;

		public Object dataObject;

		public int attachmentInterfaceDataSize;

		private bool positionSet;

		private bool rotationSet;

		public StingerMissile stingerMissile;

		public LAPD2019Laser integratedLaser;

		public bool usesAutoToggle;

		public static Dictionary<int, List<TrackedItem>> toAttachByMountObjectID = new Dictionary<int, List<TrackedItem>>();

		public static event OnInitItemTypeDelegate OnInitItemType;

		public static event AddModulPartDataDelegate AddModulPartData;

		public static event ReadModulPartDataDelegate ReadModulPartData;

		public static event PreConfigureModulPartDataDelegate PreConfigureModulPartData;

		public override void Awake()
		{
			GameManager.OnPlayerBodyInit += OnPlayerBodyInit;
			InitItemType();
			base.Awake();
			GameManager.OnSceneLeft += OnSceneLeft;
			GameManager.OnSceneJoined += OnSceneJoined;
			GameManager.OnInstanceJoined += OnInstanceJoined;
		}

		private void InitItemType()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_15b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b9: Expected O, but got Unknown
			//IL_1672: Unknown result type (might be due to invalid IL or missing references)
			//IL_1679: Expected O, but got Unknown
			//IL_16df: Unknown result type (might be due to invalid IL or missing references)
			//IL_16e6: Expected O, but got Unknown
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Expected O, but got Unknown
			//IL_17d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_17da: Expected O, but got Unknown
			//IL_1730: Unknown result type (might be due to invalid IL or missing references)
			//IL_1737: Expected O, but got Unknown
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Expected O, but got Unknown
			//IL_18b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_18b9: Expected O, but got Unknown
			//IL_1879: Unknown result type (might be due to invalid IL or missing references)
			//IL_1880: Expected O, but got Unknown
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Expected O, but got Unknown
			//IL_18fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_1903: Expected O, but got Unknown
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Expected O, but got Unknown
			//IL_1946: Unknown result type (might be due to invalid IL or missing references)
			//IL_194d: Expected O, but got Unknown
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Expected O, but got Unknown
			//IL_0724: Unknown result type (might be due to invalid IL or missing references)
			//IL_072b: Expected O, but got Unknown
			//IL_19f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a00: Expected O, but got Unknown
			//IL_0793: Unknown result type (might be due to invalid IL or missing references)
			//IL_079a: Expected O, but got Unknown
			//IL_1d8b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1d92: Expected O, but got Unknown
			//IL_0802: Unknown result type (might be due to invalid IL or missing references)
			//IL_0809: Expected O, but got Unknown
			//IL_1dfc: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e03: Expected O, but got Unknown
			//IL_0874: Unknown result type (might be due to invalid IL or missing references)
			//IL_087b: Expected O, but got Unknown
			//IL_206e: Unknown result type (might be due to invalid IL or missing references)
			//IL_2075: Expected O, but got Unknown
			//IL_2107: Unknown result type (might be due to invalid IL or missing references)
			//IL_210e: Expected O, but got Unknown
			//IL_0972: Unknown result type (might be due to invalid IL or missing references)
			//IL_0979: Expected O, but got Unknown
			//IL_09e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09eb: Expected O, but got Unknown
			//IL_2240: Unknown result type (might be due to invalid IL or missing references)
			//IL_2247: Expected O, but got Unknown
			//IL_0b02: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b09: Expected O, but got Unknown
			//IL_0c7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c84: Expected O, but got Unknown
			FVRPhysicalObject component = ((Component)this).GetComponent<FVRPhysicalObject>();
			bool found = false;
			if (TrackedItem.OnInitItemType != null)
			{
				TrackedItem.OnInitItemType(this, component, ref found);
			}
			if (found)
			{
				return;
			}
			if (component is sblpCell)
			{
				updateFunc = UpdateSBLPCell;
				updateGivenFunc = UpdateGivenSBLPCell;
				dataObject = (Object)(object)((component is sblpCell) ? component : null);
			}
			else if (component is MinigunBox)
			{
				updateFunc = UpdateMinigunBox;
				updateGivenFunc = UpdateGivenMinigunBox;
				dataObject = (Object)(object)((component is MinigunBox) ? component : null);
			}
			else if (component is FVRFireArmRound)
			{
				FVRFireArmRound key = (FVRFireArmRound)(object)(dataObject = (Object)(FVRFireArmRound)component);
				updateFunc = UpdateRound;
				updateGivenFunc = UpdateGivenRound;
				GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)key, this);
				removeTrackedDamageables = RemoveTrackedCommonDamageables;
			}
			else if (component is FVRFireArmMagazine)
			{
				updateFunc = UpdateMagazine;
				updateGivenFunc = UpdateGivenMagazine;
				dataObject = (Object)(object)((component is FVRFireArmMagazine) ? component : null);
			}
			else if (component is FVRFireArmClip)
			{
				updateFunc = UpdateClip;
				updateGivenFunc = UpdateGivenClip;
				dataObject = (Object)(object)((component is FVRFireArmClip) ? component : null);
			}
			else if (component is Speedloader)
			{
				updateFunc = UpdateSpeedloader;
				updateGivenFunc = UpdateGivenSpeedloader;
				dataObject = (Object)(object)((component is Speedloader) ? component : null);
			}
			else if (component is FVRFireArm)
			{
				FVRFireArm val = (FVRFireArm)(object)((component is FVRFireArm) ? component : null);
				if ((Object)(object)val.GetIntegratedAttachableFirearm() != (Object)null)
				{
					if (val.GetIntegratedAttachableFirearm() is AttachableBreakActions)
					{
						ref FireAttachableFirearm reference = ref attachableFirearmFireFunc;
						AttachableFirearm integratedAttachableFirearm = val.GetIntegratedAttachableFirearm();
						reference = ((AttachableBreakActions)((integratedAttachableFirearm is AttachableBreakActions) ? integratedAttachableFirearm : null)).Fire;
						attachableFirearmChamberRoundFunc = AttachableBreakActionsChamberRound;
						attachableFirearmGetChamberFunc = AttachableBreakActionsGetChamber;
					}
					else if (val.GetIntegratedAttachableFirearm() is AttachableClosedBoltWeapon)
					{
						ref FireAttachableFirearm reference2 = ref attachableFirearmFireFunc;
						AttachableFirearm integratedAttachableFirearm2 = val.GetIntegratedAttachableFirearm();
						reference2 = ((AttachableClosedBoltWeapon)((integratedAttachableFirearm2 is AttachableClosedBoltWeapon) ? integratedAttachableFirearm2 : null)).Fire;
						attachableFirearmChamberRoundFunc = AttachableClosedBoltWeaponChamberRound;
						attachableFirearmGetChamberFunc = AttachableClosedBoltWeaponGetChamber;
					}
					else if (val.GetIntegratedAttachableFirearm() is AttachableTubeFed)
					{
						ref FireAttachableFirearm reference3 = ref attachableFirearmFireFunc;
						AttachableFirearm integratedAttachableFirearm3 = val.GetIntegratedAttachableFirearm();
						reference3 = ((AttachableTubeFed)((integratedAttachableFirearm3 is AttachableTubeFed) ? integratedAttachableFirearm3 : null)).Fire;
						attachableFirearmChamberRoundFunc = AttachableTubeFedChamberRound;
						attachableFirearmGetChamberFunc = AttachableTubeFedGetChamber;
					}
					else if (val.GetIntegratedAttachableFirearm() is GP25)
					{
						ref FireAttachableFirearm reference4 = ref attachableFirearmFireFunc;
						AttachableFirearm integratedAttachableFirearm4 = val.GetIntegratedAttachableFirearm();
						reference4 = ((GP25)((integratedAttachableFirearm4 is GP25) ? integratedAttachableFirearm4 : null)).Fire;
						attachableFirearmChamberRoundFunc = GP25ChamberRound;
						attachableFirearmGetChamberFunc = GP25GetChamber;
					}
					else if (val.GetIntegratedAttachableFirearm() is M203)
					{
						ref FireAttachableFirearm reference5 = ref attachableFirearmFireFunc;
						AttachableFirearm integratedAttachableFirearm5 = val.GetIntegratedAttachableFirearm();
						reference5 = ((M203)((integratedAttachableFirearm5 is M203) ? integratedAttachableFirearm5 : null)).Fire;
						attachableFirearmChamberRoundFunc = M203ChamberRound;
						attachableFirearmGetChamberFunc = M203GetChamber;
					}
				}
				LAPD2019Laser componentInChildren = ((Component)val).GetComponentInChildren<LAPD2019Laser>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					integratedLaser = componentInChildren;
					usesAutoToggle = componentInChildren.UsesAutoOnOff;
				}
				if (val is ClosedBoltWeapon)
				{
					ClosedBoltWeapon val2 = (ClosedBoltWeapon)component;
					updateFunc = UpdateClosedBoltWeapon;
					updateGivenFunc = UpdateGivenClosedBoltWeapon;
					dataObject = (Object)(object)val2;
					fireFunc = FireCBW;
					setFirearmUpdateOverride = SetCBWUpdateOverride;
					getChamberIndex = GetClosedBoltWeaponChamberIndex;
					chamberRound = ChamberClosedBoltWeaponRound;
				}
				else if (val is OpenBoltReceiver)
				{
					OpenBoltReceiver val3 = (OpenBoltReceiver)component;
					updateFunc = UpdateOpenBoltReceiver;
					updateGivenFunc = UpdateGivenOpenBoltReceiver;
					dataObject = (Object)(object)val3;
					fireFunc = FireOBR;
					setFirearmUpdateOverride = SetOBRUpdateOverride;
					getChamberIndex = GetOpenBoltReceiverChamberIndex;
					chamberRound = ChamberOpenBoltReceiverRound;
				}
				else if (val is BoltActionRifle)
				{
					BoltActionRifle val4 = (BoltActionRifle)component;
					updateFunc = UpdateBoltActionRifle;
					updateGivenFunc = UpdateGivenBoltActionRifle;
					dataObject = (Object)(object)val4;
					fireFunc = FireBAR;
					setFirearmUpdateOverride = SetBARUpdateOverride;
					getChamberIndex = GetBoltActionRifleChamberIndex;
					chamberRound = ChamberBoltActionRifleRound;
				}
				else if (val is Handgun)
				{
					Handgun val5 = (Handgun)component;
					updateFunc = UpdateHandgun;
					updateGivenFunc = UpdateGivenHandgun;
					dataObject = (Object)(object)val5;
					fireFunc = FireHandgun;
					setFirearmUpdateOverride = SetHandgunUpdateOverride;
					getChamberIndex = GetHandgunChamberIndex;
					chamberRound = ChamberHandgunRound;
				}
				else if (val is TubeFedShotgun)
				{
					TubeFedShotgun val6 = (TubeFedShotgun)component;
					updateFunc = UpdateTubeFedShotgun;
					updateGivenFunc = UpdateGivenTubeFedShotgun;
					dataObject = (Object)(object)val6;
					fireFunc = FireTFS;
					setFirearmUpdateOverride = SetTFSUpdateOverride;
					getChamberIndex = GetTubeFedShotgunChamberIndex;
					chamberRound = ChamberTubeFedShotgunRound;
				}
				else if (val is Revolver)
				{
					Revolver val7 = (Revolver)component;
					updateFunc = UpdateRevolver;
					updateGivenFunc = UpdateGivenRevolver;
					dataObject = (Object)(object)val7;
					getChamberIndex = GetRevolverChamberIndex;
					chamberRound = ChamberRevolverRound;
				}
				else if (val is SingleActionRevolver)
				{
					SingleActionRevolver val8 = (SingleActionRevolver)component;
					updateFunc = UpdateSingleActionRevolver;
					updateGivenFunc = UpdateGivenSingleActionRevolver;
					dataObject = (Object)(object)val8;
					getChamberIndex = GetSingleActionRevolverChamberIndex;
					chamberRound = ChamberSingleActionRevolverRound;
				}
				else if (val is RevolvingShotgun)
				{
					RevolvingShotgun val9 = (RevolvingShotgun)component;
					updateFunc = UpdateRevolvingShotgun;
					updateGivenFunc = UpdateGivenRevolvingShotgun;
					dataObject = (Object)(object)val9;
					getChamberIndex = GetRevolvingShotgunChamberIndex;
					chamberRound = ChamberRevolvingShotgunRound;
				}
				else if (val is BAP)
				{
					BAP val10 = (BAP)component;
					updateFunc = UpdateBAP;
					updateGivenFunc = UpdateGivenBAP;
					dataObject = (Object)(object)val10;
					fireFunc = FireBAP;
					setFirearmUpdateOverride = SetBAPUpdateOverride;
					getChamberIndex = GetBAPChamberIndex;
					chamberRound = ChamberBAPRound;
				}
				else if (val is BreakActionWeapon)
				{
					updateFunc = UpdateBreakActionWeapon;
					updateGivenFunc = UpdateGivenBreakActionWeapon;
					dataObject = (Object)(object)((component is BreakActionWeapon) ? component : null);
					getChamberIndex = GetBreakActionWeaponChamberIndex;
					chamberRound = ChamberBreakActionWeaponRound;
				}
				else if (val is LeverActionFirearm)
				{
					LeverActionFirearm val11 = (LeverActionFirearm)component;
					updateFunc = UpdateLeverActionFirearm;
					updateGivenFunc = UpdateGivenLeverActionFirearm;
					dataObject = (Object)(object)val11;
					getChamberIndex = GetLeverActionFirearmChamberIndex;
					chamberRound = ChamberLeverActionFirearmRound;
				}
				else if (val is CarlGustaf)
				{
					CarlGustaf val12 = (CarlGustaf)component;
					updateFunc = UpdateCarlGustaf;
					updateGivenFunc = UpdateGivenCarlGustaf;
					dataObject = (Object)(object)val12;
					fireFunc = FireCarlGustaf;
					setFirearmUpdateOverride = SetCarlGustafUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
					chamberRound = ChamberCarlGustafRound;
				}
				else if (val is Derringer)
				{
					updateFunc = UpdateDerringer;
					updateGivenFunc = UpdateGivenDerringer;
					dataObject = (Object)(object)((component is Derringer) ? component : null);
					getChamberIndex = GetDerringerChamberIndex;
				}
				else if (val is FlameThrower)
				{
					updateFunc = UpdateFlameThrower;
					updateGivenFunc = UpdateGivenFlameThrower;
					dataObject = (Object)(object)((component is FlameThrower) ? component : null);
					GameObject val13 = new GameObject();
					val13.transform.parent = ((Component)this).transform;
					TrackedObjectReference trackedObjectReference = val13.AddComponent<TrackedObjectReference>();
					val13.SetActive(false);
					CheckReferenceSize();
					int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
					TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
					TrackedObject.trackedReferenceObjects[num] = val13;
					TrackedObject.trackedReferences[num] = this;
					((Object)val13).name = num.ToString();
					trackedObjectReference.refIndex = num;
					val.BeltBoxMountPos = val13.transform;
				}
				else if (val is sblp)
				{
					updateFunc = UpdateLaserGun;
					updateGivenFunc = UpdateGivenLaserGun;
					dataObject = (Object)(object)((component is sblp) ? component : null);
				}
				else if (val is Flaregun)
				{
					Flaregun val14 = (Flaregun)(object)((component is Flaregun) ? component : null);
					updateFunc = UpdateFlaregun;
					updateGivenFunc = UpdateGivenFlaregun;
					dataObject = (Object)(object)val14;
					fireFunc = FireFlaregun;
					setFirearmUpdateOverride = SetFlaregunUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is Airgun)
				{
					Airgun val15 = (Airgun)component;
					updateFunc = UpdateAirgun;
					updateGivenFunc = UpdateGivenAirgun;
					dataObject = (Object)(object)val15;
					fireFunc = FireAirgun;
					setFirearmUpdateOverride = SetAirgunUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is FlintlockWeapon)
				{
					updateFunc = UpdateFlintlockWeapon;
					updateGivenFunc = UpdateGivenFlintlockWeapon;
					dataObject = (Object)(object)((Component)component).GetComponentInChildren<FlintlockBarrel>();
				}
				else if (val is GBeamer)
				{
					updateFunc = UpdateGBeamer;
					updateGivenFunc = UpdateGivenGBeamer;
					dataObject = (Object)(object)((component is GBeamer) ? component : null);
				}
				else if (val is GrappleGun)
				{
					updateFunc = UpdateGrappleGun;
					updateGivenFunc = UpdateGivenGrappleGun;
					dataObject = (Object)(object)((component is GrappleGun) ? component : null);
					getChamberIndex = GetGrappleGunChamberIndex;
				}
				else if (val is HCB)
				{
					updateFunc = UpdateHCB;
					updateGivenFunc = UpdateGivenHCB;
					dataObject = (Object)(object)((component is HCB) ? component : null);
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is M72)
				{
					M72 val16 = (M72)(object)((component is M72) ? component : null);
					updateFunc = UpdateM72;
					updateGivenFunc = UpdateGivenM72;
					dataObject = (Object)(object)val16;
					fireFunc = FireM72;
					setFirearmUpdateOverride = SetM72UpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is Minigun)
				{
					updateFunc = UpdateMinigun;
					updateGivenFunc = UpdateGivenMinigun;
					dataObject = (Object)(object)((component is Minigun) ? component : null);
				}
				else if (val is PotatoGun)
				{
					PotatoGun val17 = (PotatoGun)(object)((component is PotatoGun) ? component : null);
					updateFunc = UpdatePotatoGun;
					updateGivenFunc = UpdateGivenPotatoGun;
					dataObject = (Object)(object)val17;
					fireFunc = FirePotatoGun;
					setFirearmUpdateOverride = SetPotatoGunUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is RemoteMissileLauncher)
				{
					RemoteMissileLauncher val18 = (RemoteMissileLauncher)(object)((component is RemoteMissileLauncher) ? component : null);
					updateFunc = UpdateRemoteMissileLauncher;
					updateGivenFunc = UpdateGivenRemoteMissileLauncher;
					dataObject = (Object)(object)val18;
					fireFunc = FireRemoteMissileLauncher;
					setFirearmUpdateOverride = SetRemoteMissileLauncherUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is StingerLauncher)
				{
					updateFunc = UpdateStingerLauncher;
					updateGivenFunc = UpdateGivenStingerLauncher;
					dataObject = (Object)(object)((component is StingerLauncher) ? component : null);
				}
				else if (val is RGM40)
				{
					RGM40 val19 = (RGM40)(object)((component is RGM40) ? component : null);
					updateFunc = UpdateRGM40;
					updateGivenFunc = UpdateGivenRGM40;
					dataObject = (Object)(object)val19;
					fireFunc = FireRGM40;
					setFirearmUpdateOverride = SetRGM40UpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is RollingBlock)
				{
					RollingBlock val20 = (RollingBlock)(object)((component is RollingBlock) ? component : null);
					updateFunc = UpdateRollingBlock;
					updateGivenFunc = UpdateGivenRollingBlock;
					dataObject = (Object)(object)val20;
					fireFunc = FireRollingBlock;
					setFirearmUpdateOverride = SetRollingBlockUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is RPG7)
				{
					RPG7 val21 = (RPG7)(object)((component is RPG7) ? component : null);
					updateFunc = UpdateRPG7;
					updateGivenFunc = UpdateGivenRPG7;
					dataObject = (Object)(object)val21;
					fireFunc = FireRPG7;
					setFirearmUpdateOverride = SetRPG7UpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is SimpleLauncher)
				{
					SimpleLauncher val22 = (SimpleLauncher)(object)((component is SimpleLauncher) ? component : null);
					updateFunc = UpdateSimpleLauncher;
					updateGivenFunc = UpdateGivenSimpleLauncher;
					dataObject = (Object)(object)val22;
					fireFunc = FireSimpleLauncher;
					setFirearmUpdateOverride = SetSimpleLauncherUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is SimpleLauncher2)
				{
					SimpleLauncher2 val23 = (SimpleLauncher2)(object)((component is SimpleLauncher2) ? component : null);
					updateFunc = UpdateSimpleLauncher2;
					updateGivenFunc = UpdateGivenSimpleLauncher2;
					dataObject = (Object)(object)val23;
					fireFunc = FireSimpleLauncher2;
					setFirearmUpdateOverride = SetSimpleLauncher2UpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is MF2_RL)
				{
					MF2_RL val24 = (MF2_RL)(object)((component is MF2_RL) ? component : null);
					updateFunc = UpdateMF2_RL;
					updateGivenFunc = UpdateGivenMF2_RL;
					dataObject = (Object)(object)val24;
					fireFunc = FireMF2_RL;
					setFirearmUpdateOverride = SetMF2_RLUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is LAPD2019)
				{
					updateFunc = UpdateLAPD2019;
					updateGivenFunc = UpdateGivenLAPD2019;
					dataObject = (Object)(object)((component is LAPD2019) ? component : null);
					getChamberIndex = GetLAPD2019ChamberIndex;
				}
				else if (val is Girandoni)
				{
					updateFunc = UpdateGirandoni;
					updateGivenFunc = UpdateGivenGirandoni;
					dataObject = (Object)(object)((component is Girandoni) ? component : null);
					fireFunc = FireGirandoni;
					setFirearmUpdateOverride = SetGirandoniUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else if (val is MeatNailer)
				{
					updateFunc = UpdateMeatNailer;
					updateGivenFunc = UpdateGivenMeatNailer;
					dataObject = (Object)(object)((component is MeatNailer) ? component : null);
					fireFunc = FireMeatNailer;
					setFirearmUpdateOverride = SetMeatNailerUpdateOverride;
					getChamberIndex = GetMeatNailerChamberIndex;
					chamberRound = ChamberMeatNailerRound;
				}
				else if (val is SRG)
				{
					updateFunc = UpdateSRG;
					updateGivenFunc = UpdateGivenSRG;
					dataObject = (Object)(object)((component is SRG) ? component : null);
					fireFunc = FireSRG;
					setFirearmUpdateOverride = SetSRGUpdateOverride;
					getChamberIndex = GetFirstChamberIndex;
				}
				else
				{
					updateFunc = UpdateFireArm;
					updateGivenFunc = UpdateGivenFireArm;
					dataObject = (Object)(object)val;
					fireFunc = FireFireArm;
					setFirearmUpdateOverride = SetFireArmUpdateOverride;
					getChamberIndex = GetFireArmChamberIndex;
					chamberRound = ChamberFireArmRound;
				}
			}
			else if (component is SteelPopTarget)
			{
				SteelPopTarget val25 = (SteelPopTarget)component;
				updateFunc = UpdateSteelPopTarget;
				updateGivenFunc = UpdateGivenSteelPopTarget;
				dataObject = (Object)(object)val25;
				findSecondary = FindSteelPopTargetSecondary;
				getSecondary = GetSteelPopTargetSecondary;
				ReactiveSteelTarget[] componentsInChildren = ((Component)component).GetComponentsInChildren<ReactiveSteelTarget>();
				object[] array = componentsInChildren;
				secondaries = array;
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)componentsInChildren[i], this);
					removeTrackedDamageables = RemoveTrackedSteelPopTargetDamageables;
				}
			}
			else if (component is Molotov)
			{
				Molotov key2 = (Molotov)component;
				updateFunc = UpdateMolotov;
				updateGivenFunc = UpdateGivenMolotov;
				dataObject = (Object)(object)key2;
				GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)key2, this);
				removeTrackedDamageables = RemoveTrackedCommonDamageables;
			}
			else if (component is PinnedGrenade)
			{
				PinnedGrenade val26 = (PinnedGrenade)component;
				updateFunc = UpdatePinnedGrenade;
				updateGivenFunc = UpdateGivenPinnedGrenade;
				dataObject = (Object)(object)val26;
				if (val26.SpawnOnSplode == null)
				{
					val26.SpawnOnSplode = new List<GameObject>();
				}
				GameObject val27 = new GameObject();
				TrackedObjectReference trackedObjectReference2 = val27.AddComponent<TrackedObjectReference>();
				val27.SetActive(false);
				CheckReferenceSize();
				int num2 = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
				TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
				TrackedObject.trackedReferenceObjects[num2] = val27;
				TrackedObject.trackedReferences[num2] = this;
				((Object)val27).name = num2.ToString();
				trackedObjectReference2.refIndex = num2;
				val26.SpawnOnSplode.Add(val27);
			}
			else if (component is FVRGrenade)
			{
				FVRGrenade val28 = (FVRGrenade)component;
				updateFunc = UpdateGrenade;
				updateGivenFunc = UpdateGivenGrenade;
				dataObject = (Object)(object)val28;
				if (val28.FuseTimings == null)
				{
					val28.FuseTimings = new Dictionary<int, float>();
				}
				CheckReferenceSize();
				int num3 = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
				TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
				val28.FuseTimings.Add(-1, num3);
				TrackedObject.trackedReferences[num3] = this;
				GameObject val29 = new GameObject("GrenadeRefIndex");
				TrackedObjectReference trackedObjectReference3 = val29.AddComponent<TrackedObjectReference>();
				trackedObjectReference3.refIndex = num3;
				val29.SetActive(false);
			}
			else if (component is C4)
			{
				C4 val30 = (C4)component;
				updateFunc = UpdateC4;
				updateGivenFunc = UpdateGivenC4;
				dataObject = (Object)(object)val30;
			}
			else if (component is ClaymoreMine)
			{
				ClaymoreMine val31 = (ClaymoreMine)component;
				updateFunc = UpdateClaymoreMine;
				updateGivenFunc = UpdateGivenClaymoreMine;
				dataObject = (Object)(object)val31;
			}
			else if (component is SLAM)
			{
				SLAM key3 = (SLAM)component;
				updateFunc = UpdateSLAM;
				updateGivenFunc = UpdateGivenSLAM;
				dataObject = (Object)(object)key3;
				GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)key3, this);
				removeTrackedDamageables = RemoveTrackedCommonDamageables;
			}
			else if (component is LAPD2019Battery)
			{
				updateFunc = UpdateLAPD2019Battery;
				updateGivenFunc = UpdateGivenLAPD2019Battery;
				dataObject = (Object)(object)((component is LAPD2019Battery) ? component : null);
			}
			else if (component is AttachableFirearmPhysicalObject)
			{
				AttachableFirearmPhysicalObject val32 = (AttachableFirearmPhysicalObject)component;
				if (val32.FA is AttachableBreakActions)
				{
					updateFunc = UpdateAttachableBreakActions;
					updateGivenFunc = UpdateGivenAttachableBreakActions;
					ref FireAttachableFirearm reference6 = ref attachableFirearmFireFunc;
					AttachableFirearm fA = val32.FA;
					reference6 = ((AttachableBreakActions)((fA is AttachableBreakActions) ? fA : null)).Fire;
					attachableFirearmChamberRoundFunc = AttachableBreakActionsChamberRound;
					attachableFirearmGetChamberFunc = AttachableBreakActionsGetChamber;
					getChamberIndex = GetFirstChamberIndex;
					chamberRound = ChamberAttachableBreakActionsRound;
				}
				else if (val32.FA is AttachableClosedBoltWeapon)
				{
					updateFunc = UpdateAttachableClosedBoltWeapon;
					updateGivenFunc = UpdateGivenAttachableClosedBoltWeapon;
					ref FireAttachableFirearm reference7 = ref attachableFirearmFireFunc;
					AttachableFirearm fA2 = val32.FA;
					reference7 = ((AttachableClosedBoltWeapon)((fA2 is AttachableClosedBoltWeapon) ? fA2 : null)).Fire;
					attachableFirearmChamberRoundFunc = AttachableClosedBoltWeaponChamberRound;
					attachableFirearmGetChamberFunc = AttachableClosedBoltWeaponGetChamber;
					getChamberIndex = GetFirstChamberIndex;
					chamberRound = ChamberAttachableClosedBoltWeaponRound;
				}
				else if (val32.FA is AttachableTubeFed)
				{
					updateFunc = UpdateAttachableTubeFed;
					updateGivenFunc = UpdateGivenAttachableTubeFed;
					ref FireAttachableFirearm reference8 = ref attachableFirearmFireFunc;
					AttachableFirearm fA3 = val32.FA;
					reference8 = ((AttachableTubeFed)((fA3 is AttachableTubeFed) ? fA3 : null)).Fire;
					attachableFirearmChamberRoundFunc = AttachableTubeFedChamberRound;
					attachableFirearmGetChamberFunc = AttachableTubeFedGetChamber;
					getChamberIndex = GetFirstChamberIndex;
					chamberRound = ChamberAttachableTubeFedRound;
				}
				else if (val32.FA is GP25)
				{
					updateFunc = UpdateGP25;
					updateGivenFunc = UpdateGivenGP25;
					ref FireAttachableFirearm reference9 = ref attachableFirearmFireFunc;
					AttachableFirearm fA4 = val32.FA;
					reference9 = ((GP25)((fA4 is GP25) ? fA4 : null)).Fire;
					attachableFirearmChamberRoundFunc = GP25ChamberRound;
					attachableFirearmGetChamberFunc = GP25GetChamber;
					getChamberIndex = GetFirstChamberIndex;
					chamberRound = ChamberGP25Round;
				}
				else if (val32.FA is M203)
				{
					updateFunc = UpdateM203;
					updateGivenFunc = UpdateGivenM203;
					ref FireAttachableFirearm reference10 = ref attachableFirearmFireFunc;
					AttachableFirearm fA5 = val32.FA;
					reference10 = ((M203)((fA5 is M203) ? fA5 : null)).Fire;
					attachableFirearmChamberRoundFunc = M203ChamberRound;
					attachableFirearmGetChamberFunc = M203GetChamber;
					getChamberIndex = GetFirstChamberIndex;
					chamberRound = ChamberM203Round;
				}
				updateParentFunc = UpdateAttachableFirearmParent;
				parentChanged = AttachmentParentChanged;
				dataObject = (Object)(object)val32.FA;
			}
			else if (component is Suppressor)
			{
				Suppressor val33 = (Suppressor)component;
				updateFunc = UpdateSuppressor;
				updateGivenFunc = UpdateGivenSuppressor;
				updateParentFunc = UpdateAttachmentParent;
				parentChanged = AttachmentParentChanged;
				dataObject = (Object)(object)val33;
			}
			else if (component is FVRFireArmAttachment)
			{
				FVRFireArmAttachment val34 = (FVRFireArmAttachment)component;
				updateFunc = UpdateAttachment;
				updateGivenFunc = UpdateGivenAttachment;
				updateParentFunc = UpdateAttachmentParent;
				parentChanged = AttachmentParentChanged;
				dataObject = (Object)(object)val34;
				if ((Object)(object)val34.AttachmentInterface != (Object)null)
				{
					if (val34.AttachmentInterface is AttachableBipodInterface)
					{
						attachmentInterfaceUpdateFunc = UpdateAttachableBipod;
						attachmentInterfaceUpdateGivenFunc = UpdateGivenAttachableBipod;
						attachmentInterfaceDataSize = 1;
					}
					else if (val34.AttachmentInterface is FlagPoseSwitcher)
					{
						attachmentInterfaceUpdateFunc = UpdateFlagPoseSwitcher;
						attachmentInterfaceUpdateGivenFunc = UpdateGivenFlagPoseSwitcher;
						attachmentInterfaceDataSize = 2;
					}
					else if (val34.AttachmentInterface is FlipSight)
					{
						attachmentInterfaceUpdateFunc = UpdateFlipSight;
						attachmentInterfaceUpdateGivenFunc = UpdateGivenFlipSight;
						attachmentInterfaceDataSize = 1;
					}
					else if (val34.AttachmentInterface is FlipSightY)
					{
						attachmentInterfaceUpdateFunc = UpdateFlipSightY;
						attachmentInterfaceUpdateGivenFunc = UpdateGivenFlipSightY;
						attachmentInterfaceDataSize = 1;
					}
					else if (val34.AttachmentInterface is LAM)
					{
						attachmentInterfaceUpdateFunc = UpdateLAM;
						attachmentInterfaceUpdateGivenFunc = UpdateGivenLAM;
						attachmentInterfaceDataSize = 1;
					}
					else if (val34.AttachmentInterface is LaserPointer)
					{
						attachmentInterfaceUpdateFunc = UpdateLaserPointer;
						attachmentInterfaceUpdateGivenFunc = UpdateGivenLaserPointer;
						attachmentInterfaceDataSize = 1;
					}
					else if (val34.AttachmentInterface is TacticalFlashlight)
					{
						attachmentInterfaceUpdateFunc = UpdateTacticalFlashlight;
						attachmentInterfaceUpdateGivenFunc = UpdateGivenTacticalFlashlight;
						attachmentInterfaceDataSize = 1;
					}
				}
			}
			else if (component is SosigWeaponPlayerInterface)
			{
				SosigWeaponPlayerInterface val35 = (SosigWeaponPlayerInterface)component;
				updateFunc = UpdateSosigWeaponInterface;
				updateGivenFunc = UpdateGivenSosigWeaponInterface;
				dataObject = (Object)(object)val35;
				sosigWeaponfireFunc = val35.W.FireGun;
				onDestruction = SosigWeaponDestruction;
				GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)val35.W, this);
				removeTrackedDamageables = RemoveTrackedSosigWeaponDamageables;
			}
			else if (component is GrappleThrowable)
			{
				GrappleThrowable val36 = (GrappleThrowable)component;
				updateFunc = UpdateGrappleThrowable;
				updateGivenFunc = UpdateGivenGrappleThrowable;
				dataObject = (Object)(object)val36;
			}
			else
			{
				dataObject = (Object)(object)component;
				Brut_GasCuboid component3;
				if (TryGetComponent<UberShatterable>(((Component)component).gameObject, out var component2))
				{
					updateFunc = UpdateUberShatterable;
					updateGivenFunc = UpdateGivenUberShatterable;
					handleShatterSpecific = HandleShatterableShatter;
					dataObject = (Object)(object)component2;
					GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)component2, this);
					removeTrackedDamageables = RemoveTrackedCommonDamageables;
				}
				else if (TryGetComponent<Brut_GasCuboid>(((Component)component).gameObject, out component3))
				{
					updateFunc = UpdateGasCuboid;
					updateGivenFunc = UpdateGivenGasCuboid;
					dataObject = (Object)(object)component3;
					CheckReferenceSize();
					int num4 = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
					TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
					GameObject val37 = new GameObject(num4.ToString());
					component3.SpawnOnSplodePoints.Add(val37.transform);
					TrackedObject.trackedReferences[num4] = this;
					TrackedObject.trackedReferenceObjects[num4] = val37;
					GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)component3, this);
					GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)component3.Handle.GetComponent<Brut_GasCuboidHandle>(), this);
					removeTrackedDamageables = RemoveTrackedGasCuboidDamageables;
				}
			}
		}

		public static void AddModulPartDataInvoke(List<byte> buffer, string groupID, string selectedPart, IDictionary pointDict, TrackedItem trackedItem)
		{
			if (TrackedItem.AddModulPartData != null)
			{
				TrackedItem.AddModulPartData(buffer, groupID, selectedPart, pointDict, trackedItem);
			}
		}

		public static void ReadModulPartDataInvoke(byte[] additionalData, int offset, string groupID, IDictionary pointDict, TrackedItem trackedItem)
		{
			if (TrackedItem.ReadModulPartData != null)
			{
				TrackedItem.ReadModulPartData(additionalData, offset, groupID, pointDict, trackedItem);
			}
		}

		public static void PreConfigureModulPartInvoke(byte[] additionalData, int offset, string groupID, IDictionary pointDict, TrackedItem trackedItem)
		{
			if (TrackedItem.PreConfigureModulPartData != null)
			{
				TrackedItem.PreConfigureModulPartData(additionalData, offset, groupID, pointDict, trackedItem);
			}
		}

		public static bool TryGetComponent<T>(GameObject obj, out T component)
		{
			component = obj.GetComponent<T>();
			return component != null;
		}

		public void RemoveTrackedCommonDamageables()
		{
			Dictionary<IFVRDamageable, TrackedObject> trackedObjectByDamageable = GameManager.trackedObjectByDamageable;
			Object obj = dataObject;
			trackedObjectByDamageable.Remove((IFVRDamageable)(object)((obj is IFVRDamageable) ? obj : null));
		}

		public void RemoveTrackedGasCuboidDamageables()
		{
			Dictionary<IFVRDamageable, TrackedObject> trackedObjectByDamageable = GameManager.trackedObjectByDamageable;
			Object obj = dataObject;
			trackedObjectByDamageable.Remove((IFVRDamageable)(object)((obj is IFVRDamageable) ? obj : null));
			Dictionary<IFVRDamageable, TrackedObject> trackedObjectByDamageable2 = GameManager.trackedObjectByDamageable;
			Object obj2 = dataObject;
			trackedObjectByDamageable2.Remove((IFVRDamageable)(object)((Brut_GasCuboid)((obj2 is Brut_GasCuboid) ? obj2 : null)).Handle.GetComponent<Brut_GasCuboidHandle>());
		}

		public void RemoveTrackedSosigWeaponDamageables()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)((SosigWeaponPlayerInterface)dataObject).W);
		}

		public void RemoveTrackedSteelPopTargetDamageables()
		{
			for (int i = 0; i < secondaries.Length; i++)
			{
				if (secondaries[i] != null)
				{
					Dictionary<IFVRDamageable, TrackedObject> trackedObjectByDamageable = GameManager.trackedObjectByDamageable;
					object obj = secondaries[i];
					trackedObjectByDamageable.Remove((IFVRDamageable)((obj is IFVRDamageable) ? obj : null));
				}
			}
		}

		public bool UpdateItemData(byte[] newData = null)
		{
			if (dataObject != (Object)null)
			{
				if (newData != null)
				{
					return updateGivenFunc != null && updateGivenFunc(newData);
				}
				return updateFunc != null && updateFunc();
			}
			return false;
		}

		private bool UpdateFireArm()
		{
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			FVRFireArm val = (FVRFireArm)(object)((obj is FVRFireArm) ? obj : null);
			bool flag = false;
			int num = val.GetChambers().Count * 4;
			if (itemData.data == null || itemData.data.Length < num)
			{
				itemData.data = new byte[num];
				flag = true;
			}
			for (int i = 0; i < val.GetChambers().Count; i++)
			{
				int num2 = i * 4;
				byte b = itemData.data[num2];
				byte b2 = itemData.data[num2 + 1];
				byte b3 = itemData.data[num2 + 2];
				byte b4 = itemData.data[num2 + 3];
				if ((Object)(object)val.GetChambers()[i].GetRound() == (Object)null || val.GetChambers()[i].IsSpent || val.GetChambers()[i].GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num2 + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.GetChambers()[i].GetRound().RoundType).CopyTo(itemData.data, num2);
					BitConverter.GetBytes((short)val.GetChambers()[i].GetRound().RoundClass).CopyTo(itemData.data, num2 + 2);
				}
				flag |= b != itemData.data[num2] || b2 != itemData.data[num2 + 1] || b3 != itemData.data[num2 + 2] || b4 != itemData.data[num2 + 3];
			}
			return flag;
		}

		private bool UpdateGivenFireArm(byte[] newData)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			FVRFireArm val = (FVRFireArm)(object)((obj is FVRFireArm) ? obj : null);
			for (int i = 0; i < val.GetChambers().Count; i++)
			{
				int num = i * 4;
				if (num >= val.GetChambers().Count)
				{
					break;
				}
				short num2 = BitConverter.ToInt16(newData, num);
				short num3 = BitConverter.ToInt16(newData, num + 2);
				if (num3 == -1)
				{
					if ((Object)(object)val.GetChambers()[i].GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.GetChambers()[i].SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val2 = (FireArmRoundType)num2;
				FireArmRoundClass val3 = (FireArmRoundClass)num3;
				if ((Object)(object)val.GetChambers()[i].GetRound() == (Object)null || val.GetChambers()[i].GetRound().RoundClass != val3)
				{
					if (val.GetChambers()[i].RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.GetChambers()[i].SetRound(val3, ((Component)val.GetChambers()[i]).transform.position, ((Component)val.GetChambers()[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.GetChambers()[i].RoundType;
						val.GetChambers()[i].RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.GetChambers()[i].SetRound(val3, ((Component)val.GetChambers()[i]).transform.position, ((Component)val.GetChambers()[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.GetChambers()[i].RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireFireArm(int chamberIndex)
		{
			if (chamberIndex == -1)
			{
				return false;
			}
			Object obj = dataObject;
			FVRFireArm val = (FVRFireArm)(object)((obj is FVRFireArm) ? obj : null);
			val.Fire(val.GetChambers()[chamberIndex], val.GetMuzzle(), false, 1f, -1f);
			return true;
		}

		private void SetFireArmUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (chamberIndex != -1)
			{
				Object obj = dataObject;
				FVRFireArm val = (FVRFireArm)(object)((obj is FVRFireArm) ? obj : null);
				FireArmRoundType roundType2 = val.GetChambers()[chamberIndex].RoundType;
				val.GetChambers()[chamberIndex].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val.GetChambers()[chamberIndex].SetRound(roundClass, ((Component)val.GetChambers()[chamberIndex]).transform.position, ((Component)val.GetChambers()[chamberIndex]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val.GetChambers()[chamberIndex].RoundType = roundType2;
			}
		}

		private int GetFireArmChamberIndex(FVRFireArmChamber chamber)
		{
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			Object obj = dataObject;
			FVRFireArm val = (FVRFireArm)(object)((obj is FVRFireArm) ? obj : null);
			List<FVRFireArmChamber> chambers = val.GetChambers();
			for (int i = 0; i < chambers.Count; i++)
			{
				if ((Object)(object)chambers[i] == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private void ChamberFireArmRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			FVRFireArm val = (FVRFireArm)(object)((obj is FVRFireArm) ? obj : null);
			ChamberPatch.chamberSkip++;
			if ((int)roundClass == -1)
			{
				val.GetChambers()[chamberIndex].SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.GetChambers()[chamberIndex].SetRound(roundClass, ((Component)val.GetChambers()[chamberIndex]).transform.position, ((Component)val.GetChambers()[chamberIndex]).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateSBLPCell()
		{
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			sblpCell val = (sblpCell)(object)((obj is sblpCell) ? obj : null);
			if (itemData.data == null)
			{
				itemData.data = new byte[9];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null) ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			if ((Object)(object)((FVRFireArmMagazine)val).FireArm == (Object)null)
			{
				itemData.data[1] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; i++)
				{
					if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[i].Magazine == (Object)(object)val)
					{
						flag2 = true;
						itemData.data[1] = (byte)i;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[1] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)(((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null) ? 1 : 0);
			flag |= b != itemData.data[2];
			b = itemData.data[3];
			if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm == (Object)null)
			{
				itemData.data[3] = byte.MaxValue;
			}
			else
			{
				bool flag3 = false;
				for (int j = 0; j < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length; j++)
				{
					if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[j].Magazine == (Object)(object)val)
					{
						itemData.data[3] = (byte)j;
						break;
					}
				}
				if (!flag3)
				{
					itemData.data[3] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[3];
			b = itemData.data[4];
			byte b2 = itemData.data[5];
			byte b3 = itemData.data[6];
			byte b4 = itemData.data[7];
			BitConverter.GetBytes(((FVRFireArmMagazine)val).FuelAmountLeft).CopyTo(itemData.data, 4);
			flag |= b != itemData.data[4] || b2 != itemData.data[5] || b3 != itemData.data[6] || b4 != itemData.data[7];
			b = itemData.data[8];
			itemData.data[8] = (byte)val.PL;
			return flag | (b != itemData.data[8]);
		}

		private bool UpdateRound()
		{
			return false;
		}

		private bool UpdateGivenRound(byte[] newData)
		{
			return false;
		}

		private bool UpdateGivenSBLPCell(byte[] newData)
		{
			//IL_07b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			sblpCell val = (sblpCell)(object)((obj is sblpCell) ? obj : null);
			if (itemData.data == null)
			{
				flag = true;
			}
			if (newData[0] == 1)
			{
				if (data.parent != -1)
				{
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[data.parent] as TrackedItemData) : (Server.objects[data.parent] as TrackedItemData));
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.dataObject is FVRFireArm)
					{
						if ((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null)
						{
							if ((Object)(object)((FVRFireArmMagazine)val).FireArm != trackedItemData.physicalItem.dataObject)
							{
								if ((Object)(object)((FVRFireArmMagazine)val).FireArm.Magazine == (Object)(object)val)
								{
									((FVRFireArmMagazine)val).FireArm.EjectMag(true);
								}
								else
								{
									for (int i = 0; i < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; i++)
									{
										if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[i].Magazine == (Object)(object)val)
										{
											((FVRFireArmMagazine)val).FireArm.EjectSecondaryMagFromSlot(i, true);
											break;
										}
									}
								}
								if (newData[1] == byte.MaxValue)
								{
									MagazinePatch.loadSkip++;
									? val2 = val;
									Object obj2 = trackedItemData.physicalItem.dataObject;
									((FVRFireArmMagazine)val2).Load((FVRFireArm)(object)((obj2 is FVRFireArm) ? obj2 : null));
									MagazinePatch.loadSkip--;
								}
								else
								{
									MagazinePatch.loadSkip++;
									? val3 = val;
									Object obj3 = trackedItemData.physicalItem.dataObject;
									((FVRFireArmMagazine)val3).LoadIntoSecondary((FVRFireArm)(object)((obj3 is FVRFireArm) ? obj3 : null), (int)newData[1]);
									MagazinePatch.loadSkip--;
								}
								flag = true;
							}
						}
						else if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null)
						{
							if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.Magazine == (Object)(object)val)
							{
								((FVRFireArmMagazine)val).AttachableFireArm.EjectMag(true);
							}
							else
							{
								for (int j = 0; j < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[j].Magazine == (Object)(object)val); j++)
								{
								}
							}
							if (newData[1] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val4 = val;
								Object obj4 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val4).Load((FVRFireArm)(object)((obj4 is FVRFireArm) ? obj4 : null));
								MagazinePatch.loadSkip--;
							}
							else
							{
								MagazinePatch.loadSkip++;
								? val5 = val;
								Object obj5 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val5).LoadIntoSecondary((FVRFireArm)(object)((obj5 is FVRFireArm) ? obj5 : null), (int)newData[1]);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
						else
						{
							if (newData[1] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val6 = val;
								Object obj6 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val6).Load((FVRFireArm)(object)((obj6 is FVRFireArm) ? obj6 : null));
								MagazinePatch.loadSkip--;
							}
							else
							{
								MagazinePatch.loadSkip++;
								? val7 = val;
								Object obj7 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val7).LoadIntoSecondary((FVRFireArm)(object)((obj7 is FVRFireArm) ? obj7 : null), (int)newData[1]);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
					}
				}
			}
			else if (newData[2] == 1)
			{
				if (data.parent != -1)
				{
					TrackedItemData trackedItemData2 = null;
					trackedItemData2 = ((!ThreadManager.host) ? (Client.objects[data.parent] as TrackedItemData) : (Server.objects[data.parent] as TrackedItemData));
					if (trackedItemData2 != null && (Object)(object)trackedItemData2.physicalItem != (Object)null && trackedItemData2.physicalItem.dataObject is AttachableFirearmPhysicalObject)
					{
						if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null)
						{
							AttachableFirearm attachableFireArm = ((FVRFireArmMagazine)val).AttachableFireArm;
							Object obj8 = trackedItemData2.physicalItem.dataObject;
							if ((Object)(object)attachableFireArm != (Object)(object)((AttachableFirearmPhysicalObject)((obj8 is AttachableFirearmPhysicalObject) ? obj8 : null)).FA)
							{
								if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.Magazine == (Object)(object)val)
								{
									((FVRFireArmMagazine)val).AttachableFireArm.EjectMag(true);
								}
								else
								{
									for (int k = 0; k < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[k].Magazine == (Object)(object)val); k++)
									{
									}
								}
								if (newData[3] == byte.MaxValue)
								{
									MagazinePatch.loadSkip++;
									? val8 = val;
									Object obj9 = trackedItemData2.physicalItem.dataObject;
									((FVRFireArmMagazine)val8).Load(((AttachableFirearmPhysicalObject)((obj9 is AttachableFirearmPhysicalObject) ? obj9 : null)).FA);
									MagazinePatch.loadSkip--;
								}
								flag = true;
							}
						}
						else if ((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null)
						{
							if ((Object)(object)((FVRFireArmMagazine)val).FireArm.Magazine == (Object)(object)val)
							{
								((FVRFireArmMagazine)val).FireArm.EjectMag(true);
							}
							else
							{
								for (int l = 0; l < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; l++)
								{
									if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[l].Magazine == (Object)(object)val)
									{
										((FVRFireArmMagazine)val).FireArm.EjectSecondaryMagFromSlot(l, true);
										break;
									}
								}
							}
							if (newData[3] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val9 = val;
								Object obj10 = trackedItemData2.physicalItem.dataObject;
								((FVRFireArmMagazine)val9).Load(((AttachableFirearmPhysicalObject)((obj10 is AttachableFirearmPhysicalObject) ? obj10 : null)).FA);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
						else
						{
							if (newData[3] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val10 = val;
								Object obj11 = trackedItemData2.physicalItem.dataObject;
								((FVRFireArmMagazine)val10).Load(((AttachableFirearmPhysicalObject)((obj11 is AttachableFirearmPhysicalObject) ? obj11 : null)).FA);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
					}
				}
			}
			else if ((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null)
			{
				if ((Object)(object)((FVRFireArmMagazine)val).FireArm.Magazine == (Object)(object)val)
				{
					((FVRFireArmMagazine)val).FireArm.EjectMag(true);
				}
				else
				{
					for (int m = 0; m < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; m++)
					{
						if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[m].Magazine == (Object)(object)val)
						{
							((FVRFireArmMagazine)val).FireArm.EjectSecondaryMagFromSlot(m, true);
							break;
						}
					}
				}
				flag = true;
			}
			else if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null)
			{
				if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.Magazine == (Object)(object)val)
				{
					((FVRFireArmMagazine)val).AttachableFireArm.EjectMag(true);
				}
				else
				{
					for (int n = 0; n < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[n].Magazine == (Object)(object)val); n++)
					{
					}
				}
				flag = true;
			}
			float fuelAmountLeft = ((FVRFireArmMagazine)val).FuelAmountLeft;
			((FVRFireArmMagazine)val).FuelAmountLeft = BitConverter.ToSingle(newData, 4);
			flag |= fuelAmountLeft != ((FVRFireArmMagazine)val).FuelAmountLeft;
			PLevel pL = val.PL;
			val.PL = (PLevel)newData[8];
			flag |= pL != val.PL;
			itemData.data = newData;
			return flag;
		}

		private bool UpdateLaserGun()
		{
			Object obj = dataObject;
			sblp val = (sblp)(object)((obj is sblp) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[3];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isShotEngaged ? 1 : 0);
			return flag | (b != itemData.data[0]);
		}

		private bool UpdateGivenLaserGun(byte[] newData)
		{
			bool result = false;
			Object obj = dataObject;
			sblp val = (sblp)(object)((obj is sblp) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				if (newData[0] == 1 && !val.m_isShotEngaged)
				{
					val.TryToEngageShot();
				}
				else if (newData[0] == 0 && val.m_isShotEngaged)
				{
					val.TryToDisengageShot();
				}
			}
			else if (newData[0] == 1 && !val.m_isShotEngaged)
			{
				val.TryToEngageShot();
				result = true;
			}
			else if (newData[0] == 0 && val.m_isShotEngaged)
			{
				val.TryToDisengageShot();
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateAirgun()
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Airgun val = (Airgun)(object)((obj is Airgun) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[3];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.IsHammerCocked ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			byte b2 = itemData.data[2];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 1);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 1);
			}
			return flag | (b != itemData.data[1] || b2 != itemData.data[2]);
		}

		private bool UpdateGivenAirgun(byte[] newData)
		{
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			Airgun val = (Airgun)(object)((obj is Airgun) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				if (newData[0] == 1 && !val.IsHammerCocked)
				{
					val.CockHammer();
				}
				else if (newData[0] == 0 && val.IsHammerCocked)
				{
					val.m_isHammerCocked = false;
				}
			}
			else if (newData[0] == 1 && !val.IsHammerCocked)
			{
				val.CockHammer();
				result = true;
			}
			else if (newData[0] == 0 && val.IsHammerCocked)
			{
				val.m_isHammerCocked = false;
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 1);
			if (num == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundClass val2 = (FireArmRoundClass)num;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val2)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound(val2, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireAirgun(int chamberIndex)
		{
			Object obj = dataObject;
			Airgun val = (Airgun)(object)((obj is Airgun) ? obj : null);
			val.DropHammer();
			return true;
		}

		private void SetAirgunUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Airgun val = (Airgun)(object)((obj is Airgun) ? obj : null);
			val.CockHammer();
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private int GetFirstChamberIndex(FVRFireArmChamber chamber)
		{
			return 0;
		}

		private bool UpdateSLAM()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			SLAM val = (SLAM)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[1];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.Mode;
			return flag | (b != itemData.data[0]);
		}

		private bool UpdateGivenSLAM(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			bool result = false;
			SLAM val = (SLAM)dataObject;
			if (itemData.data == null)
			{
				result = true;
				val.SetMode((SLAMMode)newData[0]);
			}
			else if (itemData.data[0] != newData[0])
			{
				val.SetMode((SLAMMode)newData[0]);
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateClaymoreMine()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			ClaymoreMine val = (ClaymoreMine)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[2];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isArmed ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.m_isPlanted ? 1 : 0);
			return flag | (b != itemData.data[1]);
		}

		private bool UpdateGivenClaymoreMine(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			bool result = false;
			ClaymoreMine val = (ClaymoreMine)dataObject;
			if (itemData.data == null)
			{
				result = true;
				val.m_isArmed = newData[0] == 1;
				val.m_isPlanted = newData[1] == 1;
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_isArmed = newData[0] == 1;
					result = true;
				}
				if (itemData.data[1] != newData[1])
				{
					val.m_isPlanted = newData[1] == 1;
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateC4()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			C4 val = (C4)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[1];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isArmed ? 1 : 0);
			return flag | (b != itemData.data[0]);
		}

		private bool UpdateGivenC4(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			bool result = false;
			C4 val = (C4)dataObject;
			if (itemData.data == null)
			{
				result = true;
				val.SetArmed(newData[0] == 1);
			}
			else if (itemData.data[0] != newData[0])
			{
				val.SetArmed(newData[0] == 1);
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateGrenade()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			FVRGrenade val = (FVRGrenade)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[val.Uses2ndPin ? 3 : 2];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isLeverReleased ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.Pin.m_hasBeenPulled ? 1 : 0);
			flag |= b != itemData.data[1];
			if (val.Uses2ndPin)
			{
				b = itemData.data[2];
				itemData.data[2] = (byte)(val.Pin2.m_hasBeenPulled ? 1 : 0);
				flag |= b != itemData.data[2];
			}
			return flag;
		}

		private bool UpdateGivenGrenade(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			bool result = false;
			FVRGrenade val = (FVRGrenade)dataObject;
			if (itemData.data == null)
			{
				result = true;
				if (newData[0] == 1 && !val.m_isLeverReleased)
				{
					val.ReleaseLever();
				}
				if (newData[1] == 1 && !val.Pin.m_hasBeenPulled)
				{
					val.Pin.m_hasBeenPulled = true;
					((Component)val.Pin).transform.SetParent((Transform)null);
					val.Pin.PinPiece.transform.SetParent(((Component)val.Pin).transform);
					Rigidbody val2 = val.Pin.PinPiece.AddComponent<Rigidbody>();
					val2.mass = 0.01f;
					HingeJoint component = ((Component)val.Pin).GetComponent<HingeJoint>();
					((Joint)component).connectedBody = val2;
					val.Pin.Grenade.PullPin();
					val.Pin.m_isDying = true;
					if ((Object)(object)((FVRInteractiveObject)val.Pin).UXGeo_Held != (Object)null)
					{
						Object.Destroy((Object)(object)((FVRInteractiveObject)val.Pin).UXGeo_Held);
					}
				}
				if (val.Uses2ndPin && newData[2] == 1 && !val.Pin2.m_hasBeenPulled)
				{
					val.Pin2.m_hasBeenPulled = true;
					((Component)val.Pin2).transform.SetParent((Transform)null);
					val.Pin2.PinPiece.transform.SetParent(((Component)val.Pin2).transform);
					Rigidbody val3 = val.Pin2.PinPiece.AddComponent<Rigidbody>();
					val3.mass = 0.01f;
					HingeJoint component2 = ((Component)val.Pin2).GetComponent<HingeJoint>();
					((Joint)component2).connectedBody = val3;
					val.Pin2.Grenade.PullPin2();
					val.Pin2.m_isDying = true;
					if ((Object)(object)((FVRInteractiveObject)val.Pin2).UXGeo_Held != (Object)null)
					{
						Object.Destroy((Object)(object)((FVRInteractiveObject)val.Pin2).UXGeo_Held);
					}
				}
			}
			else
			{
				if (newData[0] == 1 && !val.m_isLeverReleased)
				{
					val.ReleaseLever();
					result = true;
				}
				if (newData[1] == 1 && !val.Pin.m_hasBeenPulled)
				{
					val.Pin.m_hasBeenPulled = true;
					((Component)val.Pin).transform.SetParent((Transform)null);
					val.Pin.PinPiece.transform.SetParent(((Component)val.Pin).transform);
					Rigidbody val4 = val.Pin.PinPiece.AddComponent<Rigidbody>();
					val4.mass = 0.01f;
					HingeJoint component3 = ((Component)val.Pin).GetComponent<HingeJoint>();
					((Joint)component3).connectedBody = val4;
					val.Pin.Grenade.PullPin();
					val.Pin.m_isDying = true;
					if ((Object)(object)((FVRInteractiveObject)val.Pin).UXGeo_Held != (Object)null)
					{
						Object.Destroy((Object)(object)((FVRInteractiveObject)val.Pin).UXGeo_Held);
					}
					result = true;
				}
				if (val.Uses2ndPin && newData[2] == 1 && !val.Pin2.m_hasBeenPulled)
				{
					val.Pin2.m_hasBeenPulled = true;
					((Component)val.Pin2).transform.SetParent((Transform)null);
					val.Pin2.PinPiece.transform.SetParent(((Component)val.Pin2).transform);
					Rigidbody val5 = val.Pin2.PinPiece.AddComponent<Rigidbody>();
					val5.mass = 0.01f;
					HingeJoint component4 = ((Component)val.Pin2).GetComponent<HingeJoint>();
					((Joint)component4).connectedBody = val5;
					val.Pin2.Grenade.PullPin2();
					val.Pin2.m_isDying = true;
					if ((Object)(object)((FVRInteractiveObject)val.Pin2).UXGeo_Held != (Object)null)
					{
						Object.Destroy((Object)(object)((FVRInteractiveObject)val.Pin2).UXGeo_Held);
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdatePinnedGrenade()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			PinnedGrenade val = (PinnedGrenade)dataObject;
			bool flag = false;
			int num = val.m_rings.Count + 1;
			if (itemData.data == null || itemData.data.Length != num)
			{
				itemData.data = new byte[num];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.IsLeverReleased() ? 1 : 0);
			flag |= b != itemData.data[0];
			if (val.m_rings != null)
			{
				for (int i = 0; i < val.m_rings.Count; i++)
				{
					b = itemData.data[i + 1];
					itemData.data[i + 1] = (byte)(val.m_rings[i].HasPinDetached() ? 1 : 0);
					flag |= b != itemData.data[i + 1];
				}
			}
			return flag;
		}

		private bool UpdateGivenPinnedGrenade(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			PinnedGrenade val = (PinnedGrenade)dataObject;
			if (itemData.data == null)
			{
				result = true;
				if (newData[0] == 1 && !val.IsLeverReleased())
				{
					val.ReleaseLever();
				}
			}
			else if (newData[0] == 1 && !val.IsLeverReleased())
			{
				val.ReleaseLever();
				result = true;
			}
			if (val.m_rings != null)
			{
				bool isPinPulled = val.m_isPinPulled;
				bool flag = true;
				for (int i = 0; i < val.m_rings.Count; i++)
				{
					if (!val.m_rings[i].HasPinDetached())
					{
						if (newData[i + 1] == 1)
						{
							val.m_rings[i].m_hasPinDetached = true;
							val.m_rings[i].Pin.RootRigidbody = ((Component)val.m_rings[i].Pin).gameObject.AddComponent<Rigidbody>();
							val.m_rings[i].Pin.RootRigidbody.mass = 0.02f;
							((FVRInteractiveObject)val.m_rings[i]).ForceBreakInteraction();
							((Component)val.m_rings[i]).transform.SetParent(((Component)val.m_rings[i].Pin).transform);
							((Behaviour)val.m_rings[i].Pin).enabled = true;
							SM.PlayCoreSound((FVRPooledAudioType)10, val.m_rings[i].G.AudEvent_Pinpull, ((Component)val.m_rings[i]).transform.position);
							((Component)val.m_rings[i]).GetComponent<Collider>().enabled = false;
							((Behaviour)val.m_rings[i]).enabled = false;
							result = true;
						}
						else
						{
							flag = false;
						}
					}
				}
				if (isPinPulled != flag)
				{
					val.m_isPinPulled = flag;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateSteelPopTarget()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			SteelPopTarget val = (SteelPopTarget)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[val.Joints.Count * 12 + 1];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isSpringEnabled ? 1 : 0);
			flag |= b != itemData.data[0];
			for (int i = 0; i < val.Joints.Count; i++)
			{
				int num = i * 12 + 1;
				b = itemData.data[num];
				byte b2 = itemData.data[num + 1];
				byte b3 = itemData.data[num + 2];
				byte b4 = itemData.data[num + 3];
				BitConverter.GetBytes(((Component)val.Joints[i]).transform.localEulerAngles.x).CopyTo(itemData.data, num);
				flag |= b != itemData.data[num] || b2 != itemData.data[num + 1] || b3 != itemData.data[num + 2] || b4 != itemData.data[num + 3];
				b = itemData.data[num + 4];
				b2 = itemData.data[num + 5];
				b3 = itemData.data[num + 6];
				b4 = itemData.data[num + 7];
				BitConverter.GetBytes(((Component)val.Joints[i]).transform.localEulerAngles.y).CopyTo(itemData.data, num + 4);
				flag |= b != itemData.data[num + 4] || b2 != itemData.data[num + 5] || b3 != itemData.data[num + 6] || b4 != itemData.data[num + 7];
				b = itemData.data[num + 8];
				b2 = itemData.data[num + 9];
				b3 = itemData.data[num + 10];
				b4 = itemData.data[num + 11];
				BitConverter.GetBytes(((Component)val.Joints[i]).transform.localEulerAngles.z).CopyTo(itemData.data, num + 8);
				flag |= b != itemData.data[num + 8] || b2 != itemData.data[num + 9] || b3 != itemData.data[num + 10] || b4 != itemData.data[num + 11];
			}
			return flag;
		}

		private unsafe bool UpdateGivenSteelPopTarget(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			SteelPopTarget val = (SteelPopTarget)dataObject;
			if (itemData.data == null)
			{
				flag = true;
				if ((newData[0] == 1 && !val.m_isSpringEnabled) || (newData[0] == 0 && val.m_isSpringEnabled))
				{
					val.ToggleSpringSwitch();
				}
			}
			else if ((newData[0] == 1 && !val.m_isSpringEnabled) || (newData[0] == 0 && val.m_isSpringEnabled))
			{
				val.ToggleSpringSwitch();
				flag = true;
			}
			for (int i = 0; i < val.Joints.Count; i++)
			{
				Vector3 localEulerAngles = ((Component)val.Joints[i]).transform.localEulerAngles;
				((Component)val.Joints[i]).transform.localEulerAngles = new Vector3(BitConverter.ToSingle(newData, i * 12 + 1), BitConverter.ToSingle(newData, i * 12 + 5), BitConverter.ToSingle(newData, i * 12 + 9));
				flag |= !((object)(*(Vector3*)(&localEulerAngles))/*cast due to .constrained prefix*/).Equals((object?)((Component)val.Joints[i]).transform.localEulerAngles);
			}
			itemData.data = newData;
			return flag;
		}

		private int FindSteelPopTargetSecondary(object o)
		{
			for (int i = 0; i < secondaries.Length; i++)
			{
				if (secondaries[i] == o)
				{
					return i;
				}
			}
			return -1;
		}

		private object GetSteelPopTargetSecondary(int i)
		{
			if (i > -1 && i < secondaries.Length)
			{
				return secondaries[i];
			}
			return null;
		}

		private bool UpdateMolotov()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			Molotov val = (Molotov)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[1];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.Igniteable.IsOnFire() ? 1 : 0);
			return flag | (b != itemData.data[0]);
		}

		private bool UpdateGivenMolotov(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			bool result = false;
			Molotov val = (Molotov)dataObject;
			if (itemData.data == null)
			{
				result = true;
				if (newData[0] == 1 && !val.Igniteable.IsOnFire())
				{
					val.RemoteIgnite();
				}
			}
			else if (newData[0] == 1 && !val.Igniteable.IsOnFire())
			{
				val.RemoteIgnite();
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateMF2_RL()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			MF2_RL val = (MF2_RL)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[4];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 2);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 0);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 2);
			}
			return flag | (b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3]);
		}

		private bool UpdateGivenMF2_RL(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			MF2_RL val = (MF2_RL)dataObject;
			short num = BitConverter.ToInt16(newData, 0);
			short num2 = BitConverter.ToInt16(newData, 2);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireMF2_RL(int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			MF2_RL val = (MF2_RL)dataObject;
			val.Fire();
			return true;
		}

		private void SetMF2_RLUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			MF2_RL val = (MF2_RL)dataObject;
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateStingerLauncher()
		{
			Object obj = dataObject;
			StingerLauncher val = (StingerLauncher)(object)((obj is StingerLauncher) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[1];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_hasMissile ? 1 : 0);
			return flag | (b != itemData.data[0]);
		}

		private bool UpdateGivenStingerLauncher(byte[] newData)
		{
			bool result = false;
			Object obj = dataObject;
			StingerLauncher val = (StingerLauncher)(object)((obj is StingerLauncher) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_hasMissile = newData[0] == 1;
			}
			else if (itemData.data[0] != newData[0])
			{
				val.m_hasMissile = newData[0] == 1;
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateSingleActionRevolver()
		{
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			SingleActionRevolver val = (SingleActionRevolver)(object)((obj is SingleActionRevolver) ? obj : null);
			bool flag = false;
			int num = val.Cylinder.NumChambers * 4 + 2;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? num : (num + 4)];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.CurChamber;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.m_isHammerCocked ? 1 : 0);
			flag |= b != itemData.data[1];
			for (int i = 0; i < val.Cylinder.Chambers.Length; i++)
			{
				int num2 = i * 4 + 2;
				b = itemData.data[num2];
				byte b2 = itemData.data[num2 + 1];
				byte b3 = itemData.data[num2 + 2];
				byte b4 = itemData.data[num2 + 3];
				if ((Object)(object)val.Cylinder.Chambers[i].GetRound() == (Object)null || val.Cylinder.Chambers[i].IsSpent || val.Cylinder.Chambers[i].GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num2 + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.Cylinder.Chambers[i].GetRound().RoundType).CopyTo(itemData.data, num2);
					BitConverter.GetBytes((short)val.Cylinder.Chambers[i].GetRound().RoundClass).CopyTo(itemData.data, num2 + 2);
				}
				flag |= b != itemData.data[num2] || b2 != itemData.data[num2 + 1] || b3 != itemData.data[num2 + 2] || b4 != itemData.data[num2 + 3];
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[num];
				byte b2 = itemData.data[num + 1];
				byte b3 = itemData.data[num + 2];
				byte b4 = itemData.data[num + 3];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, num);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, num + 2);
				}
				flag |= b != itemData.data[num] || b2 != itemData.data[num + 1] || b3 != itemData.data[num + 2] || b4 != itemData.data[num + 3];
			}
			return flag;
		}

		private bool UpdateGivenSingleActionRevolver(byte[] newData)
		{
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			SingleActionRevolver val = (SingleActionRevolver)(object)((obj is SingleActionRevolver) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.CurChamber = newData[0];
				val.m_isHammerCocked = newData[1] == 1;
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.CurChamber = newData[0];
					result = true;
				}
				if (itemData.data[1] != newData[1])
				{
					val.m_isHammerCocked = newData[1] == 1;
					result = true;
				}
			}
			for (int i = 0; i < val.Cylinder.Chambers.Length; i++)
			{
				int num = i * 4 + 2;
				short num2 = BitConverter.ToInt16(newData, num);
				short num3 = BitConverter.ToInt16(newData, num + 2);
				if (num3 == -1)
				{
					if ((Object)(object)val.Cylinder.Chambers[i].GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Cylinder.Chambers[i].SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val2 = (FireArmRoundType)num2;
				FireArmRoundClass val3 = (FireArmRoundClass)num3;
				if ((Object)(object)val.Cylinder.Chambers[i].GetRound() == (Object)null || val.Cylinder.Chambers[i].GetRound().RoundClass != val3)
				{
					if (val.Cylinder.Chambers[i].RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Cylinder.Chambers[i].SetRound(val3, ((Component)val.Cylinder.Chambers[i]).transform.position, ((Component)val.Cylinder.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Cylinder.Chambers[i].RoundType;
						val.Cylinder.Chambers[i].RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Cylinder.Chambers[i].SetRound(val3, ((Component)val.Cylinder.Chambers[i]).transform.position, ((Component)val.Cylinder.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Cylinder.Chambers[i].RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				short num4 = BitConverter.ToInt16(newData, newData.Length - 4);
				short num5 = BitConverter.ToInt16(newData, newData.Length - 2);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num5 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num4;
					FireArmRoundClass val6 = (FireArmRoundClass)num5;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		public int GetSingleActionRevolverChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			SingleActionRevolver val = (SingleActionRevolver)(object)((obj is SingleActionRevolver) ? obj : null);
			List<FVRFireArmChamber> chambers = ((FVRFireArm)val).GetChambers();
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null && (Object)(object)attachableFirearmGetChamberFunc() == (Object)(object)chamber)
			{
				return chambers.Count;
			}
			for (int i = 0; i < chambers.Count; i++)
			{
				if ((Object)(object)chambers[i] == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private void ChamberSingleActionRevolverRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			SingleActionRevolver val = (SingleActionRevolver)(object)((obj is SingleActionRevolver) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == ((FVRFireArm)val).GetChambers().Count)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.position, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				((FVRFireArm)val).GetChambers()[chamberIndex].SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				((FVRFireArm)val).GetChambers()[chamberIndex].SetRound(roundClass, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.position, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateSimpleLauncher2()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			SimpleLauncher2 val = (SimpleLauncher2)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[5];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.Mode;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			byte b2 = itemData.data[2];
			byte b3 = itemData.data[3];
			byte b4 = itemData.data[4];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 3);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 1);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 3);
			}
			return flag | (b != itemData.data[1] || b2 != itemData.data[2] || b3 != itemData.data[3] || b4 != itemData.data[4]);
		}

		private bool UpdateGivenSimpleLauncher2(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			SimpleLauncher2 val = (SimpleLauncher2)dataObject;
			if (itemData.data == null)
			{
				result = true;
				val.Mode = (fMode)newData[0];
				if ((int)val.Mode == 2)
				{
					val.Mode = (fMode)1;
				}
			}
			else if (itemData.data[0] != newData[0])
			{
				val.Mode = (fMode)newData[0];
				if ((int)val.Mode == 2)
				{
					val.Mode = (fMode)1;
				}
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 1);
			short num2 = BitConverter.ToInt16(newData, 3);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireSimpleLauncher2(int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0021: 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)
			SimpleLauncher2 val = (SimpleLauncher2)dataObject;
			bool flag = false;
			if ((int)val.Mode == 0)
			{
				flag = true;
				val.Mode = (fMode)1;
			}
			val.Fire();
			if (flag)
			{
				val.Mode = (fMode)0;
			}
			return true;
		}

		private void SetSimpleLauncher2UpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			SimpleLauncher2 val = (SimpleLauncher2)dataObject;
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateSimpleLauncher()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			SimpleLauncher val = (SimpleLauncher)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[4];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 2);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 0);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 2);
			}
			return flag | (b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3]);
		}

		private bool UpdateGivenSimpleLauncher(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			SimpleLauncher val = (SimpleLauncher)dataObject;
			short num = BitConverter.ToInt16(newData, 0);
			short num2 = BitConverter.ToInt16(newData, 2);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireSimpleLauncher(int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			SimpleLauncher val = (SimpleLauncher)dataObject;
			val.Fire();
			return true;
		}

		private void SetSimpleLauncherUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			SimpleLauncher val = (SimpleLauncher)dataObject;
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateRPG7()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			RPG7 val = (RPG7)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[5];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isHammerCocked ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			byte b2 = itemData.data[2];
			byte b3 = itemData.data[3];
			byte b4 = itemData.data[4];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 3);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 1);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 3);
			}
			return flag | (b != itemData.data[1] || b2 != itemData.data[2] || b3 != itemData.data[3] || b4 != itemData.data[4]);
		}

		private bool UpdateGivenRPG7(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			RPG7 val = (RPG7)dataObject;
			if (itemData.data == null)
			{
				result = true;
				val.m_isHammerCocked = newData[0] == 1;
			}
			else if (itemData.data[0] != newData[0])
			{
				val.m_isHammerCocked = newData[0] == 1;
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 1);
			short num2 = BitConverter.ToInt16(newData, 3);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireRPG7(int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			RPG7 val = (RPG7)dataObject;
			val.Fire();
			return true;
		}

		private void SetRPG7UpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			RPG7 val = (RPG7)dataObject;
			val.m_isHammerCocked = true;
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateRollingBlock()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			RollingBlock val = (RollingBlock)dataObject;
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[5];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.m_state;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			byte b2 = itemData.data[2];
			byte b3 = itemData.data[3];
			byte b4 = itemData.data[4];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 3);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 1);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 3);
			}
			return flag | (b != itemData.data[1] || b2 != itemData.data[2] || b != itemData.data[3] || b2 != itemData.data[4]);
		}

		private bool UpdateGivenRollingBlock(byte[] newData)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			RollingBlock val = (RollingBlock)dataObject;
			if (itemData.data == null)
			{
				result = true;
				val.m_state = (RollingBlockState)newData[0];
			}
			else if (itemData.data[0] != newData[0])
			{
				val.m_state = (RollingBlockState)newData[0];
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 1);
			short num2 = BitConverter.ToInt16(newData, 3);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireRollingBlock(int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			RollingBlock val = (RollingBlock)dataObject;
			val.Fire();
			return true;
		}

		private void SetRollingBlockUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			RollingBlock val = (RollingBlock)dataObject;
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateRGM40()
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			RGM40 val = (RGM40)(object)((obj is RGM40) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[4];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 2);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 0);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 2);
			}
			return flag | (b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3]);
		}

		private bool UpdateGivenRGM40(byte[] newData)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			RGM40 val = (RGM40)(object)((obj is RGM40) ? obj : null);
			short num = BitConverter.ToInt16(newData, 0);
			short num2 = BitConverter.ToInt16(newData, 2);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireRGM40(int chamberIndex)
		{
			Object obj = dataObject;
			RGM40 val = (RGM40)(object)((obj is RGM40) ? obj : null);
			val.Fire();
			return true;
		}

		private void SetRGM40UpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			RGM40 val = (RGM40)(object)((obj is RGM40) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateRemoteMissileLauncher()
		{
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			RemoteMissileLauncher val = (RemoteMissileLauncher)(object)((obj is RemoteMissileLauncher) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)val.m_missile == (Object)null) ? 3 : 35];
				flag = true;
			}
			else if ((Object)(object)val.m_missile == (Object)null)
			{
				if (itemData.data.Length == 35)
				{
					itemData.data = new byte[3];
					flag = true;
				}
			}
			else if (itemData.data.Length == 3)
			{
				itemData.data = new byte[35];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.IsPoweredUp ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.Chamber.IsFull ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = ((!((Object)(object)val.m_missile == (Object)null)) ? ((byte)1) : ((byte)0));
			flag |= b != itemData.data[2];
			if ((Object)(object)val.m_missile != (Object)null)
			{
				flag = true;
				BitConverter.GetBytes(((Component)val.m_missile).transform.position.x).CopyTo(itemData.data, 3);
				BitConverter.GetBytes(((Component)val.m_missile).transform.position.y).CopyTo(itemData.data, 7);
				BitConverter.GetBytes(((Component)val.m_missile).transform.position.z).CopyTo(itemData.data, 11);
				Quaternion rotation = ((Component)val.m_missile).transform.rotation;
				BitConverter.GetBytes(((Quaternion)(ref rotation)).eulerAngles.x).CopyTo(itemData.data, 15);
				rotation = ((Component)val.m_missile).transform.rotation;
				BitConverter.GetBytes(((Quaternion)(ref rotation)).eulerAngles.y).CopyTo(itemData.data, 19);
				rotation = ((Component)val.m_missile).transform.rotation;
				BitConverter.GetBytes(((Quaternion)(ref rotation)).eulerAngles.z).CopyTo(itemData.data, 23);
				BitConverter.GetBytes(val.m_missile.speed).CopyTo(itemData.data, 27);
				BitConverter.GetBytes(val.m_missile.tarSpeed).CopyTo(itemData.data, 31);
			}
			return flag;
		}

		private bool UpdateGivenRemoteMissileLauncher(byte[] newData)
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			RemoteMissileLauncher val = (RemoteMissileLauncher)(object)((obj is RemoteMissileLauncher) ? obj : null);
			if ((val.IsPoweredUp && newData[0] == 0) || (!val.IsPoweredUp && newData[0] == 1))
			{
				val.TogglePower();
				result = true;
			}
			if (newData[1] == 0)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else if ((Object)(object)val.Chamber.GetRound() == (Object)null)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FireArmRoundClass)15, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
				result = true;
			}
			if ((Object)(object)val.m_missile != (Object)null && newData[2] == 1)
			{
				((Component)val.m_missile).transform.position = new Vector3(BitConverter.ToSingle(newData, 3), BitConverter.ToSingle(newData, 7), BitConverter.ToSingle(newData, 11));
				((Component)val.m_missile).transform.rotation = Quaternion.Euler(BitConverter.ToSingle(newData, 15), BitConverter.ToSingle(newData, 19), BitConverter.ToSingle(newData, 23));
				val.m_missile.speed = BitConverter.ToSingle(newData, 27);
				val.m_missile.tarSpeed = BitConverter.ToSingle(newData, 31);
			}
			itemData.data = newData;
			return result;
		}

		private bool FireRemoteMissileLauncher(int chamberIndex)
		{
			Object obj = dataObject;
			RemoteMissileLauncher val = (RemoteMissileLauncher)(object)((obj is RemoteMissileLauncher) ? obj : null);
			val.FireShot();
			return true;
		}

		private void SetRemoteMissileLauncherUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			RemoteMissileLauncher val = (RemoteMissileLauncher)(object)((obj is RemoteMissileLauncher) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdatePotatoGun()
		{
			Object obj = dataObject;
			PotatoGun val = (PotatoGun)(object)((obj is PotatoGun) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[5];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			BitConverter.GetBytes(val.m_chamberGas).CopyTo(itemData.data, 0);
			flag |= b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3];
			b = itemData.data[4];
			itemData.data[4] = (byte)(val.Chamber.IsFull ? 1 : 0);
			return flag | (b != itemData.data[4]);
		}

		private bool UpdateGivenPotatoGun(byte[] newData)
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			PotatoGun val = (PotatoGun)(object)((obj is PotatoGun) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_chamberGas = BitConverter.ToSingle(newData, 0);
			}
			else if (itemData.data[0] != newData[0] || itemData.data[1] != newData[1] || itemData.data[2] != newData[2] || itemData.data[3] != newData[3])
			{
				val.m_chamberGas = BitConverter.ToSingle(newData, 0);
				result = true;
			}
			if (newData[4] == 0)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else if ((Object)(object)val.Chamber.GetRound() == (Object)null)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FireArmRoundClass)1, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool FirePotatoGun(int chamberIndex)
		{
			Object obj = dataObject;
			PotatoGun val = (PotatoGun)(object)((obj is PotatoGun) ? obj : null);
			val.Fire();
			return true;
		}

		private void SetPotatoGunUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			PotatoGun val = (PotatoGun)(object)((obj is PotatoGun) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateMinigun()
		{
			Object obj = dataObject;
			Minigun val = (Minigun)(object)((obj is Minigun) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[5];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			BitConverter.GetBytes(val.m_motorRate).CopyTo(itemData.data, 0);
			flag |= b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3];
			b = itemData.data[4];
			itemData.data[4] = (byte)(val.m_isTriggerEngaged ? 1 : 0);
			return flag | (b != itemData.data[4]);
		}

		private bool UpdateGivenMinigun(byte[] newData)
		{
			bool result = false;
			Object obj = dataObject;
			Minigun val = (Minigun)(object)((obj is Minigun) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_motorRate = BitConverter.ToSingle(newData, 0);
				val.m_tarMotorRate = val.m_motorRate;
			}
			else
			{
				if (itemData.data[0] != newData[0] || itemData.data[1] != newData[1] || itemData.data[2] != newData[2] || itemData.data[3] != newData[3])
				{
					result = true;
				}
				val.m_motorRate = BitConverter.ToSingle(newData, 0);
				val.m_tarMotorRate = val.m_motorRate;
			}
			val.m_isTriggerEngaged = newData[4] == 1;
			itemData.data = newData;
			return result;
		}

		private bool UpdateM72()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			M72 val = (M72)(object)((obj is M72) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[4];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isSafetyEngaged ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.CanTubeBeGrabbed() ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)val.TState;
			flag |= b != itemData.data[2];
			b = itemData.data[3];
			itemData.data[3] = (byte)(val.Chamber.IsFull ? 1 : 0);
			return flag | (b != itemData.data[3]);
		}

		private bool UpdateGivenM72(byte[] newData)
		{
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Invalid comparison between Unknown and I4
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Invalid comparison between Unknown and I4
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Invalid comparison between Unknown and I4
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Invalid comparison between Unknown and I4
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Invalid comparison between Unknown and I4
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			M72 val = (M72)(object)((obj is M72) ? obj : null);
			if (itemData.data == null)
			{
				flag = true;
				bool isSafetyEngaged = val.m_isSafetyEngaged;
				if ((isSafetyEngaged && newData[0] == 0) || (!isSafetyEngaged && newData[0] == 1))
				{
					val.ToggleSafety();
				}
				if ((val.CanTubeBeGrabbed() && newData[1] == 0) || (!val.CanTubeBeGrabbed() && newData[1] == 1))
				{
					val.ToggleCap();
				}
				if (((int)val.TState == 0 || (int)val.TState == 1) && newData[2] == 2)
				{
					val.TState = (TubeState)2;
					((Component)val.Tube).transform.localPosition = val.Tube_Rear.localPosition;
				}
				else if (((int)val.TState == 1 || (int)val.TState == 2) && newData[2] == 0)
				{
					val.TState = (TubeState)0;
					((Component)val.Tube).transform.localPosition = val.Tube_Front.localPosition;
				}
			}
			else
			{
				bool isSafetyEngaged2 = val.m_isSafetyEngaged;
				if ((isSafetyEngaged2 && newData[0] == 0) || (!isSafetyEngaged2 && newData[0] == 1))
				{
					val.ToggleSafety();
					flag = true;
				}
				if ((val.CanTubeBeGrabbed() && newData[1] == 0) || (!val.CanTubeBeGrabbed() && newData[1] == 1))
				{
					val.ToggleCap();
				}
				flag = true;
				if (((int)val.TState == 0 || (int)val.TState == 1) && newData[2] == 2)
				{
					val.TState = (TubeState)2;
					((Component)val.Tube).transform.localPosition = val.Tube_Rear.localPosition;
					flag = true;
				}
				else if (((int)val.TState == 1 || (int)val.TState == 2) && newData[2] == 0)
				{
					val.TState = (TubeState)0;
					((Component)val.Tube).transform.localPosition = val.Tube_Front.localPosition;
					flag = true;
				}
			}
			if (newData[3] == 0)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					flag = true;
				}
			}
			else if ((Object)(object)val.Chamber.GetRound() == (Object)null)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FireArmRoundClass)15, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
				flag = true;
			}
			itemData.data = newData;
			return flag;
		}

		private bool FireM72(int chamberIndex)
		{
			Object obj = dataObject;
			M72 val = (M72)(object)((obj is M72) ? obj : null);
			val.Fire();
			return true;
		}

		private void SetM72UpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			M72 val = (M72)(object)((obj is M72) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateOpenBoltReceiver()
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			OpenBoltReceiver val = (OpenBoltReceiver)(object)((obj is OpenBoltReceiver) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? 6 : 10];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.FireSelectorModeIndex;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)val.m_CamBurst;
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			flag |= b != itemData.data[2] || b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5];
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[6];
				b2 = itemData.data[7];
				b3 = itemData.data[8];
				b4 = itemData.data[9];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 8);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, 6);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, 8);
				}
				flag |= b != itemData.data[6] || b2 != itemData.data[7] || b3 != itemData.data[8] || b4 != itemData.data[9];
			}
			return flag;
		}

		private bool UpdateGivenOpenBoltReceiver(byte[] newData)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			OpenBoltReceiver val = (OpenBoltReceiver)(object)((obj is OpenBoltReceiver) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_fireSelectorMode = newData[0];
				val.m_CamBurst = newData[1];
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_fireSelectorMode = newData[0];
					result = true;
				}
				if (itemData.data[1] != newData[1])
				{
					val.m_CamBurst = newData[1];
					result = true;
				}
			}
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				num = BitConverter.ToInt16(newData, 6);
				num2 = BitConverter.ToInt16(newData, 8);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num2 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num;
					FireArmRoundClass val6 = (FireArmRoundClass)num2;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private void SetOBRUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			OpenBoltReceiver val = (OpenBoltReceiver)(object)((obj is OpenBoltReceiver) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			if (AM.DoesClassExistForType(roundClass, roundType))
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			else
			{
				val.Chamber.Autochamber(val.Chamber.AutoChamberClass);
			}
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private int GetOpenBoltReceiverChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			OpenBoltReceiver val = (OpenBoltReceiver)(object)((obj is OpenBoltReceiver) ? obj : null);
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null)
			{
				return 0;
			}
			return (!((Object)(object)chamber == (Object)(object)val.Chamber)) ? 1 : 0;
		}

		private void ChamberOpenBoltReceiverRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_009a: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			OpenBoltReceiver val = (OpenBoltReceiver)(object)((obj is OpenBoltReceiver) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == 1)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool FireOBR(int chamberIndex)
		{
			Object obj = dataObject;
			return ((OpenBoltReceiver)((obj is OpenBoltReceiver) ? obj : null)).Fire();
		}

		private bool UpdateHCB()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			HCB val = (HCB)(object)((obj is HCB) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[6];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.m_sledState;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.Chamber.IsAccessible ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			return flag | (b != itemData.data[2] || b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5]);
		}

		private bool UpdateGivenHCB(byte[] newData)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			HCB val = (HCB)(object)((obj is HCB) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_sledState = (SledState)newData[0];
				val.Chamber.IsAccessible = newData[1] == 1;
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_sledState = (SledState)newData[0];
					result = true;
				}
				if (itemData.data[1] != newData[1])
				{
					val.Chamber.IsAccessible = newData[1] == 1;
					result = true;
				}
			}
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateGrappleGun()
		{
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			GrappleGun val = (GrappleGun)(object)((obj is GrappleGun) ? obj : null);
			bool flag = false;
			int num = val.Chambers.Length * 4 + 2;
			if (itemData.data == null)
			{
				itemData.data = new byte[num];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.m_curChamber;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.IsMagLoaded ? 1 : 0);
			flag |= b != itemData.data[1];
			for (int i = 0; i < val.Chambers.Length; i++)
			{
				int num2 = i * 4 + 2;
				b = itemData.data[num2];
				byte b2 = itemData.data[num2 + 1];
				byte b3 = itemData.data[num2 + 2];
				byte b4 = itemData.data[num2 + 3];
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].IsSpent || val.Chambers[i].GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num2 + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundType).CopyTo(itemData.data, num2);
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundClass).CopyTo(itemData.data, num2 + 2);
				}
				flag |= b != itemData.data[num2] || b2 != itemData.data[num2 + 1] || b3 != itemData.data[num2 + 2] || b4 != itemData.data[num2 + 3];
			}
			return flag;
		}

		private bool UpdateGivenGrappleGun(byte[] newData)
		{
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			GrappleGun val = (GrappleGun)(object)((obj is GrappleGun) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_curChamber = newData[0];
				bool flag = newData[1] == 1;
				if (flag && !val.IsMagLoaded)
				{
					val.ProxyMag.gameObject.SetActive(true);
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
				}
				else if (!flag && val.IsMagLoaded)
				{
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)21, 1f);
					((FVRFireArm)val).EjectDelay = 0.4f;
					val.ProxyMag.gameObject.SetActive(false);
				}
				val.IsMagLoaded = flag;
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_curChamber = newData[0];
					result = true;
				}
				bool flag2 = newData[1] == 1;
				if (flag2 && !val.IsMagLoaded)
				{
					val.ProxyMag.gameObject.SetActive(true);
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
					result = true;
				}
				else if (!flag2 && val.IsMagLoaded)
				{
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)21, 1f);
					((FVRFireArm)val).EjectDelay = 0.4f;
					val.ProxyMag.gameObject.SetActive(false);
					result = true;
				}
				val.IsMagLoaded = flag2;
			}
			for (int i = 0; i < val.Chambers.Length; i++)
			{
				int num = i * 4 + 2;
				short num2 = BitConverter.ToInt16(newData, num);
				short num3 = BitConverter.ToInt16(newData, num + 2);
				if (num3 == -1)
				{
					if ((Object)(object)val.Chambers[i].GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val2 = (FireArmRoundType)num2;
				FireArmRoundClass val3 = (FireArmRoundClass)num3;
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].GetRound().RoundClass != val3)
				{
					if (val.Chambers[i].RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chambers[i].RoundType;
						val.Chambers[i].RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chambers[i].RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		public int GetGrappleGunChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			GrappleGun val = (GrappleGun)(object)((obj is GrappleGun) ? obj : null);
			FVRFireArmChamber[] chambers = val.Chambers;
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			for (int i = 0; i < chambers.Length; i++)
			{
				if ((Object)(object)chambers[i] == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private bool UpdateGBeamer()
		{
			Object obj = dataObject;
			GBeamer val = (GBeamer)(object)((obj is GBeamer) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[7];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isBatterySwitchedOn ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.m_isCapacitorSwitchedOn ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)(val.m_isMotorSwitchedOn ? 1 : 0);
			flag |= b != itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			byte b5 = itemData.data[6];
			BitConverter.GetBytes(val.m_capacitorCharge).CopyTo(itemData.data, 3);
			return flag | (b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5] || b5 != itemData.data[6]);
		}

		private bool UpdateGivenGBeamer(byte[] newData)
		{
			bool result = false;
			Object obj = dataObject;
			GBeamer val = (GBeamer)(object)((obj is GBeamer) ? obj : null);
			if ((val.m_isBatterySwitchedOn && newData[0] == 0) || (!val.m_isBatterySwitchedOn && newData[0] == 1))
			{
				val.BatterySwitch.ToggleSwitch(false);
				result = true;
			}
			if ((val.m_isCapacitorSwitchedOn && newData[1] == 0) || (!val.m_isCapacitorSwitchedOn && newData[1] == 1))
			{
				val.CapacitorSwitch.ToggleSwitch(false);
				result = true;
			}
			if ((val.m_isMotorSwitchedOn && newData[2] == 0) || (!val.m_isMotorSwitchedOn && newData[2] == 1))
			{
				val.MotorSwitch.ToggleSwitch(false);
				result = true;
			}
			float num = BitConverter.ToSingle(newData, 3);
			if (val.m_capacitorCharge != num)
			{
				val.m_capacitorCharge = num;
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateFlintlockWeapon()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			FVRPhysicalObject obj = physicalItem;
			FlintlockWeapon val = (FlintlockWeapon)(object)((obj is FlintlockWeapon) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[6];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.HammerState;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.HasFlint() ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)val.FState;
			flag |= b != itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			itemData.data[3] = (byte)(int)val.m_flintUses.x;
			itemData.data[4] = (byte)(int)val.m_flintUses.y;
			itemData.data[5] = (byte)(int)val.m_flintUses.z;
			return flag | (b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5]);
		}

		private unsafe bool UpdateGivenFlintlockWeapon(byte[] newData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			FVRPhysicalObject obj = physicalItem;
			FlintlockWeapon val = (FlintlockWeapon)(object)((obj is FlintlockWeapon) ? obj : null);
			HState hammerState = val.HammerState;
			val.HammerState = (HState)newData[0];
			flag |= hammerState != val.HammerState;
			bool flag2 = val.HasFlint();
			val.m_hasFlint = newData[1] == 1;
			flag |= flag2 ^ val.HasFlint();
			FlintState fState = val.FState;
			val.FState = (FlintState)newData[2];
			flag |= fState != val.FState;
			Vector3 flintUses = val.m_flintUses;
			Vector3 zero = Vector3.zero;
			zero.x = (int)newData[3];
			zero.y = (int)newData[4];
			zero.z = (int)newData[5];
			val.m_flintUses = zero;
			flag |= !((object)(*(Vector3*)(&flintUses))/*cast due to .constrained prefix*/).Equals((object?)zero);
			itemData.data = newData;
			return flag;
		}

		private bool UpdateFlaregun()
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Flaregun val = (Flaregun)(object)((obj is Flaregun) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[6];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isHammerCocked ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			byte b2 = itemData.data[2];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 3);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 1);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 3);
			}
			flag |= b != itemData.data[1] || b2 != itemData.data[2];
			b = itemData.data[5];
			itemData.data[5] = (byte)val.m_hingeState;
			return flag | (b != itemData.data[5]);
		}

		private bool UpdateGivenFlaregun(byte[] newData)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Invalid comparison between Unknown and I4
			//IL_00d7: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Invalid comparison between Unknown and I4
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Invalid comparison between Unknown and I4
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Invalid comparison between Unknown and I4
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Invalid comparison between Unknown and I4
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			Flaregun val = (Flaregun)(object)((obj is Flaregun) ? obj : null);
			bool isHammerCocked = val.m_isHammerCocked;
			val.SetHammerCocked(newData[0] == 1);
			flag |= isHammerCocked ^ (newData[0] == 1);
			short num = BitConverter.ToInt16(newData, 1);
			short num2 = BitConverter.ToInt16(newData, 3);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					flag = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					flag = true;
				}
			}
			HingeState val4 = (HingeState)newData[5];
			if ((int)val.m_hingeState == 2 && ((int)val4 == 1 || (int)val4 == 0))
			{
				val.Latch();
				val.m_hingeState = (HingeState)0;
				val.m_hingeLerp = 0f;
				((FVRPhysicalObject)val).SetAnimatedComponent(val.Hinge, Mathf.Lerp(0f, val.RotOut, val.m_hingeLerp), (InterpStyle)1, val.HingeAxis);
				flag = true;
			}
			else if ((int)val.m_hingeState == 0 && ((int)val4 == 3 || (int)val4 == 2))
			{
				val.Unlatch();
				val.m_hingeState = (HingeState)2;
				val.m_hingeLerp = 1f;
				((FVRPhysicalObject)val).SetAnimatedComponent(val.Hinge, Mathf.Lerp(0f, val.RotOut, val.m_hingeLerp), (InterpStyle)1, val.HingeAxis);
				flag = true;
			}
			itemData.data = newData;
			return flag;
		}

		private bool FireFlaregun(int chamberIndex)
		{
			Object obj = dataObject;
			((Flaregun)((obj is Flaregun) ? obj : null)).Fire();
			return true;
		}

		private void SetFlaregunUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Flaregun val = (Flaregun)(object)((obj is Flaregun) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateFlameThrower()
		{
			Object obj = dataObject;
			FlameThrower val = (FlameThrower)(object)((obj is FlameThrower) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[1];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.m_isFiring ? 1 : 0);
			return flag | (b != itemData.data[0]);
		}

		private bool UpdateGivenFlameThrower(byte[] newData)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			FlameThrower val = (FlameThrower)(object)((obj is FlameThrower) ? obj : null);
			if (val.m_isFiring && newData[0] == 0)
			{
				val.StopFiring();
				result = true;
			}
			else if (!val.m_isFiring && newData[0] == 1)
			{
				val.m_hasFiredStartSound = true;
				SM.PlayCoreSound((FVRPooledAudioType)10, val.AudEvent_Ignite, ((FVRFireArm)val).GetMuzzle().position);
				val.AudSource_FireLoop.volume = 0.4f;
				float num = (val.UsesValve ? val.Valve.ValvePos : ((!val.UsesMF2Valve) ? 0.5f : val.MF2Valve.Lerp));
				val.AudSource_FireLoop.pitch = Mathf.Lerp(val.AudioPitchRange.x, val.AudioPitchRange.y, num);
				if (!val.AudSource_FireLoop.isPlaying)
				{
					val.AudSource_FireLoop.Play();
				}
				val.m_isFiring = true;
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateCarlGustaf()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			CarlGustaf val = (CarlGustaf)(object)((obj is CarlGustaf) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[9];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			byte b5 = itemData.data[8];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 2);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 0);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 2);
				itemData.data[8] = (byte)((val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent) ? 1 : 0);
			}
			flag |= b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3] || b5 != itemData.data[8];
			b = itemData.data[4];
			itemData.data[4] = (byte)val.CHState;
			flag |= b != itemData.data[4];
			b = itemData.data[5];
			itemData.data[5] = (byte)val.TailLatch.LState;
			flag |= b != itemData.data[5];
			b = itemData.data[6];
			itemData.data[6] = (byte)val.ShellInsertEject.CSState;
			flag |= b != itemData.data[6];
			b = itemData.data[7];
			itemData.data[7] = (byte)val.TailLatch.RestrictingLatch.LState;
			return flag | (b != itemData.data[7]);
		}

		private bool UpdateGivenCarlGustaf(byte[] newData)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Invalid comparison between Unknown and I4
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Invalid comparison between Unknown and I4
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Invalid comparison between Unknown and I4
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Invalid comparison between Unknown and I4
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_071c: Invalid comparison between Unknown and I4
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_065f: Invalid comparison between Unknown and I4
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_0637: Unknown result type (might be due to invalid IL or missing references)
			//IL_074d: Unknown result type (might be due to invalid IL or missing references)
			//IL_076d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0792: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0704: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_099c: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a2: Invalid comparison between Unknown and I4
			//IL_08d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08dd: Invalid comparison between Unknown and I4
			//IL_096e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0985: Unknown result type (might be due to invalid IL or missing references)
			//IL_0899: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a54: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			CarlGustaf val = (CarlGustaf)(object)((obj is CarlGustaf) ? obj : null);
			short num = BitConverter.ToInt16(newData, 0);
			short num2 = BitConverter.ToInt16(newData, 2);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
				if (newData[8] == 1 && !val.Chamber.IsSpent)
				{
					val.Chamber.Fire();
				}
			}
			if (newData[4] == 0)
			{
				if ((int)val.CHState > 0)
				{
					val.m_curZ = val.ChargingHandForward.localPosition.z;
					val.m_tarZ = val.ChargingHandForward.localPosition.z;
					val.ChargingHandle.localPosition = new Vector3(val.ChargingHandle.localPosition.x, val.ChargingHandle.localPosition.y, val.ChargingHandForward.localPosition.z);
					val.CHState = (ChargingHandleState)0;
				}
			}
			else if (newData[4] == 1)
			{
				if ((int)val.CHState != 1)
				{
					float num3 = (val.m_tarZ = (val.m_curZ = Mathf.Lerp(val.ChargingHandForward.localPosition.z, val.ChargingHandBack.localPosition.z, 0.5f)));
					val.ChargingHandle.localPosition = new Vector3(val.ChargingHandle.localPosition.x, val.ChargingHandle.localPosition.y, num3);
					val.CHState = (ChargingHandleState)1;
				}
			}
			else if ((int)val.CHState != 2)
			{
				val.m_curZ = val.ChargingHandBack.localPosition.z;
				val.m_tarZ = val.ChargingHandBack.localPosition.z;
				val.ChargingHandle.localPosition = new Vector3(val.ChargingHandle.localPosition.x, val.ChargingHandle.localPosition.y, val.ChargingHandBack.localPosition.z);
				val.CHState = (ChargingHandleState)2;
			}
			if (newData[5] == 0)
			{
				if ((int)val.TailLatch.LState != 0 && (Object)(object)((FVRInteractiveObject)val.TailLatch).m_hand == (Object)null)
				{
					float num4 = (val.TailLatch.IsMinOpen ? val.TailLatch.RotMax : val.TailLatch.RotMin);
					val.TailLatch.m_curRot = num4;
					val.TailLatch.m_tarRot = num4;
					((Component)val.TailLatch).transform.localEulerAngles = new Vector3(0f, num4, 0f);
					val.TailLatch.LState = (CGLatchState)0;
				}
			}
			else if (newData[5] == 1)
			{
				if ((int)val.TailLatch.LState != 1 && (Object)(object)((FVRInteractiveObject)val.TailLatch).m_hand == (Object)null)
				{
					float num5 = Mathf.Lerp(val.TailLatch.RotMin, val.TailLatch.RotMax, 0.5f);
					val.TailLatch.m_curRot = num5;
					val.TailLatch.m_tarRot = num5;
					((Component)val.TailLatch).transform.localEulerAngles = new Vector3(0f, num5, 0f);
					val.TailLatch.LState = (CGLatchState)1;
				}
			}
			else if ((int)val.TailLatch.LState != 2 && (Object)(object)((FVRInteractiveObject)val.TailLatch).m_hand == (Object)null)
			{
				float num6 = (val.TailLatch.IsMinOpen ? val.TailLatch.RotMin : val.TailLatch.RotMax);
				val.TailLatch.m_curRot = num6;
				val.TailLatch.m_tarRot = num6;
				((Component)val.TailLatch).transform.localEulerAngles = new Vector3(0f, num6, 0f);
				val.TailLatch.LState = (CGLatchState)2;
			}
			if (newData[6] == 0)
			{
				if ((int)val.ShellInsertEject.CSState != 0 && (Object)(object)((FVRInteractiveObject)val.ShellInsertEject).m_hand == (Object)null)
				{
					val.ShellInsertEject.m_curZ = val.ShellInsertEject.ChamberPoint_Forward.localPosition.z;
					val.ShellInsertEject.m_tarZ = val.ShellInsertEject.ChamberPoint_Forward.localPosition.z;
					((Component)val.Chamber).transform.localPosition = new Vector3(((Component)val.Chamber).transform.localPosition.x, ((Component)val.Chamber).transform.localPosition.y, val.ShellInsertEject.ChamberPoint_Forward.localPosition.z);
					val.ShellInsertEject.CSState = (ChamberSlideState)0;
				}
			}
			else if (newData[6] == 1)
			{
				if ((int)val.ShellInsertEject.CSState != 1 && (Object)(object)((FVRInteractiveObject)val.ShellInsertEject).m_hand == (Object)null)
				{
					float num7 = Mathf.Lerp(val.TailLatch.RotMin, val.TailLatch.RotMax, 0.5f);
					val.ShellInsertEject.m_curZ = num7;
					val.ShellInsertEject.m_tarZ = num7;
					((Component)val.Chamber).transform.localPosition = new Vector3(((Component)val.Chamber).transform.localPosition.x, ((Component)val.Chamber).transform.localPosition.y, num7);
					val.ShellInsertEject.CSState = (ChamberSlideState)1;
				}
			}
			else if ((int)val.ShellInsertEject.CSState != 2 && (Object)(object)((FVRInteractiveObject)val.ShellInsertEject).m_hand == (Object)null)
			{
				val.ShellInsertEject.m_curZ = val.ShellInsertEject.ChamberPoint_Back.localPosition.z;
				val.ShellInsertEject.m_tarZ = val.ShellInsertEject.ChamberPoint_Back.localPosition.z;
				((Component)val.Chamber).transform.localPosition = new Vector3(((Component)val.Chamber).transform.localPosition.x, ((Component)val.Chamber).transform.localPosition.y, val.ShellInsertEject.ChamberPoint_Back.localPosition.z);
				val.ShellInsertEject.CSState = (ChamberSlideState)2;
			}
			if (newData[7] == 0)
			{
				if ((int)val.TailLatch.RestrictingLatch.LState != 0 && (Object)(object)((FVRInteractiveObject)val.TailLatch.RestrictingLatch).m_hand == (Object)null)
				{
					float num8 = (val.TailLatch.RestrictingLatch.IsMinOpen ? val.TailLatch.RestrictingLatch.RotMax : val.TailLatch.RestrictingLatch.RotMin);
					val.TailLatch.RestrictingLatch.m_curRot = num8;
					val.TailLatch.RestrictingLatch.m_tarRot = num8;
					((Component)val.TailLatch.RestrictingLatch).transform.localEulerAngles = new Vector3(0f, num8, 0f);
					val.TailLatch.RestrictingLatch.LState = (CGLatchState)0;
				}
			}
			else if (newData[7] == 1)
			{
				if ((int)val.TailLatch.RestrictingLatch.LState != 1 && (Object)(object)((FVRInteractiveObject)val.TailLatch.RestrictingLatch).m_hand == (Object)null)
				{
					float num9 = Mathf.Lerp(val.TailLatch.RestrictingLatch.RotMin, val.TailLatch.RestrictingLatch.RotMax, 0.5f);
					val.TailLatch.RestrictingLatch.m_curRot = num9;
					val.TailLatch.RestrictingLatch.m_tarRot = num9;
					((Component)val.TailLatch.RestrictingLatch).transform.localEulerAngles = new Vector3(0f, num9, 0f);
					val.TailLatch.RestrictingLatch.LState = (CGLatchState)1;
				}
			}
			else if ((int)val.TailLatch.RestrictingLatch.LState != 2 && (Object)(object)((FVRInteractiveObject)val.TailLatch.RestrictingLatch).m_hand == (Object)null)
			{
				float num10 = (val.TailLatch.RestrictingLatch.IsMinOpen ? val.TailLatch.RestrictingLatch.RotMin : val.TailLatch.RestrictingLatch.RotMax);
				val.TailLatch.RestrictingLatch.m_curRot = num10;
				val.TailLatch.RestrictingLatch.m_tarRot = num10;
				((Component)val.TailLatch.RestrictingLatch).transform.localEulerAngles = new Vector3(0f, num10, 0f);
				val.TailLatch.RestrictingLatch.LState = (CGLatchState)2;
			}
			itemData.data = newData;
			return result;
		}

		private void ChamberCarlGustafRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			CarlGustaf val = (CarlGustaf)(object)((obj is CarlGustaf) ? obj : null);
			ChamberPatch.chamberSkip++;
			if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool FireCarlGustaf(int chamberIndex)
		{
			Object obj = dataObject;
			((CarlGustaf)((obj is CarlGustaf) ? obj : null)).TryToFire();
			return true;
		}

		private void SetCarlGustafUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			CarlGustaf val = (CarlGustaf)(object)((obj is CarlGustaf) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateLeverActionFirearm()
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			LeverActionFirearm val = (LeverActionFirearm)(object)((obj is LeverActionFirearm) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? 10 : 14];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 2);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 0);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 2);
			}
			flag |= b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3];
			b = itemData.data[4];
			itemData.data[4] = (byte)(val.IsHammerCocked ? 1 : 0);
			flag |= b != itemData.data[4];
			if (val.UsesSecondChamber)
			{
				b = itemData.data[5];
				b2 = itemData.data[6];
				b3 = itemData.data[7];
				b4 = itemData.data[8];
				if ((Object)(object)val.Chamber2.GetRound() == (Object)null || val.Chamber2.IsSpent || val.Chamber2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 7);
				}
				else
				{
					BitConverter.GetBytes((short)val.Chamber2.GetRound().RoundType).CopyTo(itemData.data, 5);
					BitConverter.GetBytes((short)val.Chamber2.GetRound().RoundClass).CopyTo(itemData.data, 7);
				}
				flag |= b != itemData.data[5] || b2 != itemData.data[6] || b3 != itemData.data[7] || b4 != itemData.data[8];
				b = itemData.data[9];
				itemData.data[9] = (byte)(val.m_isHammerCocked2 ? 1 : 0);
				flag |= b != itemData.data[9];
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[10];
				b2 = itemData.data[11];
				b3 = itemData.data[12];
				b4 = itemData.data[13];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 12);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, 10);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, 12);
				}
				flag |= b != itemData.data[10] || b2 != itemData.data[11] || b3 != itemData.data[12] || b4 != itemData.data[13];
			}
			return flag;
		}

		private bool UpdateGivenLeverActionFirearm(byte[] newData)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			LeverActionFirearm val = (LeverActionFirearm)(object)((obj is LeverActionFirearm) ? obj : null);
			short num = BitConverter.ToInt16(newData, 0);
			short num2 = BitConverter.ToInt16(newData, 2);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			val.m_isHammerCocked = newData[4] == 1;
			if (val.UsesSecondChamber)
			{
				num = BitConverter.ToInt16(newData, 5);
				num2 = BitConverter.ToInt16(newData, 7);
				if (num2 == -1)
				{
					if ((Object)(object)val.Chamber2.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber2.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val4 = (FireArmRoundType)num;
					FireArmRoundClass val5 = (FireArmRoundClass)num2;
					if ((Object)(object)val.Chamber2.GetRound() == (Object)null || val.Chamber2.GetRound().RoundClass != val5)
					{
						if (val.Chamber2.RoundType == val4)
						{
							ChamberPatch.chamberSkip++;
							val.Chamber2.SetRound(val5, ((Component)val.Chamber2).transform.position, ((Component)val.Chamber2).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val.Chamber2.RoundType;
							val.Chamber2.RoundType = val4;
							ChamberPatch.chamberSkip++;
							val.Chamber2.SetRound(val5, ((Component)val.Chamber2).transform.position, ((Component)val.Chamber2).transform.rotation);
							ChamberPatch.chamberSkip--;
							val.Chamber2.RoundType = roundType2;
						}
						result = true;
					}
				}
				val.m_isHammerCocked2 = newData[9] == 1;
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				num = BitConverter.ToInt16(newData, newData.Length - 4);
				num2 = BitConverter.ToInt16(newData, newData.Length - 2);
				FVRFireArmChamber val6 = attachableFirearmGetChamberFunc();
				if (num2 == -1)
				{
					if ((Object)(object)val6.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val6.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val7 = (FireArmRoundType)num;
					FireArmRoundClass val8 = (FireArmRoundClass)num2;
					if ((Object)(object)val6.GetRound() == (Object)null || val6.GetRound().RoundClass != val8)
					{
						if (val6.RoundType == val7)
						{
							ChamberPatch.chamberSkip++;
							val6.SetRound(val8, ((Component)val6).transform.position, ((Component)val6).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType3 = val6.RoundType;
							val6.RoundType = val7;
							ChamberPatch.chamberSkip++;
							val6.SetRound(val8, ((Component)val6).transform.position, ((Component)val6).transform.rotation);
							ChamberPatch.chamberSkip--;
							val6.RoundType = roundType3;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private int GetLeverActionFirearmChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			LeverActionFirearm val = (LeverActionFirearm)(object)((obj is LeverActionFirearm) ? obj : null);
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			if ((Object)(object)val.Chamber == (Object)(object)chamber)
			{
				return 0;
			}
			if ((Object)(object)val.Chamber2 == (Object)(object)chamber)
			{
				return 1;
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null && (Object)(object)attachableFirearmGetChamberFunc() == (Object)(object)chamber)
			{
				return 2;
			}
			return -1;
		}

		private void ChamberLeverActionFirearmRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			LeverActionFirearm val = (LeverActionFirearm)(object)((obj is LeverActionFirearm) ? obj : null);
			switch (chamberIndex)
			{
			case 0:
				ChamberPatch.chamberSkip++;
				if ((int)roundClass == -1)
				{
					val.Chamber.SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				}
				ChamberPatch.chamberSkip--;
				break;
			case 1:
				ChamberPatch.chamberSkip++;
				if ((int)roundClass == -1)
				{
					val.Chamber2.SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					val.Chamber2.SetRound(roundClass, ((Component)val.Chamber2).transform.position, ((Component)val.Chamber2).transform.rotation);
				}
				ChamberPatch.chamberSkip--;
				break;
			case 2:
				ChamberPatch.chamberSkip++;
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chamber2).transform.position, ((Component)val.Chamber2).transform.rotation);
				}
				ChamberPatch.chamberSkip--;
				break;
			}
		}

		private bool UpdateDerringer()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Derringer val = (Derringer)(object)((obj is Derringer) ? obj : null);
			bool flag = false;
			int num = val.Barrels.Count * 4 + 3;
			if (itemData.data == null)
			{
				itemData.data = new byte[num];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.IsExternalHammerCocked() ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)val.m_hingeState;
			flag |= b != itemData.data[1];
			if ((Object)(object)integratedLaser != (Object)null)
			{
				b = itemData.data[2];
				itemData.data[2] = (byte)(integratedLaser.m_isOn ? 1 : 0);
				flag |= b != itemData.data[2];
			}
			for (int i = 0; i < val.Barrels.Count; i++)
			{
				int num2 = i * 4 + 3;
				b = itemData.data[num2];
				byte b2 = itemData.data[num2 + 1];
				byte b3 = itemData.data[num2 + 2];
				byte b4 = itemData.data[num2 + 3];
				if ((Object)(object)val.Barrels[i].Chamber.GetRound() == (Object)null || val.Barrels[i].Chamber.IsSpent || val.Barrels[i].Chamber.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num2 + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.Barrels[i].Chamber.GetRound().RoundType).CopyTo(itemData.data, num2);
					BitConverter.GetBytes((short)val.Barrels[i].Chamber.GetRound().RoundClass).CopyTo(itemData.data, num2 + 2);
				}
				flag |= b != itemData.data[num2] || b2 != itemData.data[num2 + 1] || b3 != itemData.data[num2 + 2] || b4 != itemData.data[num2 + 3];
			}
			return flag;
		}

		private bool UpdateGivenDerringer(byte[] newData)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Invalid comparison between Unknown and I4
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Invalid comparison between Unknown and I4
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Invalid comparison between Unknown and I4
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Invalid comparison between Unknown and I4
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			Derringer val = (Derringer)(object)((obj is Derringer) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				if (newData[0] == 1 && !val.IsExternalHammerCocked())
				{
					val.CockHammer();
				}
				else if (newData[0] == 0 && val.IsExternalHammerCocked())
				{
					val.m_isExternalHammerCocked = false;
				}
			}
			else if (newData[0] == 1 && !val.IsExternalHammerCocked())
			{
				val.CockHammer();
				result = true;
			}
			else if (newData[0] == 0 && val.IsExternalHammerCocked())
			{
				val.m_isExternalHammerCocked = false;
				result = true;
			}
			HingeState val2 = (HingeState)newData[1];
			if ((int)val.m_hingeState == 2 && ((int)val2 == 1 || (int)val2 == 0))
			{
				val.Latch();
				val.m_hingeState = (HingeState)0;
				val.m_hingeLerp = 0f;
				((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)18, 1f);
				((FVRPhysicalObject)val).SetAnimatedComponent(val.Hinge, Mathf.Lerp(val.HingeValues.x, val.HingeValues.y, val.m_hingeLerp), val.Hinge_InterpStyle, val.Hinge_Axis);
				if (val.HasLatchPiece)
				{
					((FVRPhysicalObject)val).SetAnimatedComponent(val.LatchPiece, Mathf.Lerp(val.LatchValues.x, val.LatchValues.y, val.m_hingeLerp), val.Latch_InterpStyle, val.Latch_Axis);
				}
				if (val.HasExtractor)
				{
					((FVRPhysicalObject)val).SetAnimatedComponent(val.Extractor, Mathf.Lerp(val.Extractor_Values.x, val.Extractor_Values.y, val.m_hingeLerp), val.Extractor_InterpStyle, val.Extractor_Axis);
				}
				result = true;
			}
			else if ((int)val.m_hingeState == 0 && ((int)val2 == 3 || (int)val2 == 2))
			{
				val.Unlatch();
				val.m_hingeState = (HingeState)2;
				val.m_hingeLerp = 1f;
				for (int i = 0; i < val.Barrels.Count; i++)
				{
					val.Barrels[i].Chamber.IsAccessible = true;
				}
				((FVRPhysicalObject)val).SetAnimatedComponent(val.Hinge, Mathf.Lerp(val.HingeValues.x, val.HingeValues.y, val.m_hingeLerp), val.Hinge_InterpStyle, val.Hinge_Axis);
				if (val.HasLatchPiece)
				{
					((FVRPhysicalObject)val).SetAnimatedComponent(val.LatchPiece, Mathf.Lerp(val.LatchValues.x, val.LatchValues.y, val.m_hingeLerp), val.Latch_InterpStyle, val.Latch_Axis);
				}
				if (val.HasExtractor)
				{
					((FVRPhysicalObject)val).SetAnimatedComponent(val.Extractor, Mathf.Lerp(val.Extractor_Values.x, val.Extractor_Values.y, val.m_hingeLerp), val.Extractor_InterpStyle, val.Extractor_Axis);
				}
				result = true;
			}
			if ((Object)(object)integratedLaser != (Object)null)
			{
				if (newData[2] == 1 && !integratedLaser.m_isOn)
				{
					integratedLaser.TurnOn();
				}
				else if (newData[2] == 0 && integratedLaser.m_isOn)
				{
					integratedLaser.TurnOff();
				}
			}
			for (int j = 0; j < val.Barrels.Count; j++)
			{
				int num = j * 4 + 3;
				short num2 = BitConverter.ToInt16(newData, num);
				short num3 = BitConverter.ToInt16(newData, num + 2);
				if (num3 == -1)
				{
					if ((Object)(object)val.Barrels[j].Chamber.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Barrels[j].Chamber.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val3 = (FireArmRoundType)num2;
				FireArmRoundClass val4 = (FireArmRoundClass)num3;
				if ((Object)(object)val.Barrels[j].Chamber.GetRound() == (Object)null || val.Barrels[j].Chamber.GetRound().RoundClass != val4)
				{
					if (val.Barrels[j].Chamber.RoundType == val3)
					{
						ChamberPatch.chamberSkip++;
						val.Barrels[j].Chamber.SetRound(val4, ((Component)val.Barrels[j].Chamber).transform.position, ((Component)val.Barrels[j].Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Barrels[j].Chamber.RoundType;
						val.Barrels[j].Chamber.RoundType = val3;
						ChamberPatch.chamberSkip++;
						val.Barrels[j].Chamber.SetRound(val4, ((Component)val.Barrels[j].Chamber).transform.position, ((Component)val.Barrels[j].Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Barrels[j].Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private int GetDerringerChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			Derringer val = (Derringer)(object)((obj is Derringer) ? obj : null);
			List<DBarrel> barrels = val.Barrels;
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			for (int i = 0; i < barrels.Count; i++)
			{
				if ((Object)(object)barrels[i].Chamber == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private bool UpdateBreakActionWeapon()
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BreakActionWeapon val = (BreakActionWeapon)(object)((obj is BreakActionWeapon) ? obj : null);
			bool flag = false;
			int num = val.Barrels.Length * 5;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? num : (num + 4)];
				flag = true;
			}
			for (int i = 0; i < val.Barrels.Length; i++)
			{
				int num2 = i * 5;
				byte b = itemData.data[num2];
				byte b2 = itemData.data[num2 + 1];
				byte b3 = itemData.data[num2 + 2];
				byte b4 = itemData.data[num2 + 3];
				if ((Object)(object)val.Barrels[i].Chamber.GetRound() == (Object)null || val.Barrels[i].Chamber.IsSpent || val.Barrels[i].Chamber.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num2 + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.Barrels[i].Chamber.GetRound().RoundType).CopyTo(itemData.data, num2);
					BitConverter.GetBytes((short)val.Barrels[i].Chamber.GetRound().RoundClass).CopyTo(itemData.data, num2 + 2);
				}
				flag |= b != itemData.data[num2] || b2 != itemData.data[num2 + 1] || b3 != itemData.data[num2 + 2] || b4 != itemData.data[num2 + 3];
				b = itemData.data[num2 + 4];
				itemData.data[num2 + 4] = (byte)(val.Barrels[i].m_isHammerCocked ? 1 : 0);
				flag |= b != itemData.data[num2 + 4];
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				byte b = itemData.data[num];
				byte b2 = itemData.data[num + 1];
				byte b3 = itemData.data[num + 2];
				byte b4 = itemData.data[num + 3];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, num);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, num + 2);
				}
				flag |= b != itemData.data[num] || b2 != itemData.data[num + 1] || b3 != itemData.data[num + 2] || b4 != itemData.data[num + 3];
			}
			return flag;
		}

		private bool UpdateGivenBreakActionWeapon(byte[] newData)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			BreakActionWeapon val = (BreakActionWeapon)(object)((obj is BreakActionWeapon) ? obj : null);
			for (int i = 0; i < val.Barrels.Length; i++)
			{
				int num = i * 5;
				short num2 = BitConverter.ToInt16(newData, num);
				short num3 = BitConverter.ToInt16(newData, num + 2);
				if (num3 == -1)
				{
					if ((Object)(object)val.Barrels[i].Chamber.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Barrels[i].Chamber.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val2 = (FireArmRoundType)num2;
					FireArmRoundClass val3 = (FireArmRoundClass)num3;
					if ((Object)(object)val.Barrels[i].Chamber.GetRound() == (Object)null || val.Barrels[i].Chamber.GetRound().RoundClass != val3)
					{
						if (val.Barrels[i].Chamber.RoundType == val2)
						{
							ChamberPatch.chamberSkip++;
							val.Barrels[i].Chamber.SetRound(val3, ((Component)val.Barrels[i].Chamber).transform.position, ((Component)val.Barrels[i].Chamber).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType = val.Barrels[i].Chamber.RoundType;
							val.Barrels[i].Chamber.RoundType = val2;
							ChamberPatch.chamberSkip++;
							val.Barrels[i].Chamber.SetRound(val3, ((Component)val.Barrels[i].Chamber).transform.position, ((Component)val.Barrels[i].Chamber).transform.rotation);
							ChamberPatch.chamberSkip--;
							val.Barrels[i].Chamber.RoundType = roundType;
						}
						result = true;
					}
				}
				val.Barrels[i].m_isHammerCocked = newData[num + 4] == 1;
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				short num4 = BitConverter.ToInt16(newData, newData.Length - 4);
				short num5 = BitConverter.ToInt16(newData, newData.Length - 2);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num5 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num4;
					FireArmRoundClass val6 = (FireArmRoundClass)num5;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private int GetBreakActionWeaponChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			BreakActionWeapon val = (BreakActionWeapon)(object)((obj is BreakActionWeapon) ? obj : null);
			BreakActionBarrel[] barrels = val.Barrels;
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null && (Object)(object)attachableFirearmGetChamberFunc() == (Object)(object)chamber)
			{
				return barrels.Length;
			}
			for (int i = 0; i < barrels.Length; i++)
			{
				if ((Object)(object)barrels[i].Chamber == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private void ChamberBreakActionWeaponRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BreakActionWeapon val = (BreakActionWeapon)(object)((obj is BreakActionWeapon) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == val.Barrels.Length)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.position, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				((FVRFireArm)val).GetChambers()[chamberIndex].SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				((FVRFireArm)val).GetChambers()[chamberIndex].SetRound(roundClass, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.position, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateBAP()
		{
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BAP val = (BAP)(object)((obj is BAP) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? 6 : 10];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.m_fireSelectorMode;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.m_isHammerCocked ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			flag |= b != itemData.data[2] || b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5];
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[6];
				b2 = itemData.data[7];
				b3 = itemData.data[8];
				b4 = itemData.data[9];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 8);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, 6);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, 8);
				}
				flag |= b != itemData.data[6] || b2 != itemData.data[7] || b3 != itemData.data[8] || b4 != itemData.data[9];
			}
			return flag;
		}

		private bool UpdateGivenBAP(byte[] newData)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			BAP val = (BAP)(object)((obj is BAP) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_fireSelectorMode = newData[0];
			}
			else if (itemData.data[0] != newData[0])
			{
				val.m_fireSelectorMode = newData[0];
				result = true;
			}
			if (newData[1] == 0)
			{
				if (val.m_isHammerCocked)
				{
					val.m_isHammerCocked = false;
					result = true;
				}
			}
			else if (!val.m_isHammerCocked)
			{
				val.CockHammer();
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				num = BitConverter.ToInt16(newData, newData.Length - 4);
				num2 = BitConverter.ToInt16(newData, newData.Length - 2);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num2 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num;
					FireArmRoundClass val6 = (FireArmRoundClass)num2;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private void SetBAPUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BAP val = (BAP)(object)((obj is BAP) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private void ChamberBAPRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_009a: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BAP val = (BAP)(object)((obj is BAP) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == 1)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private int GetBAPChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			BAP val = (BAP)(object)((obj is BAP) ? obj : null);
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null)
			{
				return 0;
			}
			return (!((Object)(object)chamber == (Object)(object)val.Chamber)) ? 1 : 0;
		}

		private bool FireBAP(int chamberIndex)
		{
			Object obj = dataObject;
			return ((BAP)((obj is BAP) ? obj : null)).Fire();
		}

		private bool UpdateRevolvingShotgun()
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			RevolvingShotgun val = (RevolvingShotgun)(object)((obj is RevolvingShotgun) ? obj : null);
			bool flag = false;
			int num = val.Chambers.Length * 4 + 2;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? num : (num + 4)];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.CurChamber;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.CylinderLoaded ? 1 : 0);
			flag |= b != itemData.data[1];
			for (int i = 0; i < val.Chambers.Length; i++)
			{
				int num2 = i * 4 + 2;
				b = itemData.data[num2];
				byte b2 = itemData.data[num2 + 1];
				byte b3 = itemData.data[num2 + 2];
				byte b4 = itemData.data[num2 + 3];
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].IsSpent || val.Chambers[i].GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num2 + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundType).CopyTo(itemData.data, num2);
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundClass).CopyTo(itemData.data, num2 + 2);
				}
				flag |= b != itemData.data[num2] || b2 != itemData.data[num2 + 1] || b3 != itemData.data[num2 + 2] || b4 != itemData.data[num2 + 3];
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[num];
				byte b2 = itemData.data[num + 1];
				byte b3 = itemData.data[num + 2];
				byte b4 = itemData.data[num + 3];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, num);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, num + 2);
				}
				flag |= b != itemData.data[num] || b2 != itemData.data[num + 1] || b3 != itemData.data[num + 2] || b4 != itemData.data[num + 3];
			}
			return flag;
		}

		private bool UpdateGivenRevolvingShotgun(byte[] newData)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			RevolvingShotgun val = (RevolvingShotgun)(object)((obj is RevolvingShotgun) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.CurChamber = newData[0];
				bool flag = newData[1] == 1;
				if (flag && !val.CylinderLoaded)
				{
					((Component)val.ProxyCylinder).gameObject.SetActive(true);
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
					val.CurChamber = 0;
					val.ProxyCylinder.localRotation = val.GetLocalRotationFromCylinder(0);
				}
				else if (!flag && val.CylinderLoaded)
				{
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)21, 1f);
					((FVRFireArm)val).EjectDelay = 0.4f;
					val.CylinderLoaded = false;
					((Component)val.ProxyCylinder).gameObject.SetActive(false);
				}
				val.CylinderLoaded = flag;
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.CurChamber = newData[0];
					result = true;
				}
				bool flag2 = newData[1] == 1;
				if (flag2 && !val.CylinderLoaded)
				{
					((Component)val.ProxyCylinder).gameObject.SetActive(true);
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
					val.CurChamber = 0;
					val.ProxyCylinder.localRotation = val.GetLocalRotationFromCylinder(0);
					result = true;
				}
				else if (!flag2 && val.CylinderLoaded)
				{
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)21, 1f);
					((FVRFireArm)val).EjectDelay = 0.4f;
					val.CylinderLoaded = false;
					((Component)val.ProxyCylinder).gameObject.SetActive(false);
					result = true;
				}
				val.CylinderLoaded = flag2;
			}
			for (int i = 0; i < val.Chambers.Length; i++)
			{
				int num = i * 4 + 2;
				short num2 = BitConverter.ToInt16(newData, num);
				short num3 = BitConverter.ToInt16(newData, num + 2);
				if (num3 == -1)
				{
					if ((Object)(object)val.Chambers[i].GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val2 = (FireArmRoundType)num2;
				FireArmRoundClass val3 = (FireArmRoundClass)num3;
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].GetRound().RoundClass != val3)
				{
					if (val.Chambers[i].RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chambers[i].RoundType;
						val.Chambers[i].RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chambers[i].RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				short num4 = BitConverter.ToInt16(newData, newData.Length - 4);
				short num5 = BitConverter.ToInt16(newData, newData.Length - 2);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num5 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num4;
					FireArmRoundClass val6 = (FireArmRoundClass)num5;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private int GetRevolvingShotgunChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			RevolvingShotgun val = (RevolvingShotgun)(object)((obj is RevolvingShotgun) ? obj : null);
			FVRFireArmChamber[] chambers = val.Chambers;
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null && (Object)(object)attachableFirearmGetChamberFunc() == (Object)(object)chamber)
			{
				return chambers.Length;
			}
			for (int i = 0; i < chambers.Length; i++)
			{
				if ((Object)(object)chambers[i] == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private void ChamberRevolvingShotgunRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			RevolvingShotgun val = (RevolvingShotgun)(object)((obj is RevolvingShotgun) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == ((FVRFireArm)val).GetChambers().Count)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.position, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				((FVRFireArm)val).GetChambers()[chamberIndex].SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				((FVRFireArm)val).GetChambers()[chamberIndex].SetRound(roundClass, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.position, ((Component)((FVRFireArm)val).GetChambers()[chamberIndex]).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateRevolver()
		{
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Revolver val = (Revolver)(object)((obj is Revolver) ? obj : null);
			bool flag = false;
			int num = val.Cylinder.numChambers * 4 + 1;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? num : (num + 4)];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.CurChamber;
			flag |= b != itemData.data[0];
			for (int i = 0; i < val.Chambers.Length; i++)
			{
				int num2 = i * 4 + 1;
				b = itemData.data[num2];
				byte b2 = itemData.data[num2 + 1];
				byte b3 = itemData.data[num2 + 2];
				byte b4 = itemData.data[num2 + 3];
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].IsSpent || val.Chambers[i].GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num2 + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundType).CopyTo(itemData.data, num2);
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundClass).CopyTo(itemData.data, num2 + 2);
				}
				flag |= b != itemData.data[num2] || b2 != itemData.data[num2 + 1] || b3 != itemData.data[num2 + 2] || b4 != itemData.data[num2 + 3];
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[num];
				byte b2 = itemData.data[num + 1];
				byte b3 = itemData.data[num + 2];
				byte b4 = itemData.data[num + 3];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, num);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, num + 2);
				}
				flag |= b != itemData.data[num] || b2 != itemData.data[num + 1] || b3 != itemData.data[num + 2] || b4 != itemData.data[num + 3];
			}
			return flag;
		}

		private bool UpdateGivenRevolver(byte[] newData)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			Revolver val = (Revolver)(object)((obj is Revolver) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.CurChamber = newData[0];
			}
			else if (itemData.data[0] != newData[0])
			{
				val.CurChamber = newData[0];
				result = true;
			}
			for (int i = 0; i < val.Chambers.Length; i++)
			{
				int num = i * 4 + 1;
				short num2 = BitConverter.ToInt16(newData, num);
				short num3 = BitConverter.ToInt16(newData, num + 2);
				if (num3 == -1)
				{
					if ((Object)(object)val.Chambers[i].GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val2 = (FireArmRoundType)num2;
				FireArmRoundClass val3 = (FireArmRoundClass)num3;
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].GetRound().RoundClass != val3)
				{
					if (val.Chambers[i].RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chambers[i].RoundType;
						val.Chambers[i].RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chambers[i].RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				short num4 = BitConverter.ToInt16(newData, newData.Length - 4);
				short num5 = BitConverter.ToInt16(newData, newData.Length - 2);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num5 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num4;
					FireArmRoundClass val6 = (FireArmRoundClass)num5;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private int GetRevolverChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			Revolver val = (Revolver)(object)((obj is Revolver) ? obj : null);
			FVRFireArmChamber[] chambers = val.Chambers;
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null && (Object)(object)attachableFirearmGetChamberFunc() == (Object)(object)chamber)
			{
				return chambers.Length;
			}
			for (int i = 0; i < chambers.Length; i++)
			{
				if ((Object)(object)chambers[i] == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private void ChamberRevolverRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Revolver val = (Revolver)(object)((obj is Revolver) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == val.Chambers.Length)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chambers[chamberIndex]).transform.position, ((Component)val.Chambers[chamberIndex]).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				val.Chambers[chamberIndex].SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chambers[chamberIndex].SetRound(roundClass, ((Component)val.Chambers[chamberIndex]).transform.position, ((Component)val.Chambers[chamberIndex]).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateM203()
		{
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f9: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			M203 val = (M203)(object)((obj is M203) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[21];
				flag = true;
			}
			byte b = itemData.data[0];
			if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount == (Object)null)
			{
				itemData.data[0] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts.Count; i++)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts[i] == (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount)
					{
						itemData.data[0] = (byte)i;
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[0] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			byte b5 = itemData.data[4];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 3);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 1);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 3);
			}
			flag |= b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3] || b5 != itemData.data[4];
			b2 = itemData.data[5];
			b3 = itemData.data[6];
			b4 = itemData.data[7];
			b5 = itemData.data[8];
			BitConverter.GetBytes(mountObjectID).CopyTo(itemData.data, 5);
			flag |= b2 != itemData.data[5] || b3 != itemData.data[6] || b4 != itemData.data[7] || b5 != itemData.data[8];
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				mountObjectScale = Vector3.one;
				b2 = itemData.data[9];
				b3 = itemData.data[10];
				b4 = itemData.data[11];
				b5 = itemData.data[12];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 9);
				flag |= b2 != itemData.data[9] || b3 != itemData.data[10] || b4 != itemData.data[11] || b5 != itemData.data[12];
				b2 = itemData.data[13];
				b3 = itemData.data[14];
				b4 = itemData.data[15];
				b5 = itemData.data[16];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 13);
				flag |= b2 != itemData.data[13] || b3 != itemData.data[14] || b4 != itemData.data[15] || b5 != itemData.data[16];
				b2 = itemData.data[17];
				b3 = itemData.data[18];
				b4 = itemData.data[19];
				b5 = itemData.data[20];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 17);
				return flag | (b2 != itemData.data[17] || b3 != itemData.data[18] || b4 != itemData.data[19] || b5 != itemData.data[20]);
			}
			mountObjectScale = ((Component)this).transform.parent.localScale;
			b2 = itemData.data[9];
			b3 = itemData.data[10];
			b4 = itemData.data[11];
			b5 = itemData.data[12];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.x).CopyTo(itemData.data, 9);
			flag |= b2 != itemData.data[9] || b3 != itemData.data[10] || b4 != itemData.data[11] || b5 != itemData.data[12];
			b2 = itemData.data[13];
			b3 = itemData.data[14];
			b4 = itemData.data[15];
			b5 = itemData.data[16];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.y).CopyTo(itemData.data, 13);
			flag |= b2 != itemData.data[13] || b3 != itemData.data[14] || b4 != itemData.data[15] || b5 != itemData.data[16];
			b2 = itemData.data[17];
			b3 = itemData.data[18];
			b4 = itemData.data[19];
			b5 = itemData.data[20];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.z).CopyTo(itemData.data, 17);
			return flag | (b2 != itemData.data[17] || b3 != itemData.data[18] || b4 != itemData.data[19] || b5 != itemData.data[20]);
		}

		private bool UpdateGivenM203(byte[] newData)
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_0635: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0714: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Unknown result type (might be due to invalid IL or missing references)
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			bool flag = itemData.data == null;
			Object obj = dataObject;
			M203 val = (M203)(object)((obj is M203) ? obj : null);
			byte b = currentMountIndex;
			if (newData[0] == byte.MaxValue)
			{
				if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out var value))
				{
					value.Remove(this);
				}
				if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
				{
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
					((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
					data.ignoreParentChanged++;
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
					data.ignoreParentChanged--;
					currentMountIndex = byte.MaxValue;
					if (data.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
					}
				}
			}
			else
			{
				mountObjectID = BitConverter.ToInt32(newData, 5);
				mountObjectScale = new Vector3(BitConverter.ToSingle(newData, 9), BitConverter.ToSingle(newData, 13), BitConverter.ToSingle(newData, 17));
				if (mountObjectID != -1)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
					{
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
						((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
						data.ignoreParentChanged++;
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						data.ignoreParentChanged--;
						if (data.controller != GameManager.ID)
						{
							Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
						}
					}
				}
				else
				{
					FVRFireArmAttachmentMount val2 = null;
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
					bool flag2 = false;
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						if (trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > newData[0])
						{
							val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[newData[0]];
						}
					}
					else
					{
						flag2 = true;
						if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value2))
						{
							value2.Add(this);
						}
						else
						{
							toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
						}
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)(object)val2)
					{
						data.ignoreParentChanged++;
						if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
						{
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
							((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						}
						if (CanAttachToMount((FVRFireArmAttachment)(object)((AttachableFirearm)val).Attachment, val2))
						{
							if (val2.GetRootMount().ParentToThis)
							{
								((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
							}
							else
							{
								((Component)val2.MyObject).transform.localScale = mountObjectScale;
							}
							if (((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).CanScaleToMount && val2.CanThisRescale())
							{
								((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).ScaleToMount(val2);
							}
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).AttachToMount(val2, true);
							if (!((object)((Component)this).transform.localPosition/*cast due to .constrained prefix*/).Equals((object?)itemData.position))
							{
								((Component)this).transform.localPosition = itemData.position;
							}
							if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
							{
								for (int i = 0; i < value3.Count; i++)
								{
									if ((Object)(object)value3[i] != (Object)null)
									{
										value3[i].data.UpdateFromData(value3[i].data);
									}
								}
								toAttachByMountObjectID.Remove(data.trackedID);
							}
						}
						else if (!flag2)
						{
							if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value4))
							{
								value4.Add(this);
							}
							else
							{
								toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
							}
						}
						currentMountIndex = newData[0];
						data.ignoreParentChanged--;
					}
				}
			}
			flag |= b != currentMountIndex;
			short num = BitConverter.ToInt16(newData, 1);
			short num2 = BitConverter.ToInt16(newData, 3);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					flag = true;
				}
			}
			else
			{
				FireArmRoundType val3 = (FireArmRoundType)num;
				FireArmRoundClass val4 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val4)
				{
					if (val.Chamber.RoundType == val3)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val3;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					flag = true;
				}
			}
			itemData.data = newData;
			return flag;
		}

		private void M203ChamberRound(FireArmRoundType roundType, FireArmRoundClass roundClass)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			M203 val = null;
			val = (M203)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			if ((int)roundClass == -1)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FVRFireArmRound)null, false);
				ChamberPatch.chamberSkip--;
				return;
			}
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private FVRFireArmChamber M203GetChamber()
		{
			M203 val = null;
			val = (M203)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			return val.Chamber;
		}

		private void ChamberM203Round(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			M203 val = (M203)(object)((obj is M203) ? obj : null);
			ChamberPatch.chamberSkip++;
			if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateGP25()
		{
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0739: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			GP25 val = (GP25)(object)((obj is GP25) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[22];
				flag = true;
			}
			byte b = itemData.data[0];
			if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount == (Object)null)
			{
				itemData.data[0] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts.Count; i++)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts[i] == (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount)
					{
						itemData.data[0] = (byte)i;
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[0] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[0];
			byte b2 = itemData.data[1];
			itemData.data[1] = (byte)(val.m_safetyEngaged ? 1u : 0u);
			flag |= b2 != itemData.data[1];
			b2 = itemData.data[2];
			byte b3 = itemData.data[3];
			byte b4 = itemData.data[4];
			byte b5 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			flag |= b2 != itemData.data[2] || b3 != itemData.data[3] || b4 != itemData.data[4] || b5 != itemData.data[5];
			b2 = itemData.data[6];
			b3 = itemData.data[7];
			b4 = itemData.data[8];
			b5 = itemData.data[9];
			BitConverter.GetBytes(mountObjectID).CopyTo(itemData.data, 6);
			flag |= b2 != itemData.data[6] || b3 != itemData.data[7] || b4 != itemData.data[8] || b5 != itemData.data[9];
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				mountObjectScale = Vector3.one;
				b2 = itemData.data[10];
				b3 = itemData.data[11];
				b4 = itemData.data[12];
				b5 = itemData.data[13];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 10);
				flag |= b2 != itemData.data[10] || b3 != itemData.data[11] || b4 != itemData.data[12] || b5 != itemData.data[13];
				b2 = itemData.data[14];
				b3 = itemData.data[15];
				b4 = itemData.data[16];
				b5 = itemData.data[17];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 14);
				flag |= b2 != itemData.data[14] || b3 != itemData.data[15] || b4 != itemData.data[16] || b5 != itemData.data[17];
				b2 = itemData.data[18];
				b3 = itemData.data[19];
				b4 = itemData.data[20];
				b5 = itemData.data[21];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 18);
				return flag | (b2 != itemData.data[18] || b3 != itemData.data[19] || b4 != itemData.data[20] || b5 != itemData.data[21]);
			}
			mountObjectScale = ((Component)this).transform.parent.localScale;
			b2 = itemData.data[10];
			b3 = itemData.data[11];
			b4 = itemData.data[12];
			b5 = itemData.data[13];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.x).CopyTo(itemData.data, 10);
			flag |= b2 != itemData.data[10] || b3 != itemData.data[11] || b4 != itemData.data[12] || b5 != itemData.data[13];
			b2 = itemData.data[14];
			b3 = itemData.data[15];
			b4 = itemData.data[16];
			b5 = itemData.data[17];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.y).CopyTo(itemData.data, 14);
			flag |= b2 != itemData.data[14] || b3 != itemData.data[15] || b4 != itemData.data[16] || b5 != itemData.data[17];
			b2 = itemData.data[18];
			b3 = itemData.data[19];
			b4 = itemData.data[20];
			b5 = itemData.data[21];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.z).CopyTo(itemData.data, 18);
			return flag | (b2 != itemData.data[18] || b3 != itemData.data[19] || b4 != itemData.data[20] || b5 != itemData.data[21]);
		}

		private bool UpdateGivenGP25(byte[] newData)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Unknown result type (might be due to invalid IL or missing references)
			//IL_0688: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0702: Unknown result type (might be due to invalid IL or missing references)
			//IL_0707: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0711: Unknown result type (might be due to invalid IL or missing references)
			//IL_0728: Unknown result type (might be due to invalid IL or missing references)
			//IL_0735: Unknown result type (might be due to invalid IL or missing references)
			//IL_0745: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_0764: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			GP25 val = (GP25)(object)((obj is GP25) ? obj : null);
			byte b = currentMountIndex;
			if (newData[0] == byte.MaxValue)
			{
				if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out var value))
				{
					value.Remove(this);
				}
				if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
				{
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
					((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
					data.ignoreParentChanged++;
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
					data.ignoreParentChanged--;
					currentMountIndex = byte.MaxValue;
					if (data.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
					}
				}
			}
			else
			{
				mountObjectID = BitConverter.ToInt32(newData, 6);
				mountObjectScale = new Vector3(BitConverter.ToSingle(newData, 10), BitConverter.ToSingle(newData, 14), BitConverter.ToSingle(newData, 18));
				if (mountObjectID == -1)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
					{
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
						((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
						data.ignoreParentChanged++;
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						data.ignoreParentChanged--;
						currentMountIndex = byte.MaxValue;
						if (data.controller != GameManager.ID)
						{
							Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
						}
					}
				}
				else
				{
					FVRFireArmAttachmentMount val2 = null;
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
					bool flag2 = false;
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						if (trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > newData[0])
						{
							val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[newData[0]];
						}
					}
					else
					{
						flag2 = true;
						if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value2))
						{
							value2.Add(this);
						}
						else
						{
							toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
						}
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)(object)val2)
					{
						data.ignoreParentChanged++;
						if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
						{
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
							((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						}
						if (CanAttachToMount((FVRFireArmAttachment)(object)((AttachableFirearm)val).Attachment, val2))
						{
							if (val2.GetRootMount().ParentToThis)
							{
								((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
							}
							else
							{
								((Component)val2.MyObject).transform.localScale = mountObjectScale;
							}
							if (((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).CanScaleToMount && val2.CanThisRescale())
							{
								((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).ScaleToMount(val2);
							}
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).AttachToMount(val2, true);
							if (!((object)((Component)this).transform.localPosition/*cast due to .constrained prefix*/).Equals((object?)itemData.position))
							{
								((Component)this).transform.localPosition = itemData.position;
							}
							if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
							{
								for (int i = 0; i < value3.Count; i++)
								{
									if ((Object)(object)value3[i] != (Object)null)
									{
										value3[i].data.UpdateFromData(value3[i].data);
									}
								}
								toAttachByMountObjectID.Remove(data.trackedID);
							}
						}
						else if (!flag2)
						{
							if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value4))
							{
								value4.Add(this);
							}
							else
							{
								toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
							}
						}
						currentMountIndex = newData[0];
						data.ignoreParentChanged--;
					}
				}
			}
			flag |= b != currentMountIndex;
			if (itemData.data == null)
			{
				flag = true;
				val.m_safetyEngaged = newData[1] == 1;
			}
			else if (itemData.data[1] != newData[1])
			{
				val.m_safetyEngaged = newData[1] == 1;
				flag = true;
			}
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					flag = true;
				}
			}
			else
			{
				FireArmRoundType val3 = (FireArmRoundType)num;
				FireArmRoundClass val4 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val4)
				{
					if (val.Chamber.RoundType == val3)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val3;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					flag = true;
				}
			}
			itemData.data = newData;
			return flag;
		}

		private void GP25ChamberRound(FireArmRoundType roundType, FireArmRoundClass roundClass)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			GP25 val = null;
			val = (GP25)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			if ((int)roundClass == -1)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FVRFireArmRound)null, false);
				ChamberPatch.chamberSkip--;
				return;
			}
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private FVRFireArmChamber GP25GetChamber()
		{
			GP25 val = null;
			val = (GP25)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			return val.Chamber;
		}

		private void ChamberGP25Round(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			GP25 val = (GP25)(object)((obj is GP25) ? obj : null);
			ChamberPatch.chamberSkip++;
			if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateAttachableTubeFed()
		{
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_063e: Unknown result type (might be due to invalid IL or missing references)
			//IL_068d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_0805: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			AttachableTubeFed val = (AttachableTubeFed)(object)((obj is AttachableTubeFed) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[25];
				flag = true;
			}
			byte b = itemData.data[0];
			if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount == (Object)null)
			{
				itemData.data[0] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts.Count; i++)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts[i] == (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount)
					{
						itemData.data[0] = (byte)i;
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[0] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[0];
			byte b2 = itemData.data[1];
			itemData.data[1] = (byte)(val.IsSafetyEngaged ? 1 : 0);
			flag |= b2 != itemData.data[1];
			b2 = itemData.data[2];
			itemData.data[2] = BitConverter.GetBytes(val.IsHammerCocked)[0];
			flag |= b2 != itemData.data[2];
			b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			byte b5 = itemData.data[6];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 5);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 3);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 5);
			}
			flag |= b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5] || b5 != itemData.data[6];
			b2 = itemData.data[7];
			itemData.data[7] = (byte)val.Bolt.CurPos;
			flag |= b2 != itemData.data[7];
			if (val.HasHandle)
			{
				b2 = itemData.data[8];
				itemData.data[8] = (byte)val.Handle.CurPos;
				flag |= b2 != itemData.data[8];
			}
			b2 = itemData.data[9];
			b3 = itemData.data[10];
			b4 = itemData.data[11];
			b5 = itemData.data[12];
			BitConverter.GetBytes(mountObjectID).CopyTo(itemData.data, 9);
			flag |= b2 != itemData.data[9] || b3 != itemData.data[10] || b4 != itemData.data[11] || b5 != itemData.data[12];
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				mountObjectScale = Vector3.one;
				b2 = itemData.data[13];
				b3 = itemData.data[14];
				b4 = itemData.data[15];
				b5 = itemData.data[16];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 13);
				flag |= b2 != itemData.data[13] || b3 != itemData.data[14] || b4 != itemData.data[15] || b5 != itemData.data[16];
				b2 = itemData.data[17];
				b3 = itemData.data[18];
				b4 = itemData.data[19];
				b5 = itemData.data[20];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 17);
				flag |= b2 != itemData.data[17] || b3 != itemData.data[18] || b4 != itemData.data[19] || b5 != itemData.data[20];
				b2 = itemData.data[21];
				b3 = itemData.data[22];
				b4 = itemData.data[23];
				b5 = itemData.data[24];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 21);
				return flag | (b2 != itemData.data[21] || b3 != itemData.data[22] || b4 != itemData.data[23] || b5 != itemData.data[24]);
			}
			mountObjectScale = ((Component)this).transform.parent.localScale;
			b2 = itemData.data[13];
			b3 = itemData.data[14];
			b4 = itemData.data[15];
			b5 = itemData.data[16];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.x).CopyTo(itemData.data, 13);
			flag |= b2 != itemData.data[13] || b3 != itemData.data[14] || b4 != itemData.data[15] || b5 != itemData.data[16];
			b2 = itemData.data[17];
			b3 = itemData.data[18];
			b4 = itemData.data[19];
			b5 = itemData.data[20];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.y).CopyTo(itemData.data, 17);
			flag |= b2 != itemData.data[17] || b3 != itemData.data[18] || b4 != itemData.data[19] || b5 != itemData.data[20];
			b2 = itemData.data[21];
			b3 = itemData.data[22];
			b4 = itemData.data[23];
			b5 = itemData.data[24];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.z).CopyTo(itemData.data, 21);
			return flag | (b2 != itemData.data[21] || b3 != itemData.data[22] || b4 != itemData.data[23] || b5 != itemData.data[24]);
		}

		private bool UpdateGivenAttachableTubeFed(byte[] newData)
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_062f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_0642: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_07df: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0803: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_085e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0863: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Unknown result type (might be due to invalid IL or missing references)
			//IL_086d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			//IL_0891: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08be: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0820: Unknown result type (might be due to invalid IL or missing references)
			//IL_082d: Unknown result type (might be due to invalid IL or missing references)
			//IL_083d: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			AttachableTubeFed val = (AttachableTubeFed)(object)((obj is AttachableTubeFed) ? obj : null);
			byte b = currentMountIndex;
			if (newData[0] == byte.MaxValue)
			{
				if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out var value))
				{
					value.Remove(this);
				}
				if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
				{
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
					((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
					data.ignoreParentChanged++;
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
					data.ignoreParentChanged--;
					currentMountIndex = byte.MaxValue;
					if (data.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
					}
				}
			}
			else
			{
				mountObjectID = BitConverter.ToInt32(newData, 9);
				mountObjectScale = new Vector3(BitConverter.ToSingle(newData, 13), BitConverter.ToSingle(newData, 17), BitConverter.ToSingle(newData, 21));
				if (mountObjectID != -1)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
					{
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
						((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
						data.ignoreParentChanged++;
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						data.ignoreParentChanged--;
						currentMountIndex = byte.MaxValue;
						if (data.controller != GameManager.ID)
						{
							Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
						}
					}
				}
				else
				{
					FVRFireArmAttachmentMount val2 = null;
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
					bool flag2 = false;
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						if (trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > newData[0])
						{
							val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[newData[0]];
						}
					}
					else
					{
						flag2 = true;
						if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value2))
						{
							value2.Add(this);
						}
						else
						{
							toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
						}
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)(object)val2)
					{
						data.ignoreParentChanged++;
						if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
						{
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
							((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						}
						if (CanAttachToMount((FVRFireArmAttachment)(object)((AttachableFirearm)val).Attachment, val2))
						{
							if (val2.GetRootMount().ParentToThis)
							{
								((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
							}
							else
							{
								((Component)val2.MyObject).transform.localScale = mountObjectScale;
							}
							if (((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).CanScaleToMount && val2.CanThisRescale())
							{
								((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).ScaleToMount(val2);
							}
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).AttachToMount(val2, true);
							if (!((object)((Component)this).transform.localPosition/*cast due to .constrained prefix*/).Equals((object?)itemData.position))
							{
								((Component)this).transform.localPosition = itemData.position;
							}
							if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
							{
								for (int i = 0; i < value3.Count; i++)
								{
									if ((Object)(object)value3[i] != (Object)null)
									{
										value3[i].data.UpdateFromData(value3[i].data);
									}
								}
								toAttachByMountObjectID.Remove(data.trackedID);
							}
						}
						else if (!flag2)
						{
							if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value4))
							{
								value4.Add(this);
							}
							else
							{
								toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
							}
						}
						currentMountIndex = newData[0];
						data.ignoreParentChanged--;
					}
				}
			}
			flag |= b != currentMountIndex;
			if (itemData.data == null)
			{
				flag = true;
				if ((newData[1] == 1 && !val.IsSafetyEngaged) || (newData[1] == 0 && val.IsSafetyEngaged))
				{
					val.ToggleSafety();
				}
				val.Bolt.LastPos = val.Bolt.CurPos;
				val.Bolt.CurPos = (BoltPos)newData[7];
				if (val.HasHandle)
				{
					val.Handle.LastPos = val.Handle.CurPos;
					val.Handle.CurPos = (BoltPos)newData[8];
				}
			}
			else
			{
				if ((newData[1] == 1 && !val.IsSafetyEngaged) || (newData[1] == 0 && val.IsSafetyEngaged))
				{
					val.ToggleSafety();
					flag = true;
				}
				if (itemData.data[7] != newData[7])
				{
					val.Bolt.LastPos = val.Bolt.CurPos;
					val.Bolt.CurPos = (BoltPos)newData[7];
				}
				if (val.HasHandle && itemData.data[8] != newData[8])
				{
					val.Handle.LastPos = val.Handle.CurPos;
					val.Handle.CurPos = (BoltPos)newData[8];
				}
			}
			if (newData[2] == 0)
			{
				if (val.IsHammerCocked)
				{
					val.m_isHammerCocked = newData[2] == 1;
					flag = true;
				}
			}
			else if (!val.IsHammerCocked)
			{
				val.CockHammer();
				flag = true;
			}
			short num = BitConverter.ToInt16(newData, 3);
			short num2 = BitConverter.ToInt16(newData, 5);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					flag = true;
				}
			}
			else
			{
				FireArmRoundType val3 = (FireArmRoundType)num;
				FireArmRoundClass val4 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val4)
				{
					if (val.Chamber.RoundType == val3)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val3;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					flag = true;
				}
			}
			itemData.data = newData;
			return flag;
		}

		private void AttachableTubeFedChamberRound(FireArmRoundType roundType, FireArmRoundClass roundClass)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			AttachableTubeFed val = null;
			val = (AttachableTubeFed)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			if ((int)roundClass == -1)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FVRFireArmRound)null, false);
				ChamberPatch.chamberSkip--;
				return;
			}
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private FVRFireArmChamber AttachableTubeFedGetChamber()
		{
			AttachableTubeFed val = null;
			val = (AttachableTubeFed)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			return val.Chamber;
		}

		private void ChamberAttachableTubeFedRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			AttachableTubeFed val = (AttachableTubeFed)(object)((obj is AttachableTubeFed) ? obj : null);
			ChamberPatch.chamberSkip++;
			if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateAttachableClosedBoltWeapon()
		{
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ac: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			AttachableClosedBoltWeapon val = (AttachableClosedBoltWeapon)(object)((obj is AttachableClosedBoltWeapon) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[24];
				flag = true;
			}
			byte b = itemData.data[0];
			if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount == (Object)null)
			{
				itemData.data[0] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts.Count; i++)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts[i] == (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount)
					{
						itemData.data[0] = (byte)i;
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[0] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[0];
			byte b2 = itemData.data[1];
			itemData.data[1] = (byte)val.FireSelectorModeIndex;
			flag |= b2 != itemData.data[1];
			b2 = itemData.data[2];
			itemData.data[2] = (byte)val.m_CamBurst;
			flag |= b2 != itemData.data[2];
			b2 = itemData.data[3];
			itemData.data[3] = (byte)(val.IsHammerCocked ? 1 : 0);
			flag |= b2 != itemData.data[3];
			b2 = itemData.data[4];
			byte b3 = itemData.data[5];
			byte b4 = itemData.data[6];
			byte b5 = itemData.data[7];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 6);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 4);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 6);
			}
			flag |= b2 != itemData.data[4] || b3 != itemData.data[5] || b4 != itemData.data[5] || b5 != itemData.data[6];
			b2 = itemData.data[8];
			b3 = itemData.data[9];
			b4 = itemData.data[10];
			b5 = itemData.data[11];
			BitConverter.GetBytes(mountObjectID).CopyTo(itemData.data, 8);
			flag |= b2 != itemData.data[8] || b3 != itemData.data[9] || b4 != itemData.data[10] || b5 != itemData.data[11];
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				mountObjectScale = Vector3.one;
				b2 = itemData.data[12];
				b3 = itemData.data[13];
				b4 = itemData.data[14];
				b5 = itemData.data[15];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 12);
				flag |= b2 != itemData.data[12] || b3 != itemData.data[13] || b4 != itemData.data[14] || b5 != itemData.data[15];
				b2 = itemData.data[16];
				b3 = itemData.data[17];
				b4 = itemData.data[18];
				b5 = itemData.data[19];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 16);
				flag |= b2 != itemData.data[16] || b3 != itemData.data[17] || b4 != itemData.data[18] || b5 != itemData.data[19];
				b2 = itemData.data[20];
				b3 = itemData.data[21];
				b4 = itemData.data[22];
				b5 = itemData.data[23];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 20);
				return flag | (b2 != itemData.data[20] || b3 != itemData.data[21] || b4 != itemData.data[22] || b5 != itemData.data[23]);
			}
			mountObjectScale = ((Component)this).transform.parent.localScale;
			b2 = itemData.data[12];
			b3 = itemData.data[13];
			b4 = itemData.data[14];
			b5 = itemData.data[15];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.x).CopyTo(itemData.data, 12);
			flag |= b2 != itemData.data[12] || b3 != itemData.data[13] || b4 != itemData.data[14] || b5 != itemData.data[15];
			b2 = itemData.data[16];
			b3 = itemData.data[17];
			b4 = itemData.data[18];
			b5 = itemData.data[19];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.y).CopyTo(itemData.data, 16);
			flag |= b2 != itemData.data[16] || b3 != itemData.data[17] || b4 != itemData.data[18] || b5 != itemData.data[19];
			b2 = itemData.data[20];
			b3 = itemData.data[21];
			b4 = itemData.data[22];
			b5 = itemData.data[23];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.z).CopyTo(itemData.data, 20);
			return flag | (b2 != itemData.data[20] || b3 != itemData.data[21] || b4 != itemData.data[22] || b5 != itemData.data[23]);
		}

		private bool UpdateGivenAttachableClosedBoltWeapon(byte[] newData)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_071b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0776: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0783: Unknown result type (might be due to invalid IL or missing references)
			//IL_0785: Unknown result type (might be due to invalid IL or missing references)
			//IL_079c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0738: Unknown result type (might be due to invalid IL or missing references)
			//IL_0745: Unknown result type (might be due to invalid IL or missing references)
			//IL_0755: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			AttachableClosedBoltWeapon val = (AttachableClosedBoltWeapon)(object)((obj is AttachableClosedBoltWeapon) ? obj : null);
			byte b = currentMountIndex;
			if (newData[0] == byte.MaxValue)
			{
				if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out var value))
				{
					value.Remove(this);
				}
				if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
				{
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
					((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
					data.ignoreParentChanged++;
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
					data.ignoreParentChanged--;
					currentMountIndex = byte.MaxValue;
					if (data.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
					}
				}
			}
			else
			{
				mountObjectID = BitConverter.ToInt32(newData, 8);
				mountObjectScale = new Vector3(BitConverter.ToSingle(newData, 12), BitConverter.ToSingle(newData, 16), BitConverter.ToSingle(newData, 20));
				if (mountObjectID == -1)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
					{
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
						((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
						data.ignoreParentChanged++;
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						data.ignoreParentChanged--;
						currentMountIndex = byte.MaxValue;
						if (data.controller != GameManager.ID)
						{
							Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
						}
					}
				}
				else
				{
					FVRFireArmAttachmentMount val2 = null;
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
					bool flag2 = false;
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						if (trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > newData[0])
						{
							val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[newData[0]];
						}
					}
					else
					{
						flag2 = true;
						if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value2))
						{
							value2.Add(this);
						}
						else
						{
							toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
						}
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)(object)val2)
					{
						data.ignoreParentChanged++;
						if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
						{
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
							((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						}
						if (CanAttachToMount((FVRFireArmAttachment)(object)((AttachableFirearm)val).Attachment, val2))
						{
							if (val2.GetRootMount().ParentToThis)
							{
								((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
							}
							else
							{
								((Component)val2.MyObject).transform.localScale = mountObjectScale;
							}
							if (((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).CanScaleToMount && val2.CanThisRescale())
							{
								((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).ScaleToMount(val2);
							}
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).AttachToMount(val2, true);
							if (!((object)((Component)this).transform.localPosition/*cast due to .constrained prefix*/).Equals((object?)itemData.position))
							{
								((Component)this).transform.localPosition = itemData.position;
							}
							if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
							{
								for (int i = 0; i < value3.Count; i++)
								{
									if ((Object)(object)value3[i] != (Object)null)
									{
										value3[i].data.UpdateFromData(value3[i].data);
									}
								}
								toAttachByMountObjectID.Remove(data.trackedID);
							}
						}
						else if (!flag2)
						{
							if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value4))
							{
								value4.Add(this);
							}
							else
							{
								toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
							}
						}
						currentMountIndex = newData[0];
						data.ignoreParentChanged--;
					}
				}
			}
			flag |= b != currentMountIndex;
			if (itemData.data == null)
			{
				flag = true;
				val.m_fireSelectorMode = newData[1];
				val.m_CamBurst = newData[2];
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_fireSelectorMode = newData[1];
					flag = true;
				}
				if (itemData.data[1] != newData[1])
				{
					val.m_CamBurst = newData[2];
					flag = true;
				}
			}
			if (newData[3] == 0)
			{
				if (val.IsHammerCocked)
				{
					val.m_isHammerCocked = BitConverter.ToBoolean(newData, 3);
					flag = true;
				}
			}
			else if (!val.IsHammerCocked)
			{
				val.CockHammer();
				flag = true;
			}
			short num = BitConverter.ToInt16(newData, 4);
			short num2 = BitConverter.ToInt16(newData, 6);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					flag = true;
				}
			}
			else
			{
				FireArmRoundType val3 = (FireArmRoundType)num;
				FireArmRoundClass val4 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val4)
				{
					if (val.Chamber.RoundType == val3)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val3;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					flag = true;
				}
			}
			itemData.data = newData;
			return flag;
		}

		private void AttachableClosedBoltWeaponChamberRound(FireArmRoundType roundType, FireArmRoundClass roundClass)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			AttachableClosedBoltWeapon val = null;
			val = (AttachableClosedBoltWeapon)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			if ((int)roundClass == -1)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FVRFireArmRound)null, false);
				ChamberPatch.chamberSkip--;
				return;
			}
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private FVRFireArmChamber AttachableClosedBoltWeaponGetChamber()
		{
			AttachableClosedBoltWeapon val = null;
			val = (AttachableClosedBoltWeapon)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			return val.Chamber;
		}

		private void ChamberAttachableClosedBoltWeaponRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			AttachableClosedBoltWeapon val = (AttachableClosedBoltWeapon)(object)((obj is AttachableClosedBoltWeapon) ? obj : null);
			ChamberPatch.chamberSkip++;
			if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool UpdateAttachableBreakActions()
		{
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_067c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0738: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			AttachableBreakActions val = (AttachableBreakActions)(object)((obj is AttachableBreakActions) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[22];
				flag = true;
			}
			byte b = itemData.data[0];
			if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount == (Object)null)
			{
				itemData.data[0] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts.Count; i++)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount.MyObject.AttachmentMounts[i] == (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount)
					{
						itemData.data[0] = (byte)i;
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[0] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[0];
			byte b2 = itemData.data[1];
			itemData.data[1] = (byte)(val.m_isBreachOpen ? 1 : 0);
			flag |= b2 != itemData.data[1];
			b2 = itemData.data[2];
			byte b3 = itemData.data[3];
			byte b4 = itemData.data[4];
			byte b5 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			flag |= b2 != itemData.data[2] || b3 != itemData.data[3] || b4 != itemData.data[4] || b5 != itemData.data[5];
			b2 = itemData.data[6];
			b3 = itemData.data[7];
			b4 = itemData.data[8];
			b5 = itemData.data[9];
			BitConverter.GetBytes(mountObjectID).CopyTo(itemData.data, 6);
			flag |= b2 != itemData.data[6] || b3 != itemData.data[7] || b4 != itemData.data[8] || b5 != itemData.data[9];
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				mountObjectScale = Vector3.one;
				b2 = itemData.data[10];
				b3 = itemData.data[11];
				b4 = itemData.data[12];
				b5 = itemData.data[13];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 10);
				flag |= b2 != itemData.data[10] || b3 != itemData.data[11] || b4 != itemData.data[12] || b5 != itemData.data[13];
				b2 = itemData.data[14];
				b3 = itemData.data[15];
				b4 = itemData.data[16];
				b5 = itemData.data[17];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 14);
				flag |= b2 != itemData.data[14] || b3 != itemData.data[15] || b4 != itemData.data[16] || b5 != itemData.data[17];
				b2 = itemData.data[18];
				b3 = itemData.data[19];
				b4 = itemData.data[20];
				b5 = itemData.data[21];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 18);
				return flag | (b2 != itemData.data[18] || b3 != itemData.data[19] || b4 != itemData.data[20] || b5 != itemData.data[21]);
			}
			mountObjectScale = ((Component)this).transform.parent.localScale;
			b2 = itemData.data[10];
			b3 = itemData.data[11];
			b4 = itemData.data[12];
			b5 = itemData.data[13];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.x).CopyTo(itemData.data, 10);
			flag |= b2 != itemData.data[10] || b3 != itemData.data[11] || b4 != itemData.data[12] || b5 != itemData.data[13];
			b2 = itemData.data[14];
			b3 = itemData.data[15];
			b4 = itemData.data[16];
			b5 = itemData.data[17];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.y).CopyTo(itemData.data, 14);
			flag |= b2 != itemData.data[14] || b3 != itemData.data[15] || b4 != itemData.data[16] || b5 != itemData.data[17];
			b2 = itemData.data[18];
			b3 = itemData.data[19];
			b4 = itemData.data[20];
			b5 = itemData.data[21];
			BitConverter.GetBytes(((Component)this).transform.parent.localScale.z).CopyTo(itemData.data, 18);
			return flag | (b2 != itemData.data[18] || b3 != itemData.data[19] || b4 != itemData.data[20] || b5 != itemData.data[21]);
		}

		private bool UpdateGivenAttachableBreakActions(byte[] newData)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0646: Unknown result type (might be due to invalid IL or missing references)
			//IL_064a: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_066f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_068e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_071c: Unknown result type (might be due to invalid IL or missing references)
			//IL_072c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_074b: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			AttachableBreakActions val = (AttachableBreakActions)(object)((obj is AttachableBreakActions) ? obj : null);
			byte b = currentMountIndex;
			if (newData[0] == byte.MaxValue)
			{
				if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out var value))
				{
					value.Remove(this);
				}
				if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
				{
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
					((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
					data.ignoreParentChanged++;
					((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
					data.ignoreParentChanged--;
					currentMountIndex = byte.MaxValue;
					if (data.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
					}
				}
			}
			else
			{
				mountObjectID = BitConverter.ToInt32(newData, 6);
				mountObjectScale = new Vector3(BitConverter.ToSingle(newData, 10), BitConverter.ToSingle(newData, 14), BitConverter.ToSingle(newData, 18));
				if (mountObjectID == -1)
				{
					if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
					{
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
						((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
						data.ignoreParentChanged++;
						((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						data.ignoreParentChanged--;
						currentMountIndex = byte.MaxValue;
						if (data.controller != GameManager.ID)
						{
							Mod.SetKinematicRecursive(((Component)((AttachableFirearm)val).Attachment).transform, value: true);
						}
					}
				}
				else
				{
					FVRFireArmAttachmentMount val2 = null;
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
					bool flag2 = false;
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						if (trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > newData[0])
						{
							val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[newData[0]];
						}
					}
					else
					{
						flag2 = true;
						if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value2))
						{
							value2.Add(this);
						}
						else
						{
							toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
						}
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)(object)val2)
					{
						data.ignoreParentChanged++;
						if ((Object)(object)((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).curMount != (Object)null)
						{
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).Sensor.m_storedScaleMagnified = 1f;
							((Component)((AttachableFirearm)val).Attachment).transform.localScale = new Vector3(1f, 1f, 1f);
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).DetachFromMount();
						}
						if (CanAttachToMount((FVRFireArmAttachment)(object)((AttachableFirearm)val).Attachment, val2))
						{
							if (val2.GetRootMount().ParentToThis)
							{
								((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
							}
							else
							{
								((Component)val2.MyObject).transform.localScale = mountObjectScale;
							}
							if (((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).CanScaleToMount && val2.CanThisRescale())
							{
								((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).ScaleToMount(val2);
							}
							((FVRFireArmAttachment)((AttachableFirearm)val).Attachment).AttachToMount(val2, true);
							if (!((object)((Component)this).transform.localPosition/*cast due to .constrained prefix*/).Equals((object?)itemData.position))
							{
								((Component)this).transform.localPosition = itemData.position;
							}
							if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
							{
								for (int i = 0; i < value3.Count; i++)
								{
									if ((Object)(object)value3[i] != (Object)null)
									{
										value3[i].data.UpdateFromData(value3[i].data);
									}
								}
								toAttachByMountObjectID.Remove(data.trackedID);
							}
						}
						else if (!flag2)
						{
							if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value4))
							{
								value4.Add(this);
							}
							else
							{
								toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
							}
						}
						currentMountIndex = newData[0];
						data.ignoreParentChanged--;
					}
				}
			}
			flag |= b != currentMountIndex;
			bool flag3 = newData[1] == 1;
			if ((val.m_isBreachOpen && !flag3) || (!val.m_isBreachOpen && flag3))
			{
				val.ToggleBreach();
				flag = true;
			}
			val.m_isBreachOpen = flag3;
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					flag = true;
				}
			}
			else
			{
				FireArmRoundType val3 = (FireArmRoundType)num;
				FireArmRoundClass val4 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val4)
				{
					if (val.Chamber.RoundType == val3)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val3;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val4, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					flag = true;
				}
			}
			itemData.data = newData;
			return flag;
		}

		private void AttachableBreakActionsChamberRound(FireArmRoundType roundType, FireArmRoundClass roundClass)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			AttachableBreakActions val = null;
			val = (AttachableBreakActions)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			if ((int)roundClass == -1)
			{
				ChamberPatch.chamberSkip++;
				val.Chamber.SetRound((FVRFireArmRound)null, false);
				ChamberPatch.chamberSkip--;
				return;
			}
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private FVRFireArmChamber AttachableBreakActionsGetChamber()
		{
			AttachableBreakActions val = null;
			val = (AttachableBreakActions)((!(dataObject is AttachableFirearm)) ? /*isinst with value type is only supported in some contexts*/: /*isinst with value type is only supported in some contexts*/);
			return val.Chamber;
		}

		private void ChamberAttachableBreakActionsRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			AttachableBreakActions val = (AttachableBreakActions)(object)((obj is AttachableBreakActions) ? obj : null);
			ChamberPatch.chamberSkip++;
			if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private void UpdateAttachableFirearmParent()
		{
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			FVRFireArmAttachment attachment = (FVRFireArmAttachment)(object)((AttachableFirearm)((obj is AttachableFirearm) ? obj : null)).Attachment;
			List<TrackedItem> value5;
			if (currentMountIndex != byte.MaxValue)
			{
				if (mountObjectID == -1)
				{
					return;
				}
				FVRFireArmAttachmentMount val = null;
				TrackedItemData trackedItemData = null;
				trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
				if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					val = trackedItemData.physicalItem.physicalItem.AttachmentMounts[currentMountIndex];
				}
				if ((Object)(object)attachment.curMount == (Object)null)
				{
					List<TrackedItem> value2;
					if (CanAttachToMount(attachment, val))
					{
						if (val.GetRootMount().ParentToThis)
						{
							((Component)val.GetRootMount()).transform.localScale = mountObjectScale;
						}
						else
						{
							((Component)val.MyObject).transform.localScale = mountObjectScale;
						}
						if (attachment.CanScaleToMount && val.CanThisRescale())
						{
							attachment.ScaleToMount(val);
						}
						data.ignoreParentChanged++;
						attachment.AttachToMount(val, true);
						data.ignoreParentChanged--;
						if (!toAttachByMountObjectID.TryGetValue(data.trackedID, out var value))
						{
							return;
						}
						for (int i = 0; i < value.Count; i++)
						{
							if ((Object)(object)value[i] != (Object)null)
							{
								value[i].data.UpdateFromData(value[i].data);
							}
						}
						toAttachByMountObjectID.Remove(data.trackedID);
					}
					else if (toAttachByMountObjectID.TryGetValue(mountObjectID, out value2))
					{
						value2.Add(this);
					}
					else
					{
						toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
					}
				}
				else
				{
					if (!((Object)(object)attachment.curMount != (Object)(object)val))
					{
						return;
					}
					data.ignoreParentChanged++;
					if ((Object)(object)attachment.curMount != (Object)null)
					{
						attachment.Sensor.m_storedScaleMagnified = 1f;
						((Component)attachment).transform.localScale = new Vector3(1f, 1f, 1f);
						attachment.DetachFromMount();
					}
					List<TrackedItem> value4;
					if (CanAttachToMount(attachment, val))
					{
						if (val.GetRootMount().ParentToThis)
						{
							((Component)val.GetRootMount()).transform.localScale = mountObjectScale;
						}
						else
						{
							((Component)val.MyObject).transform.localScale = mountObjectScale;
						}
						if (attachment.CanScaleToMount && val.CanThisRescale())
						{
							attachment.ScaleToMount(val);
						}
						attachment.AttachToMount(val, true);
						if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
						{
							for (int j = 0; j < value3.Count; j++)
							{
								if ((Object)(object)value3[j] != (Object)null)
								{
									value3[j].data.UpdateFromData(value3[j].data);
								}
							}
							toAttachByMountObjectID.Remove(data.trackedID);
						}
					}
					else if (toAttachByMountObjectID.TryGetValue(mountObjectID, out value4))
					{
						value4.Add(this);
					}
					else
					{
						toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
					}
					data.ignoreParentChanged--;
				}
			}
			else if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out value5))
			{
				value5.Remove(this);
			}
		}

		private bool UpdateLAPD2019Battery()
		{
			Object obj = dataObject;
			LAPD2019Battery val = (LAPD2019Battery)(object)((obj is LAPD2019Battery) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[4];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			BitConverter.GetBytes(val.GetEnergy()).CopyTo(itemData.data, 0);
			return flag | (b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3]);
		}

		private bool UpdateGivenLAPD2019Battery(byte[] newData)
		{
			bool result = false;
			Object obj = dataObject;
			LAPD2019Battery val = (LAPD2019Battery)(object)((obj is LAPD2019Battery) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.SetEnergy(BitConverter.ToSingle(newData, 0));
			}
			else if (itemData.data[11] != newData[11] || itemData.data[12] != newData[12] || itemData.data[13] != newData[13] || itemData.data[14] != newData[14])
			{
				val.SetEnergy(BitConverter.ToSingle(newData, 0));
				result = true;
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateLAPD2019()
		{
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			LAPD2019 val = (LAPD2019)(object)((obj is LAPD2019) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[26];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.CurChamber;
			flag |= b != itemData.data[0];
			byte b2;
			byte b3;
			byte b4;
			for (int i = 0; i < 5; i++)
			{
				int num = i * 4 + 1;
				b = itemData.data[num];
				b2 = itemData.data[num + 1];
				b3 = itemData.data[num + 2];
				b4 = itemData.data[num + 3];
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].IsSpent || val.Chambers[i].GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundType).CopyTo(itemData.data, num);
					BitConverter.GetBytes((short)val.Chambers[i].GetRound().RoundClass).CopyTo(itemData.data, num + 2);
				}
				flag |= b != itemData.data[num] || b2 != itemData.data[num + 1] || b3 != itemData.data[num + 2] || b4 != itemData.data[num + 3];
			}
			b = itemData.data[21];
			b2 = itemData.data[22];
			b3 = itemData.data[23];
			b4 = itemData.data[24];
			BitConverter.GetBytes(val.m_capacitorCharge).CopyTo(itemData.data, 21);
			flag |= b != itemData.data[21] || b2 != itemData.data[22] || b3 != itemData.data[23] || b4 != itemData.data[24];
			b = itemData.data[25];
			itemData.data[25] = (byte)(val.m_isCapacitorCharged ? 1 : 0);
			return flag | (b != itemData.data[25]);
		}

		private bool UpdateGivenLAPD2019(byte[] newData)
		{
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			LAPD2019 val = (LAPD2019)(object)((obj is LAPD2019) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.CurChamber = newData[0];
				val.m_capacitorCharge = BitConverter.ToSingle(newData, 21);
				val.m_isCapacitorCharged = newData[25] == 1;
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.CurChamber = newData[0];
					result = true;
				}
				if (itemData.data[21] != newData[21] || itemData.data[22] != newData[22] || itemData.data[23] != newData[23] || itemData.data[24] != newData[24])
				{
					val.m_capacitorCharge = BitConverter.ToSingle(newData, 21);
					result = true;
				}
				if (itemData.data[25] != newData[25])
				{
					val.m_isCapacitorCharged = newData[25] == 1;
					result = true;
				}
			}
			for (int i = 0; i < 5; i++)
			{
				short num = BitConverter.ToInt16(newData, i * 4 + 1);
				short num2 = BitConverter.ToInt16(newData, i * 4 + 3);
				if (num2 == -1)
				{
					if ((Object)(object)val.Chambers[i].GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chambers[i].GetRound() == (Object)null || val.Chambers[i].GetRound().RoundClass != val3)
				{
					if (val.Chambers[i].RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chambers[i].RoundType;
						val.Chambers[i].RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chambers[i].SetRound(val3, ((Component)val.Chambers[i]).transform.position, ((Component)val.Chambers[i]).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chambers[i].RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private int GetLAPD2019ChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			LAPD2019 val = (LAPD2019)(object)((obj is LAPD2019) ? obj : null);
			FVRFireArmChamber[] chambers = val.Chambers;
			if ((Object)(object)chamber == (Object)null)
			{
				return -1;
			}
			for (int i = 0; i < chambers.Length; i++)
			{
				if ((Object)(object)chambers[i] == (Object)(object)chamber)
				{
					return i;
				}
			}
			return -1;
		}

		private bool UpdateGirandoni()
		{
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Girandoni val = (Girandoni)(object)((obj is Girandoni) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[14];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.HasAirTank ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.m_isHammerCocked ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			flag |= b != itemData.data[2] || b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5];
			b = itemData.data[6];
			b2 = itemData.data[7];
			b3 = itemData.data[8];
			b4 = itemData.data[9];
			BitConverter.GetBytes(val.m_airTankAir).CopyTo(itemData.data, 6);
			flag |= b != itemData.data[6] || b2 != itemData.data[7] || b3 != itemData.data[8] || b4 != itemData.data[9];
			b = itemData.data[10];
			b2 = itemData.data[11];
			b3 = itemData.data[12];
			b4 = itemData.data[13];
			BitConverter.GetBytes(val.CatchRot).CopyTo(itemData.data, 10);
			return flag | (b != itemData.data[10] || b2 != itemData.data[11] || b3 != itemData.data[12] || b4 != itemData.data[13]);
		}

		private bool UpdateGivenGirandoni(byte[] newData)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a3: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			Girandoni val = (Girandoni)(object)((obj is Girandoni) ? obj : null);
			if (!val.HasAirTank && newData[0] == 1)
			{
				val.HasAirTank = true;
				val.CatchRot = BitConverter.ToSingle(newData, 10);
				Vector3 up = val.AirTankRoot.up;
				up = Quaternion.AngleAxis(val.CatchRot, val.AirTankRoot.forward) * up;
				Quaternion rotation = Quaternion.LookRotation(val.AirTankRoot.forward, up);
				val.ProxyAirTank.transform.rotation = rotation;
				val.ProxyAirTank.transform.localPosition = Vector3.Lerp(val.AirTankPoint_Close.localPosition, val.AirTankPoint_Far.localPosition, val.CatchRot / val.MaxCatchRot);
				val.m_airTankAir = BitConverter.ToSingle(newData, 6);
				((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
				val.ProxyAirTank.SetActive(true);
			}
			else if (val.HasAirTank && newData[0] == 0)
			{
				val.HasAirTank = false;
				val.ProxyAirTank.SetActive(false);
				val.m_airTankAir = 0f;
				((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)21, 1f);
				val.CatchRot = val.MaxCatchRot;
			}
			if (newData[1] == 1 && !val.m_isHammerCocked)
			{
				val.CockHammer();
			}
			else if (newData[1] == 0 && val.m_isHammerCocked)
			{
				val.m_isHammerCocked = false;
			}
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			if (val.HasAirTank)
			{
				val.m_airTankAir = BitConverter.ToSingle(newData, 6);
				val.CatchRot = BitConverter.ToSingle(newData, 10);
			}
			itemData.data = newData;
			return result;
		}

		private bool FireGirandoni(int chamberIndex)
		{
			Object obj = dataObject;
			Girandoni val = (Girandoni)(object)((obj is Girandoni) ? obj : null);
			val.Fire();
			return true;
		}

		private void SetGirandoniUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Girandoni val = (Girandoni)(object)((obj is Girandoni) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
			if (val.m_airTankAir < 1f)
			{
				val.m_airTankAir = 1f;
			}
		}

		private bool UpdateMeatNailer()
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			MeatNailer val = (MeatNailer)(object)((obj is MeatNailer) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[val.ammoTrack.holders.Length * 4 + 4];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 2);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 0);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 2);
			}
			flag |= b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3];
			for (int i = 0; i < val.ammoTrack.holders.Length; i++)
			{
				int num = i * 4 + 4;
				b = itemData.data[num];
				b2 = itemData.data[num + 1];
				b3 = itemData.data[num + 2];
				b4 = itemData.data[num + 3];
				if ((Object)(object)val.ammoTrack.holders[i].Chamber.GetRound() == (Object)null || val.ammoTrack.holders[i].Chamber.IsSpent || val.ammoTrack.holders[i].Chamber.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, num + 2);
				}
				else
				{
					BitConverter.GetBytes((short)val.ammoTrack.holders[i].Chamber.GetRound().RoundType).CopyTo(itemData.data, num);
					BitConverter.GetBytes((short)val.ammoTrack.holders[i].Chamber.GetRound().RoundClass).CopyTo(itemData.data, num + 2);
				}
				flag |= b != itemData.data[num] || b2 != itemData.data[num + 1] || b3 != itemData.data[num + 2] || b4 != itemData.data[num + 3];
			}
			return flag;
		}

		private bool UpdateGivenMeatNailer(byte[] newData)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			MeatNailer val = (MeatNailer)(object)((obj is MeatNailer) ? obj : null);
			short num = BitConverter.ToInt16(newData, 0);
			short num2 = BitConverter.ToInt16(newData, 2);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			for (int i = 0; i < val.ammoTrack.holders.Length; i++)
			{
				int num3 = i * 4 + 4;
				num = BitConverter.ToInt16(newData, num3);
				num2 = BitConverter.ToInt16(newData, num3 + 2);
				if (num2 == -1)
				{
					if ((Object)(object)val.ammoTrack.holders[i].Chamber.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val.ammoTrack.holders[i].Chamber.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
					continue;
				}
				FireArmRoundType val4 = (FireArmRoundType)num;
				FireArmRoundClass val5 = (FireArmRoundClass)num2;
				if ((Object)(object)val.ammoTrack.holders[i].Chamber.GetRound() == (Object)null || val.ammoTrack.holders[i].Chamber.GetRound().RoundClass != val5)
				{
					if (val.ammoTrack.holders[i].Chamber.RoundType == val4)
					{
						ChamberPatch.chamberSkip++;
						val.ammoTrack.holders[i].Chamber.SetRound(val5, ((Component)val.ammoTrack.holders[i].Chamber).transform.position, ((Component)val.ammoTrack.holders[i].Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType2 = val.ammoTrack.holders[i].Chamber.RoundType;
						val.ammoTrack.holders[i].Chamber.RoundType = val4;
						ChamberPatch.chamberSkip++;
						val.ammoTrack.holders[i].Chamber.SetRound(val5, ((Component)val.ammoTrack.holders[i].Chamber).transform.position, ((Component)val.ammoTrack.holders[i].Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.ammoTrack.holders[i].Chamber.RoundType = roundType2;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireMeatNailer(int chamberIndex)
		{
			Object obj = dataObject;
			MeatNailer val = (MeatNailer)(object)((obj is MeatNailer) ? obj : null);
			return val.Fire();
		}

		private void SetMeatNailerUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			MeatNailer val = (MeatNailer)(object)((obj is MeatNailer) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private int GetMeatNailerChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			MeatNailer val = (MeatNailer)(object)((obj is MeatNailer) ? obj : null);
			if ((Object)(object)val.Chamber == (Object)(object)chamber)
			{
				return 0;
			}
			for (int i = 0; i < val.ammoTrack.holders.Length; i++)
			{
				if ((Object)(object)val.ammoTrack.holders[i].Chamber == (Object)(object)chamber)
				{
					return i + 1;
				}
			}
			return -1;
		}

		private void ChamberMeatNailerRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			MeatNailer val = (MeatNailer)(object)((obj is MeatNailer) ? obj : null);
			FVRFireArmChamber chamber = val.Chamber;
			if (chamberIndex > 0)
			{
				chamber = val.ammoTrack.holders[chamberIndex - 1].Chamber;
			}
			FireArmRoundType roundType2 = chamber.RoundType;
			chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			chamber.SetRound(roundClass, ((Component)chamber).transform.position, ((Component)chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			chamber.RoundType = roundType2;
		}

		private bool UpdateSRG()
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			SRG val = (SRG)(object)((obj is SRG) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[4];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			byte b3 = itemData.data[2];
			byte b4 = itemData.data[3];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 2);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 0);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 2);
			}
			return flag | (b != itemData.data[0] || b2 != itemData.data[1] || b3 != itemData.data[2] || b4 != itemData.data[3]);
		}

		private bool UpdateGivenSRG(byte[] newData)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			SRG val = (SRG)(object)((obj is SRG) ? obj : null);
			short num = BitConverter.ToInt16(newData, 0);
			short num2 = BitConverter.ToInt16(newData, 2);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool FireSRG(int chamberIndex)
		{
			Object obj = dataObject;
			SRG val = (SRG)(object)((obj is SRG) ? obj : null);
			return val.Fire();
		}

		private void SetSRGUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			SRG val = (SRG)(object)((obj is SRG) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private bool UpdateSosigWeaponInterface()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			SosigWeaponPlayerInterface val = (SosigWeaponPlayerInterface)(object)((obj is SosigWeaponPlayerInterface) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[3];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			BitConverter.GetBytes((short)val.W.m_shotsLeft).CopyTo(itemData.data, 0);
			flag |= b != itemData.data[0] || b2 != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)val.W.MechaState;
			return flag | (b != itemData.data[2]);
		}

		private bool UpdateGivenSosigWeaponInterface(byte[] newData)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			SosigWeaponPlayerInterface val = (SosigWeaponPlayerInterface)(object)((obj is SosigWeaponPlayerInterface) ? obj : null);
			int num = 0;
			try
			{
				if (itemData.data == null)
				{
					num = 1;
					result = true;
					val.W.m_shotsLeft = BitConverter.ToInt16(newData, 0);
					num = 2;
					val.W.MechaState = (SosigWeaponMechaState)newData[2];
				}
				else
				{
					num = 3;
					if (itemData.data[0] != newData[0] || itemData.data[1] != newData[1])
					{
						num = 4;
						val.W.m_shotsLeft = BitConverter.ToInt16(newData, 0);
						result = true;
					}
					if (itemData.data[2] != newData[2])
					{
						num = 5;
						val.W.MechaState = (SosigWeaponMechaState)newData[2];
						result = true;
					}
				}
			}
			catch (Exception ex)
			{
				Mod.LogError("TrackedItem SosigWeaponPlayerInterface " + data.trackedID + " with local index " + data.localWaitingIndex + ", update given with newData size: " + newData.Length + " error at step: " + num + ": " + ex.Message + ":\n" + ex.StackTrace);
			}
			itemData.data = newData;
			return result;
		}

		private void SosigWeaponDestruction()
		{
			Object obj = dataObject;
			SosigWeaponPlayerInterface val = (SosigWeaponPlayerInterface)(object)((obj is SosigWeaponPlayerInterface) ? obj : null);
			if (!((Object)(object)val.W.SosigHoldingThis != (Object)null))
			{
				return;
			}
			if (val.W.HandHoldingThis != null)
			{
				if (val.W.HandHoldingThis.IsRightHand)
				{
					val.W.SosigHoldingThis.Hand_Primary.DropHeldObject();
				}
				else
				{
					val.W.SosigHoldingThis.Hand_Secondary.DropHeldObject();
				}
				return;
			}
			for (int i = 0; i < val.W.SosigHoldingThis.Inventory.Slots.Count; i++)
			{
				if (val.W.SosigHoldingThis.Inventory.Slots[i] != null && (Object)(object)val.W.SosigHoldingThis.Inventory.Slots[i].HeldObject == (Object)(object)val.W)
				{
					val.W.SosigHoldingThis.Inventory.Slots[i].DetachHeldObject();
					break;
				}
			}
		}

		private bool UpdateGrappleThrowable()
		{
			Object obj = dataObject;
			GrappleThrowable val = (GrappleThrowable)(object)((obj is GrappleThrowable) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[3];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.IsRopeFree ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)(val.m_hasBeenThrown ? 1 : 0);
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)(val.m_hasLanded ? 1 : 0);
			return flag | (b != itemData.data[2]);
		}

		private bool UpdateGivenGrappleThrowable(byte[] newData)
		{
			bool result = false;
			Object obj = dataObject;
			GrappleThrowable val = (GrappleThrowable)(object)((obj is GrappleThrowable) ? obj : null);
			if (itemData.data == null)
			{
				if (newData[0] == 0)
				{
					val.m_isRopeFree = false;
					val.BundledRope.SetActive(true);
					val.ClearRopeLengths();
					val.FakeRopeLength.SetActive(false);
					val.FakeKnot.SetActive(false);
				}
				else
				{
					val.FreeRope();
					val.FakeRopeLength.SetActive(true);
				}
				if (newData[1] == 0)
				{
					val.m_hasBeenThrown = false;
				}
				else
				{
					val.m_hasBeenThrown = true;
					val.FakeRopeLength.SetActive(false);
				}
				val.m_hasLanded = newData[2] == 1;
				result = true;
			}
			else
			{
				if (val.IsRopeFree && itemData.data[0] == 0)
				{
					val.m_isRopeFree = false;
					val.BundledRope.SetActive(true);
					val.ClearRopeLengths();
					val.FakeRopeLength.SetActive(false);
					val.FakeKnot.SetActive(false);
					result = true;
				}
				else if (!val.IsRopeFree && itemData.data[0] == 1)
				{
					val.FreeRope();
					val.FakeRopeLength.SetActive(true);
					result = true;
				}
				if (newData[1] == 0 && val.m_hasBeenThrown)
				{
					val.m_hasBeenThrown = false;
					result = true;
				}
				else if (newData[1] == 1 && !val.m_hasBeenThrown)
				{
					val.m_hasBeenThrown = true;
					val.FakeRopeLength.SetActive(false);
					result = true;
				}
				if ((newData[2] == 0 && val.m_hasLanded) || (newData[2] == 1 && !val.m_hasLanded))
				{
					val.m_hasLanded = newData[2] == 1;
					result = true;
				}
			}
			itemData.data = newData;
			return result;
		}

		private bool UpdateUberShatterable()
		{
			return false;
		}

		private bool UpdateGivenUberShatterable(byte[] newData)
		{
			return false;
		}

		private bool UpdateGasCuboid()
		{
			return false;
		}

		private bool UpdateGivenGasCuboid(byte[] newData)
		{
			return false;
		}

		private bool UpdateClosedBoltWeapon()
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			ClosedBoltWeapon val = (ClosedBoltWeapon)(object)((obj is ClosedBoltWeapon) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? 7 : 11];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.FireSelectorModeIndex;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)val.m_CamBurst;
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)(val.IsHammerCocked ? 1 : 0);
			flag |= b != itemData.data[2];
			b = itemData.data[3];
			byte b2 = itemData.data[4];
			byte b3 = itemData.data[5];
			byte b4 = itemData.data[6];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 5);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 3);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 5);
			}
			flag |= b != itemData.data[3] || b2 != itemData.data[4] || b3 != itemData.data[5] || b4 != itemData.data[6];
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[7];
				b2 = itemData.data[8];
				b3 = itemData.data[9];
				b4 = itemData.data[10];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 9);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, 7);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, 9);
				}
				flag |= b != itemData.data[7] || b2 != itemData.data[8] || b3 != itemData.data[9] || b4 != itemData.data[10];
			}
			return flag;
		}

		private bool UpdateGivenClosedBoltWeapon(byte[] newData)
		{
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			ClosedBoltWeapon val = (ClosedBoltWeapon)(object)((obj is ClosedBoltWeapon) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_fireSelectorMode = newData[0];
				val.m_CamBurst = newData[1];
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_fireSelectorMode = newData[0];
					result = true;
				}
				if (itemData.data[1] != newData[1])
				{
					val.m_CamBurst = newData[1];
					result = true;
				}
			}
			if (newData[2] == 0)
			{
				if (val.IsHammerCocked)
				{
					val.m_isHammerCocked = BitConverter.ToBoolean(newData, 2);
					result = true;
				}
			}
			else if (!val.IsHammerCocked)
			{
				val.CockHammer(false);
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 3);
			short num2 = BitConverter.ToInt16(newData, 5);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				num = BitConverter.ToInt16(newData, 7);
				num2 = BitConverter.ToInt16(newData, 9);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num2 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num;
					FireArmRoundClass val6 = (FireArmRoundClass)num2;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private void SetCBWUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			ClosedBoltWeapon val = (ClosedBoltWeapon)dataObject;
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private void ChamberClosedBoltWeaponRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_009a: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			ClosedBoltWeapon val = (ClosedBoltWeapon)dataObject;
			ChamberPatch.chamberSkip++;
			if (chamberIndex == 1)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private int GetClosedBoltWeaponChamberIndex(FVRFireArmChamber chamber)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			ClosedBoltWeapon val = (ClosedBoltWeapon)dataObject;
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null)
			{
				return 0;
			}
			return (!((Object)(object)chamber == (Object)(object)val.Chamber)) ? 1 : 0;
		}

		private bool FireCBW(int chamberIndex)
		{
			Object obj = dataObject;
			return ((ClosedBoltWeapon)((obj is ClosedBoltWeapon) ? obj : null)).Fire();
		}

		private bool UpdateHandgun()
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Handgun val = (Handgun)(object)((obj is Handgun) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? 8 : 12];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.FireSelectorModeIndex;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = (byte)val.m_CamBurst;
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)(val.m_isHammerCocked ? 1 : 0);
			flag |= b != itemData.data[2];
			b = itemData.data[3];
			byte b2 = itemData.data[4];
			byte b3 = itemData.data[5];
			byte b4 = itemData.data[6];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 5);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 3);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 5);
			}
			flag |= b != itemData.data[3] || b2 != itemData.data[4] || b3 != itemData.data[5] || b4 != itemData.data[6];
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[7];
				b2 = itemData.data[8];
				b3 = itemData.data[9];
				b4 = itemData.data[10];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 9);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, 7);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, 9);
				}
				flag |= b != itemData.data[7] || b2 != itemData.data[8] || b3 != itemData.data[9] || b4 != itemData.data[10];
				if ((Object)(object)integratedLaser != (Object)null)
				{
					b = itemData.data[11];
					itemData.data[11] = (byte)(integratedLaser.m_isOn ? 1 : 0);
					flag |= b != itemData.data[11];
				}
			}
			else if ((Object)(object)integratedLaser != (Object)null)
			{
				b = itemData.data[7];
				itemData.data[7] = (byte)(integratedLaser.m_isOn ? 1 : 0);
				flag |= b != itemData.data[7];
			}
			return flag;
		}

		private bool UpdateGivenHandgun(byte[] newData)
		{
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			Handgun val = (Handgun)(object)((obj is Handgun) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_fireSelectorMode = newData[0];
				val.m_CamBurst = newData[1];
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_fireSelectorMode = newData[0];
					result = true;
				}
				if (itemData.data[1] != newData[1])
				{
					val.m_CamBurst = newData[1];
					result = true;
				}
			}
			bool isHammerCocked = val.m_isHammerCocked;
			if (newData[2] == 0)
			{
				if (isHammerCocked)
				{
					val.m_isHammerCocked = BitConverter.ToBoolean(newData, 2);
					result = true;
				}
			}
			else if (!isHammerCocked)
			{
				val.CockHammer(false);
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 3);
			short num2 = BitConverter.ToInt16(newData, 5);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				num = BitConverter.ToInt16(newData, 7);
				num2 = BitConverter.ToInt16(newData, 9);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num2 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num;
					FireArmRoundClass val6 = (FireArmRoundClass)num2;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
				if ((Object)(object)integratedLaser != (Object)null)
				{
					if (newData[11] == 1 && !integratedLaser.m_isOn)
					{
						integratedLaser.TurnOn();
					}
					else if (newData[11] == 0 && integratedLaser.m_isOn)
					{
						integratedLaser.TurnOff();
					}
				}
			}
			else if ((Object)(object)integratedLaser != (Object)null)
			{
				if (newData[7] == 1 && !integratedLaser.m_isOn)
				{
					integratedLaser.TurnOn();
				}
				else if (newData[7] == 0 && integratedLaser.m_isOn)
				{
					integratedLaser.TurnOff();
				}
			}
			itemData.data = newData;
			return result;
		}

		private void SetHandgunUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Handgun val = (Handgun)(object)((obj is Handgun) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private int GetHandgunChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			Handgun val = (Handgun)(object)((obj is Handgun) ? obj : null);
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null)
			{
				return 0;
			}
			return (!((Object)(object)chamber == (Object)(object)val.Chamber)) ? 1 : 0;
		}

		private void ChamberHandgunRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_009a: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			Handgun val = (Handgun)(object)((obj is Handgun) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == 1)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool FireHandgun(int chamberIndex)
		{
			Object obj = dataObject;
			return ((Handgun)((obj is Handgun) ? obj : null)).Fire();
		}

		private bool UpdateTubeFedShotgun()
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			TubeFedShotgun val = (TubeFedShotgun)(object)((obj is TubeFedShotgun) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? 8 : 12];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)(val.IsSafetyEngaged ? 1 : 0);
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = BitConverter.GetBytes(val.IsHammerCocked)[0];
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			flag |= b != itemData.data[2] || b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5];
			b = itemData.data[6];
			itemData.data[6] = (byte)val.Bolt.CurPos;
			flag |= b != itemData.data[6];
			if (val.HasHandle)
			{
				b = itemData.data[7];
				itemData.data[7] = (byte)val.Handle.CurPos;
				flag |= b != itemData.data[7];
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[8];
				b2 = itemData.data[9];
				b3 = itemData.data[10];
				b4 = itemData.data[11];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val2.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 10);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, 8);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, 10);
				}
				flag |= b != itemData.data[8] || b2 != itemData.data[9] || b3 != itemData.data[10] || b4 != itemData.data[11];
			}
			return flag;
		}

		private bool UpdateGivenTubeFedShotgun(byte[] newData)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			TubeFedShotgun val = (TubeFedShotgun)(object)((obj is TubeFedShotgun) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				if (val.HasSafety && ((newData[0] == 1 && !val.IsSafetyEngaged) || (newData[0] == 0 && val.IsSafetyEngaged)))
				{
					val.ToggleSafety();
				}
				val.Bolt.LastPos = val.Bolt.CurPos;
				val.Bolt.CurPos = (BoltPos)newData[6];
				if (val.HasHandle)
				{
					val.Handle.LastPos = val.Handle.CurPos;
					val.Handle.CurPos = (BoltPos)newData[7];
				}
			}
			else
			{
				if (val.HasSafety && ((newData[0] == 1 && !val.IsSafetyEngaged) || (newData[0] == 0 && val.IsSafetyEngaged)))
				{
					val.ToggleSafety();
					result = true;
				}
				if (itemData.data[6] != newData[6])
				{
					val.Bolt.LastPos = val.Bolt.CurPos;
					val.Bolt.CurPos = (BoltPos)newData[6];
				}
				if (val.HasHandle && itemData.data[7] != newData[7])
				{
					val.Handle.LastPos = val.Handle.CurPos;
					val.Handle.CurPos = (BoltPos)newData[7];
				}
			}
			if (newData[1] == 0)
			{
				if (val.IsHammerCocked)
				{
					val.m_isHammerCocked = false;
					result = true;
				}
			}
			else if (!val.IsHammerCocked)
			{
				val.CockHammer();
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				num = BitConverter.ToInt16(newData, 8);
				num2 = BitConverter.ToInt16(newData, 11);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num2 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num;
					FireArmRoundClass val6 = (FireArmRoundClass)num2;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private void SetTFSUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			TubeFedShotgun val = (TubeFedShotgun)(object)((obj is TubeFedShotgun) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private int GetTubeFedShotgunChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			TubeFedShotgun val = (TubeFedShotgun)(object)((obj is TubeFedShotgun) ? obj : null);
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null)
			{
				return 0;
			}
			return (!((Object)(object)chamber == (Object)(object)val.Chamber)) ? 1 : 0;
		}

		private void ChamberTubeFedShotgunRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_009a: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			TubeFedShotgun val = (TubeFedShotgun)(object)((obj is TubeFedShotgun) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == 1)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool FireTFS(int chamberIndex)
		{
			Object obj = dataObject;
			return ((TubeFedShotgun)((obj is TubeFedShotgun) ? obj : null)).Fire();
		}

		private bool UpdateBoltActionRifle()
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BoltActionRifle val = (BoltActionRifle)(object)((obj is BoltActionRifle) ? obj : null);
			bool flag = false;
			if (itemData.data == null)
			{
				itemData.data = new byte[((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null) ? 8 : 12];
				flag = true;
			}
			byte b = itemData.data[0];
			itemData.data[0] = (byte)val.m_fireSelectorMode;
			flag |= b != itemData.data[0];
			b = itemData.data[1];
			itemData.data[1] = BitConverter.GetBytes(val.IsHammerCocked)[0];
			flag |= b != itemData.data[1];
			b = itemData.data[2];
			byte b2 = itemData.data[3];
			byte b3 = itemData.data[4];
			byte b4 = itemData.data[5];
			if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.IsSpent || val.Chamber.GetRound().IsSpent)
			{
				BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 4);
			}
			else
			{
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundType).CopyTo(itemData.data, 2);
				BitConverter.GetBytes((short)val.Chamber.GetRound().RoundClass).CopyTo(itemData.data, 4);
			}
			flag |= b != itemData.data[2] || b2 != itemData.data[3] || b3 != itemData.data[4] || b4 != itemData.data[5];
			b = itemData.data[6];
			itemData.data[6] = (byte)val.CurBoltHandleState;
			flag |= b != itemData.data[6];
			b = itemData.data[7];
			itemData.data[7] = (byte)val.BoltHandle.HandleRot;
			flag |= b != itemData.data[7];
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				b = itemData.data[8];
				b2 = itemData.data[9];
				b3 = itemData.data[10];
				b4 = itemData.data[11];
				FVRFireArmChamber val2 = attachableFirearmGetChamberFunc();
				if ((Object)(object)val2.GetRound() == (Object)null || val.Chamber.IsSpent || val2.GetRound().IsSpent)
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, 10);
				}
				else
				{
					BitConverter.GetBytes((short)val2.GetRound().RoundType).CopyTo(itemData.data, 8);
					BitConverter.GetBytes((short)val2.GetRound().RoundClass).CopyTo(itemData.data, 10);
				}
				flag |= b != itemData.data[8] || b2 != itemData.data[9] || b3 != itemData.data[10] || b4 != itemData.data[11];
			}
			return flag;
		}

		private bool UpdateGivenBoltActionRifle(byte[] newData)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			BoltActionRifle val = (BoltActionRifle)(object)((obj is BoltActionRifle) ? obj : null);
			if (itemData.data == null)
			{
				result = true;
				val.m_fireSelectorMode = newData[0];
				val.LastBoltHandleState = val.CurBoltHandleState;
				val.CurBoltHandleState = (BoltActionHandleState)newData[6];
				val.BoltHandle.LastHandleRot = val.BoltHandle.HandleRot;
				val.BoltHandle.HandleRot = (BoltActionHandleRot)newData[7];
			}
			else
			{
				if (itemData.data[0] != newData[0])
				{
					val.m_fireSelectorMode = newData[0];
					result = true;
				}
				if (itemData.data[6] != newData[6])
				{
					val.LastBoltHandleState = val.CurBoltHandleState;
					val.CurBoltHandleState = (BoltActionHandleState)newData[6];
				}
				if (itemData.data[7] != newData[7])
				{
					val.BoltHandle.LastHandleRot = val.BoltHandle.HandleRot;
					val.BoltHandle.HandleRot = (BoltActionHandleRot)newData[7];
				}
			}
			if (newData[1] == 0)
			{
				if (val.IsHammerCocked)
				{
					val.m_isHammerCocked = BitConverter.ToBoolean(newData, 1);
					result = true;
				}
			}
			else if (!val.IsHammerCocked)
			{
				val.CockHammer();
				result = true;
			}
			short num = BitConverter.ToInt16(newData, 2);
			short num2 = BitConverter.ToInt16(newData, 4);
			if (num2 == -1)
			{
				if ((Object)(object)val.Chamber.GetRound() != (Object)null)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
					result = true;
				}
			}
			else
			{
				FireArmRoundType val2 = (FireArmRoundType)num;
				FireArmRoundClass val3 = (FireArmRoundClass)num2;
				if ((Object)(object)val.Chamber.GetRound() == (Object)null || val.Chamber.GetRound().RoundClass != val3)
				{
					if (val.Chamber.RoundType == val2)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
					else
					{
						FireArmRoundType roundType = val.Chamber.RoundType;
						val.Chamber.RoundType = val2;
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound(val3, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
						val.Chamber.RoundType = roundType;
					}
					result = true;
				}
			}
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() != (Object)null)
			{
				num = BitConverter.ToInt16(newData, 8);
				num2 = BitConverter.ToInt16(newData, 11);
				FVRFireArmChamber val4 = attachableFirearmGetChamberFunc();
				if (num2 == -1)
				{
					if ((Object)(object)val4.GetRound() != (Object)null)
					{
						ChamberPatch.chamberSkip++;
						val4.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
						result = true;
					}
				}
				else
				{
					FireArmRoundType val5 = (FireArmRoundType)num;
					FireArmRoundClass val6 = (FireArmRoundClass)num2;
					if ((Object)(object)val4.GetRound() == (Object)null || val4.GetRound().RoundClass != val6)
					{
						if (val4.RoundType == val5)
						{
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
						}
						else
						{
							FireArmRoundType roundType2 = val4.RoundType;
							val4.RoundType = val5;
							ChamberPatch.chamberSkip++;
							val4.SetRound(val6, ((Component)val4).transform.position, ((Component)val4).transform.rotation);
							ChamberPatch.chamberSkip--;
							val4.RoundType = roundType2;
						}
						result = true;
					}
				}
			}
			itemData.data = newData;
			return result;
		}

		private void SetBARUpdateOverride(FireArmRoundType roundType, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BoltActionRifle val = (BoltActionRifle)(object)((obj is BoltActionRifle) ? obj : null);
			FireArmRoundType roundType2 = val.Chamber.RoundType;
			val.Chamber.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			ChamberPatch.chamberSkip--;
			val.Chamber.RoundType = roundType2;
		}

		private int GetBoltActionRifleChamberIndex(FVRFireArmChamber chamber)
		{
			Object obj = dataObject;
			BoltActionRifle val = (BoltActionRifle)(object)((obj is BoltActionRifle) ? obj : null);
			if ((Object)(object)((FVRFireArm)val).GetIntegratedAttachableFirearm() == (Object)null)
			{
				return 0;
			}
			return (!((Object)(object)chamber == (Object)(object)val.Chamber)) ? 1 : 0;
		}

		private void ChamberBoltActionRifleRound(FireArmRoundClass roundClass, FireArmRoundType roundType, int chamberIndex)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_009a: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			BoltActionRifle val = (BoltActionRifle)(object)((obj is BoltActionRifle) ? obj : null);
			ChamberPatch.chamberSkip++;
			if (chamberIndex == 1)
			{
				if ((int)roundClass == -1)
				{
					attachableFirearmGetChamberFunc().SetRound((FVRFireArmRound)null, false);
				}
				else
				{
					attachableFirearmGetChamberFunc().SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
				}
			}
			else if ((int)roundClass == -1)
			{
				val.Chamber.SetRound((FVRFireArmRound)null, false);
			}
			else
			{
				val.Chamber.SetRound(roundClass, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
			}
			ChamberPatch.chamberSkip--;
		}

		private bool FireBAR(int chamberIndex)
		{
			Object obj = dataObject;
			return ((BoltActionRifle)((obj is BoltActionRifle) ? obj : null)).Fire();
		}

		private bool UpdateSuppressor()
		{
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			Suppressor val = (Suppressor)(object)((obj is Suppressor) ? obj : null);
			if (itemData.data == null)
			{
				itemData.data = new byte[21];
				flag = true;
			}
			byte b = itemData.data[0];
			if ((Object)(object)((FVRFireArmAttachment)val).curMount == (Object)null)
			{
				itemData.data[0] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmAttachment)val).curMount.MyObject.AttachmentMounts.Count; i++)
				{
					if ((Object)(object)((FVRFireArmAttachment)val).curMount.MyObject.AttachmentMounts[i] == (Object)(object)((FVRFireArmAttachment)val).curMount)
					{
						itemData.data[0] = (byte)i;
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[0] = byte.MaxValue;
				}
			}
			byte[] array = new byte[4]
			{
				itemData.data[1],
				itemData.data[2],
				itemData.data[3],
				itemData.data[4]
			};
			BitConverter.GetBytes(val.CatchRot).CopyTo(itemData.data, 1);
			flag |= array[1] != itemData.data[2] || array[2] != itemData.data[3] || array[3] != itemData.data[4];
			array[0] = itemData.data[5];
			array[1] = itemData.data[6];
			array[2] = itemData.data[7];
			array[3] = itemData.data[8];
			BitConverter.GetBytes(mountObjectID).CopyTo(itemData.data, 5);
			flag |= array[0] != itemData.data[5] || array[1] != itemData.data[6] || array[2] != itemData.data[7] || array[3] != itemData.data[8];
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				mountObjectScale = Vector3.one;
				array[0] = itemData.data[9];
				array[1] = itemData.data[10];
				array[2] = itemData.data[11];
				array[3] = itemData.data[12];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 9);
				flag |= array[1] != itemData.data[10] || array[2] != itemData.data[11] || array[3] != itemData.data[12];
				array[0] = itemData.data[13];
				array[1] = itemData.data[14];
				array[2] = itemData.data[15];
				array[3] = itemData.data[16];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 13);
				flag |= array[1] != itemData.data[14] || array[2] != itemData.data[15] || array[3] != itemData.data[16];
				array[0] = itemData.data[17];
				array[1] = itemData.data[18];
				array[2] = itemData.data[19];
				array[3] = itemData.data[20];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 17);
				flag |= array[1] != itemData.data[18] || array[2] != itemData.data[19] || array[3] != itemData.data[20];
			}
			else
			{
				mountObjectScale = ((Component)this).transform.parent.localScale;
				array[0] = itemData.data[9];
				array[1] = itemData.data[10];
				array[2] = itemData.data[11];
				array[3] = itemData.data[12];
				BitConverter.GetBytes(((Component)this).transform.parent.localScale.x).CopyTo(itemData.data, 9);
				flag |= array[1] != itemData.data[10] || array[2] != itemData.data[11] || array[3] != itemData.data[12];
				array[0] = itemData.data[13];
				array[1] = itemData.data[14];
				array[2] = itemData.data[15];
				array[3] = itemData.data[16];
				BitConverter.GetBytes(((Component)this).transform.parent.localScale.y).CopyTo(itemData.data, 13);
				flag |= array[1] != itemData.data[14] || array[2] != itemData.data[15] || array[3] != itemData.data[16];
				array[0] = itemData.data[17];
				array[1] = itemData.data[18];
				array[2] = itemData.data[19];
				array[3] = itemData.data[20];
				BitConverter.GetBytes(((Component)this).transform.parent.localScale.z).CopyTo(itemData.data, 17);
				flag |= array[1] != itemData.data[18] || array[2] != itemData.data[19] || array[3] != itemData.data[20];
			}
			return flag || b != itemData.data[0];
		}

		private bool UpdateGivenSuppressor(byte[] newData)
		{
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0782: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			Suppressor val = (Suppressor)(object)((obj is Suppressor) ? obj : null);
			if (itemData.data == null || itemData.data.Length != newData.Length)
			{
				itemData.data = new byte[5];
				itemData.data[0] = byte.MaxValue;
				currentMountIndex = byte.MaxValue;
				flag = true;
			}
			Mod.LogInfo("UpdateGivenSuppressor on " + ((Object)this).name + " at " + data.trackedID + ", mount index: " + newData[0]);
			byte b = currentMountIndex;
			if (newData[0] == byte.MaxValue)
			{
				Mod.LogInfo("\tNo mount index");
				if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out var value))
				{
					Mod.LogInfo("\t\tWe were waiting for mount object, removing");
					value.Remove(this);
				}
				if ((Object)(object)((FVRFireArmAttachment)val).curMount != (Object)null)
				{
					Mod.LogInfo("\t\tWe have mount, detaching");
					((FVRFireArmAttachment)val).Sensor.m_storedScaleMagnified = 1f;
					((Component)val).transform.localScale = new Vector3(1f, 1f, 1f);
					data.ignoreParentChanged++;
					((FVRFireArmAttachment)val).DetachFromMount();
					data.ignoreParentChanged--;
					currentMountIndex = byte.MaxValue;
					if (data.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)val).transform, value: true);
					}
				}
			}
			else
			{
				mountObjectID = BitConverter.ToInt32(newData, 5);
				mountObjectScale = new Vector3(BitConverter.ToSingle(newData, 9), BitConverter.ToSingle(newData, 13), BitConverter.ToSingle(newData, 17));
				Mod.LogInfo("\tHave mount index, object ID: " + mountObjectID + ", scale: " + ((object)Unsafe.As<Vector3, Vector3>(ref mountObjectScale)/*cast due to .constrained prefix*/).ToString());
				if (mountObjectID == -1)
				{
					Mod.LogInfo("\t\tWe have mount index but no mount object yet");
					if ((Object)(object)((FVRFireArmAttachment)val).curMount != (Object)null)
					{
						((FVRFireArmAttachment)val).Sensor.m_storedScaleMagnified = 1f;
						((Component)val).transform.localScale = new Vector3(1f, 1f, 1f);
						data.ignoreParentChanged++;
						((FVRFireArmAttachment)val).DetachFromMount();
						data.ignoreParentChanged--;
						if (data.controller != GameManager.ID)
						{
							Mod.SetKinematicRecursive(((Component)val).transform, value: true);
						}
					}
				}
				else
				{
					Mod.LogInfo("\t\tHave mount index and mount object ID");
					FVRFireArmAttachmentMount val2 = null;
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
					bool flag2 = false;
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						Mod.LogInfo("\t\t\tGot mount object " + ((Object)trackedItemData.physicalItem).name);
						if (trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > newData[0])
						{
							Mod.LogInfo("\t\t\t\tMount index fits");
							val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[newData[0]];
						}
					}
					else
					{
						Mod.LogInfo("\t\t\tDont yet have mount object, adding to toAttachByMountObjectID");
						flag2 = true;
						if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value2))
						{
							value2.Add(this);
						}
						else
						{
							toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
						}
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)((FVRFireArmAttachment)val).curMount)
					{
						Mod.LogInfo("\t\t\tGot mount and is different: " + ((Object)val2).name);
						data.ignoreParentChanged++;
						if ((Object)(object)((FVRFireArmAttachment)val).curMount != (Object)null)
						{
							Mod.LogInfo("\t\t\t\tDetaching from old mount first");
							((FVRFireArmAttachment)val).Sensor.m_storedScaleMagnified = 1f;
							((Component)val).transform.localScale = new Vector3(1f, 1f, 1f);
							((FVRFireArmAttachment)val).DetachFromMount();
						}
						if (CanAttachToMount((FVRFireArmAttachment)(object)val, val2))
						{
							Mod.LogInfo("\t\t\tCan attach");
							if (val2.GetRootMount().ParentToThis)
							{
								((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
							}
							else
							{
								((Component)val2.MyObject).transform.localScale = mountObjectScale;
							}
							if (((FVRFireArmAttachment)val).CanScaleToMount && val2.CanThisRescale())
							{
								Mod.LogInfo("\t\t\t\tRescaling first");
								((FVRFireArmAttachment)val).ScaleToMount(val2);
							}
							((FVRFireArmAttachment)val).AttachToMount(val2, true);
							if (!((object)((Component)this).transform.localPosition/*cast due to .constrained prefix*/).Equals((object?)itemData.position))
							{
								((Component)this).transform.localPosition = itemData.position;
							}
							if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
							{
								Mod.LogInfo("\t\t\tChildren attachment waiting for us, updating them");
								for (int i = 0; i < value3.Count; i++)
								{
									if ((Object)(object)value3[i] != (Object)null)
									{
										Mod.LogInfo("\t\t\t\tUpdating " + ((Object)value3[i]).name + " at " + value3[i].data.trackedID);
										value3[i].data.UpdateFromData(value3[i].data);
									}
								}
								toAttachByMountObjectID.Remove(data.trackedID);
							}
						}
						else if (!flag2)
						{
							Mod.LogInfo("\t\t\tcan't mount " + ((Object)this).name + " on " + ((Object)val2).name + " yet, adding to toAttachByMountObjectID");
							if (toAttachByMountObjectID.TryGetValue(mountObjectID, out var value4))
							{
								value4.Add(this);
							}
							else
							{
								toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
							}
						}
						currentMountIndex = newData[0];
						data.ignoreParentChanged--;
					}
				}
			}
			float num = BitConverter.ToSingle(newData, 1);
			if (val.CatchRot != num)
			{
				val.CatchRot = num;
				((Component)val).transform.localEulerAngles = new Vector3(0f, 0f, num);
				flag = true;
			}
			itemData.data = newData;
			return flag || b != currentMountIndex;
		}

		private bool UpdateAttachment()
		{
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			FVRFireArmAttachment val = (FVRFireArmAttachment)(object)((obj is FVRFireArmAttachment) ? obj : null);
			if (itemData.data == null)
			{
				itemData.data = new byte[17 + attachmentInterfaceDataSize];
				flag = true;
			}
			byte b = currentMountIndex;
			if ((Object)(object)val.curMount == (Object)null)
			{
				itemData.data[0] = byte.MaxValue;
				currentMountIndex = byte.MaxValue;
				mountObjectID = -1;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < val.curMount.MyObject.AttachmentMounts.Count; i++)
				{
					if ((Object)(object)val.curMount.MyObject.AttachmentMounts[i] == (Object)(object)val.curMount)
					{
						itemData.data[0] = (byte)i;
						currentMountIndex = itemData.data[0];
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[0] = byte.MaxValue;
					currentMountIndex = byte.MaxValue;
					mountObjectID = -1;
				}
			}
			byte[] array = new byte[4]
			{
				itemData.data[1],
				itemData.data[2],
				itemData.data[3],
				itemData.data[4]
			};
			BitConverter.GetBytes(mountObjectID).CopyTo(itemData.data, 1);
			flag |= array[0] != itemData.data[1] || array[1] != itemData.data[2] || array[2] != itemData.data[3] || array[3] != itemData.data[4];
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				mountObjectScale = Vector3.one;
				array[0] = itemData.data[5];
				array[1] = itemData.data[6];
				array[2] = itemData.data[7];
				array[3] = itemData.data[8];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 5);
				flag |= array[1] != itemData.data[6] || array[2] != itemData.data[7] || array[3] != itemData.data[8];
				array[0] = itemData.data[9];
				array[1] = itemData.data[10];
				array[2] = itemData.data[11];
				array[3] = itemData.data[12];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 9);
				flag |= array[1] != itemData.data[10] || array[2] != itemData.data[11] || array[3] != itemData.data[12];
				array[0] = itemData.data[13];
				array[1] = itemData.data[14];
				array[2] = itemData.data[15];
				array[3] = itemData.data[16];
				BitConverter.GetBytes(1).CopyTo(itemData.data, 13);
				flag |= array[1] != itemData.data[14] || array[2] != itemData.data[15] || array[3] != itemData.data[16];
			}
			else
			{
				mountObjectScale = ((Component)this).transform.parent.localScale;
				array[0] = itemData.data[5];
				array[1] = itemData.data[6];
				array[2] = itemData.data[7];
				array[3] = itemData.data[8];
				BitConverter.GetBytes(((Component)this).transform.parent.localScale.x).CopyTo(itemData.data, 5);
				flag |= array[1] != itemData.data[6] || array[2] != itemData.data[7] || array[3] != itemData.data[8];
				array[0] = itemData.data[9];
				array[1] = itemData.data[10];
				array[2] = itemData.data[11];
				array[3] = itemData.data[12];
				BitConverter.GetBytes(((Component)this).transform.parent.localScale.y).CopyTo(itemData.data, 9);
				flag |= array[1] != itemData.data[10] || array[2] != itemData.data[11] || array[3] != itemData.data[12];
				array[0] = itemData.data[13];
				array[1] = itemData.data[14];
				array[2] = itemData.data[15];
				array[3] = itemData.data[16];
				BitConverter.GetBytes(((Component)this).transform.parent.localScale.z).CopyTo(itemData.data, 13);
				flag |= array[1] != itemData.data[14] || array[2] != itemData.data[15] || array[3] != itemData.data[16];
			}
			if (attachmentInterfaceUpdateFunc != null)
			{
				attachmentInterfaceUpdateFunc(val, ref flag);
			}
			return flag || b != currentMountIndex;
		}

		private bool UpdateGivenAttachment(byte[] newData)
		{
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			bool modified = false;
			Object obj = dataObject;
			FVRFireArmAttachment val = (FVRFireArmAttachment)(object)((obj is FVRFireArmAttachment) ? obj : null);
			if (itemData.data == null || itemData.data.Length != newData.Length)
			{
				itemData.data = new byte[17 + attachmentInterfaceDataSize];
				itemData.data[0] = byte.MaxValue;
				currentMountIndex = byte.MaxValue;
				modified = true;
			}
			byte b = currentMountIndex;
			if (newData[0] == byte.MaxValue)
			{
				if (mountObjectID != -1 && toAttachByMountObjectID.TryGetValue(mountObjectID, out var value))
				{
					value.Remove(this);
				}
				if ((Object)(object)val.curMount != (Object)null)
				{
					val.Sensor.m_storedScaleMagnified = 1f;
					((Component)val).transform.localScale = new Vector3(1f, 1f, 1f);
					data.ignoreParentChanged++;
					val.DetachFromMount();
					data.ignoreParentChanged--;
					currentMountIndex = byte.MaxValue;
					if (data.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)val).transform, value: true);
					}
				}
			}
			else
			{
				mountObjectID = BitConverter.ToInt32(newData, 1);
				mountObjectScale = new Vector3(BitConverter.ToSingle(newData, 5), BitConverter.ToSingle(newData, 9), BitConverter.ToSingle(newData, 13));
				if (mountObjectID == -1)
				{
					if ((Object)(object)val.curMount != (Object)null)
					{
						val.Sensor.m_storedScaleMagnified = 1f;
						((Component)val).transform.localScale = new Vector3(1f, 1f, 1f);
						val.DetachFromMount();
						if (data.controller != GameManager.ID)
						{
							Mod.SetKinematicRecursive(((Component)val).transform, value: true);
						}
					}
				}
				else
				{
					FVRFireArmAttachmentMount val2 = null;
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
					List<TrackedItem> value2;
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						if (trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > newData[0])
						{
							val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[newData[0]];
						}
					}
					else if (toAttachByMountObjectID.TryGetValue(mountObjectID, out value2))
					{
						value2.Add(this);
					}
					else
					{
						toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
					}
					if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)val.curMount)
					{
						if ((Object)(object)val.curMount != (Object)null)
						{
							val.Sensor.m_storedScaleMagnified = 1f;
							((Component)val).transform.localScale = new Vector3(1f, 1f, 1f);
							val.DetachFromMount();
						}
						List<TrackedItem> value4;
						if (CanAttachToMount(val, val2))
						{
							if (val2.GetRootMount().ParentToThis)
							{
								((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
							}
							else
							{
								((Component)val2.MyObject).transform.localScale = mountObjectScale;
							}
							if (val.CanScaleToMount && val2.CanThisRescale())
							{
								val.ScaleToMount(val2);
							}
							val.AttachToMount(val2, true);
							if (!((object)((Component)this).transform.localPosition/*cast due to .constrained prefix*/).Equals((object?)itemData.position))
							{
								((Component)this).transform.localPosition = itemData.position;
							}
							if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value3))
							{
								for (int i = 0; i < value3.Count; i++)
								{
									if ((Object)(object)value3[i] != (Object)null)
									{
										value3[i].data.UpdateFromData(value3[i].data);
									}
								}
								toAttachByMountObjectID.Remove(data.trackedID);
							}
						}
						else if (toAttachByMountObjectID.TryGetValue(mountObjectID, out value4))
						{
							value4.Add(this);
						}
						else
						{
							toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
						}
						currentMountIndex = newData[0];
					}
				}
			}
			if (attachmentInterfaceUpdateGivenFunc != null)
			{
				attachmentInterfaceUpdateGivenFunc(val, newData, ref modified);
			}
			itemData.data = newData;
			return modified || b != currentMountIndex;
		}

		private void UpdateAttachmentParent()
		{
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			Object obj = dataObject;
			FVRFireArmAttachment val = (FVRFireArmAttachment)(object)((obj is FVRFireArmAttachment) ? obj : null);
			if (itemData.data[0] == byte.MaxValue || mountObjectID == -1)
			{
				return;
			}
			FVRFireArmAttachmentMount val2 = null;
			TrackedItemData trackedItemData = null;
			trackedItemData = ((!ThreadManager.host) ? (Client.objects[mountObjectID] as TrackedItemData) : (Server.objects[mountObjectID] as TrackedItemData));
			Mod.LogInfo("Trying to mount item at " + data.trackedID + " " + ((Object)this).name + " to parent mount: " + itemData.data[0]);
			List<TrackedItem> value;
			if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.physicalItem.AttachmentMounts.Count > itemData.data[0])
			{
				val2 = trackedItemData.physicalItem.physicalItem.AttachmentMounts[itemData.data[0]];
				Mod.LogInfo("\tGot enough mounts, null?: " + ((Object)(object)val2 == (Object)null));
			}
			else if (toAttachByMountObjectID.TryGetValue(mountObjectID, out value))
			{
				value.Add(this);
			}
			else
			{
				toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
			}
			if ((Object)(object)val.curMount == (Object)null)
			{
				List<TrackedItem> value3;
				if ((Object)(object)val2 != (Object)null && CanAttachToMount(val, val2))
				{
					if (val2.GetRootMount().ParentToThis)
					{
						((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
					}
					else
					{
						((Component)val2.MyObject).transform.localScale = mountObjectScale;
					}
					if (val.CanScaleToMount && val2.CanThisRescale())
					{
						val.ScaleToMount(val2);
					}
					data.ignoreParentChanged++;
					val.AttachToMount(val2, true);
					data.ignoreParentChanged--;
					if (!toAttachByMountObjectID.TryGetValue(data.trackedID, out var value2))
					{
						return;
					}
					for (int i = 0; i < value2.Count; i++)
					{
						if ((Object)(object)value2[i] != (Object)null)
						{
							value2[i].data.UpdateFromData(value2[i].data);
						}
					}
					toAttachByMountObjectID.Remove(data.trackedID);
				}
				else if (toAttachByMountObjectID.TryGetValue(mountObjectID, out value3))
				{
					value3.Add(this);
				}
				else
				{
					toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
				}
			}
			else
			{
				if (!((Object)(object)val.curMount != (Object)(object)val2))
				{
					return;
				}
				data.ignoreParentChanged++;
				if ((Object)(object)val.curMount != (Object)null)
				{
					val.Sensor.m_storedScaleMagnified = 1f;
					((Component)val).transform.localScale = new Vector3(1f, 1f, 1f);
					val.DetachFromMount();
				}
				List<TrackedItem> value5;
				if ((Object)(object)val2 != (Object)null && CanAttachToMount(val, val2))
				{
					if (val2.GetRootMount().ParentToThis)
					{
						((Component)val2.GetRootMount()).transform.localScale = mountObjectScale;
					}
					else
					{
						((Component)val2.MyObject).transform.localScale = mountObjectScale;
					}
					if (val.CanScaleToMount && val2.CanThisRescale())
					{
						val.ScaleToMount(val2);
					}
					val.AttachToMount(val2, true);
					if (toAttachByMountObjectID.TryGetValue(data.trackedID, out var value4))
					{
						for (int j = 0; j < value4.Count; j++)
						{
							if ((Object)(object)value4[j] != (Object)null)
							{
								value4[j].data.UpdateFromData(value4[j].data);
							}
						}
						toAttachByMountObjectID.Remove(data.trackedID);
					}
				}
				else if (toAttachByMountObjectID.TryGetValue(mountObjectID, out value5))
				{
					value5.Add(this);
				}
				else
				{
					toAttachByMountObjectID.Add(mountObjectID, new List<TrackedItem> { this });
				}
				data.ignoreParentChanged--;
			}
		}

		private void AttachmentParentChanged()
		{
			if (data.controller == GameManager.ID)
			{
				FVRFireArmAttachment val = (FVRFireArmAttachment)((dataObject is AttachableFirearm) ? ((object)((AttachableFirearm)/*isinst with value type is only supported in some contexts*/).Attachment) : ((object)/*isinst with value type is only supported in some contexts*/));
				TrackedItem value;
				if ((Object)(object)val.curMount == (Object)null)
				{
					mountObjectID = -1;
				}
				else if (GameManager.trackedItemByItem.TryGetValue(val.curMount.MyObject, out value))
				{
					mountObjectID = value.data.trackedID;
				}
				else
				{
					mountObjectID = -1;
				}
			}
		}

		private void UpdateAttachableBipod(FVRFireArmAttachment att, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			AttachableBipodInterface val = (AttachableBipodInterface)(object)((attachmentInterface is AttachableBipodInterface) ? attachmentInterface : null);
			byte b = itemData.data[17];
			itemData.data[17] = (byte)(val.Bipod.m_isBipodExpanded ? 1 : 0);
			modified |= b != itemData.data[17];
		}

		private void UpdateGivenAttachableBipod(FVRFireArmAttachment att, byte[] newData, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			AttachableBipodInterface val = (AttachableBipodInterface)(object)((attachmentInterface is AttachableBipodInterface) ? attachmentInterface : null);
			if ((newData[17] == 1 && !val.Bipod.m_isBipodExpanded) || (newData[17] == 0 && val.Bipod.m_isBipodExpanded))
			{
				val.Bipod.Toggle();
				modified = true;
			}
		}

		private void UpdateFlagPoseSwitcher(FVRFireArmAttachment att, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			FlagPoseSwitcher val = (FlagPoseSwitcher)(object)((attachmentInterface is FlagPoseSwitcher) ? attachmentInterface : null);
			byte b = itemData.data[17];
			byte b2 = itemData.data[18];
			BitConverter.GetBytes((short)val.m_index).CopyTo(itemData.data, 17);
			modified |= b != itemData.data[17] || b2 != itemData.data[18];
		}

		private void UpdateGivenFlagPoseSwitcher(FVRFireArmAttachment att, byte[] newData, ref bool modified)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			FlagPoseSwitcher val = (FlagPoseSwitcher)(object)((attachmentInterface is FlagPoseSwitcher) ? attachmentInterface : null);
			int num = BitConverter.ToInt16(newData, 17);
			if (num != val.m_index)
			{
				val.m_index = num;
				val.Flag.localPosition = val.Poses[num].localPosition;
				val.Flag.localRotation = val.Poses[num].localRotation;
				modified = true;
			}
		}

		private void UpdateFlipSight(FVRFireArmAttachment att, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			FlipSight val = (FlipSight)(object)((attachmentInterface is FlipSight) ? attachmentInterface : null);
			byte b = itemData.data[17];
			itemData.data[17] = (byte)(val.IsUp ? 1 : 0);
			modified |= b != itemData.data[17];
		}

		private void UpdateGivenFlipSight(FVRFireArmAttachment att, byte[] newData, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			FlipSight val = (FlipSight)(object)((attachmentInterface is FlipSight) ? attachmentInterface : null);
			if ((newData[17] == 1 && !val.IsUp) || (newData[17] == 0 && val.IsUp))
			{
				val.Flip();
				modified = true;
			}
		}

		private void UpdateFlipSightY(FVRFireArmAttachment att, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			FlipSightY val = (FlipSightY)(object)((attachmentInterface is FlipSightY) ? attachmentInterface : null);
			byte b = itemData.data[17];
			itemData.data[17] = (byte)(val.IsUp ? 1 : 0);
			modified |= b != itemData.data[17];
		}

		private void UpdateGivenFlipSightY(FVRFireArmAttachment att, byte[] newData, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			FlipSightY val = (FlipSightY)(object)((attachmentInterface is FlipSightY) ? attachmentInterface : null);
			if ((newData[17] == 1 && !val.IsUp) || (newData[17] == 0 && val.IsUp))
			{
				val.Flip();
				modified = true;
			}
		}

		private void UpdateLAM(FVRFireArmAttachment att, ref bool modified)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			LAM val = (LAM)(object)((attachmentInterface is LAM) ? attachmentInterface : null);
			byte b = itemData.data[17];
			itemData.data[17] = (byte)val.LState;
			modified |= b != itemData.data[17];
		}

		private void UpdateGivenLAM(FVRFireArmAttachment att, byte[] newData, ref bool modified)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between I4 and Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Invalid comparison between Unknown and I4
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Invalid comparison between Unknown and I4
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			LAM val = (LAM)(object)((attachmentInterface is LAM) ? attachmentInterface : null);
			if (newData[17] == (int)val.LState)
			{
				return;
			}
			val.LState = (LAMState)newData[17];
			if ((int)val.LState == 0)
			{
				SM.PlayCoreSound((FVRPooledAudioType)10, val.AudEvent_LAMOFF, ((Component)this).transform.position);
			}
			else
			{
				SM.PlayCoreSound((FVRPooledAudioType)10, val.AudEvent_LAMON, ((Component)this).transform.position);
			}
			if ((int)val.LState == 1 || (int)val.LState == 3)
			{
				val.BeamHitPoint.SetActive(true);
				val.BeamEffect.SetActive(true);
			}
			else
			{
				val.BeamHitPoint.SetActive(false);
				val.BeamEffect.SetActive(false);
			}
			if ((int)val.LState == 2 || (int)val.LState == 3)
			{
				val.LightParts.SetActive(true);
				if (GM.CurrentSceneSettings.IsSceneLowLight)
				{
					val.FlashlightLight.Light.intensity = 2f;
				}
				else
				{
					val.FlashlightLight.Light.intensity = 0.5f;
				}
			}
			else
			{
				val.LightParts.SetActive(false);
			}
			modified = true;
		}

		private void UpdateLaserPointer(FVRFireArmAttachment att, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			LaserPointer val = (LaserPointer)(object)((attachmentInterface is LaserPointer) ? attachmentInterface : null);
			byte b = itemData.data[17];
			itemData.data[17] = (byte)(val.BeamHitPoint.activeSelf ? 1 : 0);
			modified |= b != itemData.data[17];
		}

		private void UpdateGivenLaserPointer(FVRFireArmAttachment att, byte[] newData, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			LaserPointer val = (LaserPointer)(object)((attachmentInterface is LaserPointer) ? attachmentInterface : null);
			if ((newData[17] == 1 && !val.BeamHitPoint.activeSelf) || (newData[17] == 0 && val.BeamHitPoint.activeSelf))
			{
				val.ToggleOn();
				modified = true;
			}
		}

		private void UpdateTacticalFlashlight(FVRFireArmAttachment att, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			TacticalFlashlight val = (TacticalFlashlight)(object)((attachmentInterface is TacticalFlashlight) ? attachmentInterface : null);
			byte b = itemData.data[17];
			itemData.data[17] = (byte)(val.LightParts.activeSelf ? 1 : 0);
			modified |= b != itemData.data[17];
		}

		private void UpdateGivenTacticalFlashlight(FVRFireArmAttachment att, byte[] newData, ref bool modified)
		{
			FVRFireArmAttachmentInterface attachmentInterface = att.AttachmentInterface;
			TacticalFlashlight val = (TacticalFlashlight)(object)((attachmentInterface is TacticalFlashlight) ? attachmentInterface : null);
			if ((newData[17] == 1 && !val.LightParts.activeSelf) || (newData[17] == 0 && val.LightParts.activeSelf))
			{
				val.ToggleOn();
				modified = true;
			}
		}

		private bool UpdateMagazine()
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			FVRFireArmMagazine val = (FVRFireArmMagazine)(object)((obj is FVRFireArmMagazine) ? obj : null);
			int num = val.m_capacity * 2 + 10;
			if (itemData.data == null || itemData.data.Length < num)
			{
				itemData.data = new byte[num];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			BitConverter.GetBytes((short)val.m_numRounds).CopyTo(itemData.data, 0);
			flag |= b != itemData.data[0] || b2 != itemData.data[1];
			for (int i = 0; i < val.m_numRounds; i++)
			{
				b = itemData.data[i * 2 + 2];
				b2 = itemData.data[i * 2 + 3];
				BitConverter.GetBytes((short)val.LoadedRounds[i].LR_Class).CopyTo(itemData.data, i * 2 + 2);
				flag |= b != itemData.data[i * 2 + 2] || b2 != itemData.data[i * 2 + 3];
			}
			b = itemData.data[num - 8];
			itemData.data[num - 8] = (byte)(((Object)(object)val.FireArm != (Object)null) ? 1 : 0);
			flag |= b != itemData.data[num - 8];
			b = itemData.data[num - 7];
			if ((Object)(object)val.FireArm == (Object)null)
			{
				itemData.data[num - 7] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int j = 0; j < val.FireArm.SecondaryMagazineSlots.Length; j++)
				{
					if ((Object)(object)val.FireArm.SecondaryMagazineSlots[j].Magazine == (Object)(object)val)
					{
						flag2 = true;
						itemData.data[num - 7] = (byte)j;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[num - 7] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[num - 7];
			b = itemData.data[num - 6];
			itemData.data[num - 6] = (byte)(((Object)(object)val.AttachableFireArm != (Object)null) ? 1 : 0);
			flag |= b != itemData.data[num - 6];
			b = itemData.data[num - 5];
			if ((Object)(object)val.AttachableFireArm == (Object)null)
			{
				itemData.data[num - 5] = byte.MaxValue;
			}
			else
			{
				bool flag3 = false;
				for (int k = 0; k < val.AttachableFireArm.SecondaryMagazineSlots.Length; k++)
				{
					if ((Object)(object)val.AttachableFireArm.SecondaryMagazineSlots[k].Magazine == (Object)(object)val)
					{
						itemData.data[num - 5] = (byte)k;
						break;
					}
				}
				if (!flag3)
				{
					itemData.data[num - 5] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[num - 5];
			b = itemData.data[num - 4];
			b2 = itemData.data[num - 3];
			byte b3 = itemData.data[num - 2];
			byte b4 = itemData.data[num - 1];
			BitConverter.GetBytes(val.FuelAmountLeft).CopyTo(itemData.data, num - 4);
			return flag | (b != itemData.data[num - 4] || b2 != itemData.data[num - 3] || b3 != itemData.data[num - 2] || b4 != itemData.data[num - 1]);
		}

		private bool UpdateGivenMagazine(byte[] newData)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			FVRFireArmMagazine val = (FVRFireArmMagazine)(object)((obj is FVRFireArmMagazine) ? obj : null);
			if (itemData.data == null || itemData.data.Length != newData.Length)
			{
				flag = true;
			}
			int numRounds = val.m_numRounds;
			val.m_numRounds = 0;
			short num = BitConverter.ToInt16(newData, 0);
			for (int i = 0; i < num; i++)
			{
				int startIndex = i * 2 + 2;
				FireArmRoundClass val2 = (FireArmRoundClass)BitConverter.ToInt16(newData, startIndex);
				if (val.LoadedRounds.Length > i && val.LoadedRounds[i] != null && val2 == val.LoadedRounds[i].LR_Class)
				{
					val.m_numRounds++;
					continue;
				}
				MagazinePatch.addRoundSkip++;
				val.AddRound(val2, false, false);
				MagazinePatch.addRoundSkip--;
				flag = true;
			}
			flag |= numRounds != val.m_numRounds;
			if (flag)
			{
				val.UpdateBulletDisplay();
			}
			if (newData[^8] == 1)
			{
				if (data.parent != -1)
				{
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[data.parent] as TrackedItemData) : (Server.objects[data.parent] as TrackedItemData));
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.dataObject is FVRFireArm)
					{
						if ((Object)(object)val.FireArm != (Object)null)
						{
							if ((Object)(object)val.FireArm != trackedItemData.physicalItem.dataObject)
							{
								if ((Object)(object)val.FireArm.Magazine == (Object)(object)val)
								{
									val.FireArm.EjectMag(true);
								}
								else
								{
									for (int j = 0; j < val.FireArm.SecondaryMagazineSlots.Length; j++)
									{
										if ((Object)(object)val.FireArm.SecondaryMagazineSlots[j].Magazine == (Object)(object)val)
										{
											val.FireArm.EjectSecondaryMagFromSlot(j, true);
											break;
										}
									}
								}
								if (newData[^7] == byte.MaxValue)
								{
									MagazinePatch.loadSkip++;
									? val3 = val;
									Object obj2 = trackedItemData.physicalItem.dataObject;
									((FVRFireArmMagazine)val3).Load((FVRFireArm)(object)((obj2 is FVRFireArm) ? obj2 : null));
									MagazinePatch.loadSkip--;
								}
								else
								{
									MagazinePatch.loadSkip++;
									? val4 = val;
									Object obj3 = trackedItemData.physicalItem.dataObject;
									((FVRFireArmMagazine)val4).LoadIntoSecondary((FVRFireArm)(object)((obj3 is FVRFireArm) ? obj3 : null), (int)newData[^7]);
									MagazinePatch.loadSkip--;
								}
								flag = true;
							}
						}
						else if ((Object)(object)val.AttachableFireArm != (Object)null)
						{
							if ((Object)(object)val.AttachableFireArm.Magazine == (Object)(object)val)
							{
								val.AttachableFireArm.EjectMag(true);
							}
							else
							{
								for (int k = 0; k < val.AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)val.AttachableFireArm.SecondaryMagazineSlots[k].Magazine == (Object)(object)val); k++)
								{
								}
							}
							if (newData[^7] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val5 = val;
								Object obj4 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val5).Load((FVRFireArm)(object)((obj4 is FVRFireArm) ? obj4 : null));
								MagazinePatch.loadSkip--;
							}
							else
							{
								MagazinePatch.loadSkip++;
								? val6 = val;
								Object obj5 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val6).LoadIntoSecondary((FVRFireArm)(object)((obj5 is FVRFireArm) ? obj5 : null), (int)newData[^7]);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
						else
						{
							if (newData[^7] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val7 = val;
								Object obj6 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val7).Load((FVRFireArm)(object)((obj6 is FVRFireArm) ? obj6 : null));
								MagazinePatch.loadSkip--;
							}
							else
							{
								MagazinePatch.loadSkip++;
								? val8 = val;
								Object obj7 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val8).LoadIntoSecondary((FVRFireArm)(object)((obj7 is FVRFireArm) ? obj7 : null), (int)newData[^7]);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
					}
				}
			}
			else if (newData[^6] == 1)
			{
				if (data.parent != -1)
				{
					TrackedItemData trackedItemData2 = null;
					trackedItemData2 = ((!ThreadManager.host) ? (Client.objects[data.parent] as TrackedItemData) : (Server.objects[data.parent] as TrackedItemData));
					if (trackedItemData2 != null && (Object)(object)trackedItemData2.physicalItem != (Object)null && trackedItemData2.physicalItem.dataObject is AttachableFirearmPhysicalObject)
					{
						if ((Object)(object)val.AttachableFireArm != (Object)null)
						{
							AttachableFirearm attachableFireArm = val.AttachableFireArm;
							Object obj8 = trackedItemData2.physicalItem.dataObject;
							if ((Object)(object)attachableFireArm != (Object)(object)((AttachableFirearmPhysicalObject)((obj8 is AttachableFirearmPhysicalObject) ? obj8 : null)).FA)
							{
								if ((Object)(object)val.AttachableFireArm.Magazine == (Object)(object)val)
								{
									val.AttachableFireArm.EjectMag(true);
								}
								else
								{
									for (int l = 0; l < val.AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)val.AttachableFireArm.SecondaryMagazineSlots[l].Magazine == (Object)(object)val); l++)
									{
									}
								}
								if (newData[^5] == byte.MaxValue)
								{
									MagazinePatch.loadSkip++;
									? val9 = val;
									Object obj9 = trackedItemData2.physicalItem.dataObject;
									((FVRFireArmMagazine)val9).Load(((AttachableFirearmPhysicalObject)((obj9 is AttachableFirearmPhysicalObject) ? obj9 : null)).FA);
									MagazinePatch.loadSkip--;
								}
								flag = true;
							}
						}
						else if ((Object)(object)val.FireArm != (Object)null)
						{
							if ((Object)(object)val.FireArm.Magazine == (Object)(object)val)
							{
								val.FireArm.EjectMag(true);
							}
							else
							{
								for (int m = 0; m < val.FireArm.SecondaryMagazineSlots.Length; m++)
								{
									if ((Object)(object)val.FireArm.SecondaryMagazineSlots[m].Magazine == (Object)(object)val)
									{
										val.FireArm.EjectSecondaryMagFromSlot(m, true);
										break;
									}
								}
							}
							if (newData[^5] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val10 = val;
								Object obj10 = trackedItemData2.physicalItem.dataObject;
								((FVRFireArmMagazine)val10).Load(((AttachableFirearmPhysicalObject)((obj10 is AttachableFirearmPhysicalObject) ? obj10 : null)).FA);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
						else
						{
							if (newData[^5] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val11 = val;
								Object obj11 = trackedItemData2.physicalItem.dataObject;
								((FVRFireArmMagazine)val11).Load(((AttachableFirearmPhysicalObject)((obj11 is AttachableFirearmPhysicalObject) ? obj11 : null)).FA);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
					}
				}
			}
			else if ((Object)(object)val.FireArm != (Object)null)
			{
				if ((Object)(object)val.FireArm.Magazine == (Object)(object)val)
				{
					val.FireArm.EjectMag(true);
				}
				else
				{
					for (int n = 0; n < val.FireArm.SecondaryMagazineSlots.Length; n++)
					{
						if ((Object)(object)val.FireArm.SecondaryMagazineSlots[n].Magazine == (Object)(object)val)
						{
							val.FireArm.EjectSecondaryMagFromSlot(n, true);
							break;
						}
					}
				}
				flag = true;
			}
			else if ((Object)(object)val.AttachableFireArm != (Object)null)
			{
				if ((Object)(object)val.AttachableFireArm.Magazine == (Object)(object)val)
				{
					val.AttachableFireArm.EjectMag(true);
				}
				else
				{
					for (int num2 = 0; num2 < val.AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)val.AttachableFireArm.SecondaryMagazineSlots[num2].Magazine == (Object)(object)val); num2++)
					{
					}
				}
				flag = true;
			}
			float fuelAmountLeft = val.FuelAmountLeft;
			val.FuelAmountLeft = BitConverter.ToSingle(newData, newData.Length - 4);
			flag |= fuelAmountLeft != val.FuelAmountLeft;
			itemData.data = newData;
			return flag;
		}

		private bool UpdateMinigunBox()
		{
			bool flag = false;
			Object obj = dataObject;
			MinigunBox val = (MinigunBox)(object)((obj is MinigunBox) ? obj : null);
			if (itemData.data == null)
			{
				itemData.data = new byte[8];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			BitConverter.GetBytes((short)val.NumBulletsLeft).CopyTo(itemData.data, 0);
			flag |= b != itemData.data[0] || b2 != itemData.data[1];
			b = itemData.data[2];
			itemData.data[2] = (byte)(((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null) ? 1 : 0);
			flag |= b != itemData.data[2];
			b = itemData.data[3];
			if ((Object)(object)((FVRFireArmMagazine)val).FireArm == (Object)null)
			{
				itemData.data[3] = byte.MaxValue;
			}
			else
			{
				bool flag2 = false;
				for (int i = 0; i < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; i++)
				{
					if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[i].Magazine == (Object)(object)val)
					{
						flag2 = true;
						itemData.data[3] = (byte)i;
						break;
					}
				}
				if (!flag2)
				{
					itemData.data[3] = byte.MaxValue;
				}
			}
			flag |= b != itemData.data[3];
			b = itemData.data[4];
			itemData.data[4] = (byte)(((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null) ? 1 : 0);
			flag |= b != itemData.data[4];
			b = itemData.data[5];
			if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm == (Object)null)
			{
				itemData.data[5] = byte.MaxValue;
			}
			else
			{
				bool flag3 = false;
				for (int j = 0; j < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length; j++)
				{
					if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[j].Magazine == (Object)(object)val)
					{
						itemData.data[5] = (byte)j;
						break;
					}
				}
				if (!flag3)
				{
					itemData.data[5] = byte.MaxValue;
				}
			}
			return flag | (b != itemData.data[5]);
		}

		private bool UpdateGivenMinigunBox(byte[] newData)
		{
			bool flag = false;
			Object obj = dataObject;
			MinigunBox val = (MinigunBox)(object)((obj is MinigunBox) ? obj : null);
			if (itemData.data == null || itemData.data.Length != newData.Length)
			{
				flag = true;
			}
			int numBulletsLeft = val.NumBulletsLeft;
			val.NumBulletsLeft = BitConverter.ToInt16(newData, 0);
			flag |= numBulletsLeft != val.NumBulletsLeft;
			if (newData[2] == 1)
			{
				if (data.parent != -1)
				{
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[data.parent] as TrackedItemData) : (Server.objects[data.parent] as TrackedItemData));
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.dataObject is FVRFireArm)
					{
						if ((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null)
						{
							if ((Object)(object)((FVRFireArmMagazine)val).FireArm != trackedItemData.physicalItem.dataObject)
							{
								if ((Object)(object)((FVRFireArmMagazine)val).FireArm.Magazine == (Object)(object)val)
								{
									((FVRFireArmMagazine)val).FireArm.EjectMag(true);
								}
								else
								{
									for (int i = 0; i < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; i++)
									{
										if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[i].Magazine == (Object)(object)val)
										{
											((FVRFireArmMagazine)val).FireArm.EjectSecondaryMagFromSlot(i, true);
											break;
										}
									}
								}
								if (newData[3] == byte.MaxValue)
								{
									MagazinePatch.loadSkip++;
									? val2 = val;
									Object obj2 = trackedItemData.physicalItem.dataObject;
									((FVRFireArmMagazine)val2).Load((FVRFireArm)(object)((obj2 is FVRFireArm) ? obj2 : null));
									MagazinePatch.loadSkip--;
								}
								else
								{
									MagazinePatch.loadSkip++;
									? val3 = val;
									Object obj3 = trackedItemData.physicalItem.dataObject;
									((FVRFireArmMagazine)val3).LoadIntoSecondary((FVRFireArm)(object)((obj3 is FVRFireArm) ? obj3 : null), (int)newData[3]);
									MagazinePatch.loadSkip--;
								}
								flag = true;
							}
						}
						else if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null)
						{
							if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.Magazine == (Object)(object)val)
							{
								((FVRFireArmMagazine)val).AttachableFireArm.EjectMag(true);
							}
							else
							{
								for (int j = 0; j < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[j].Magazine == (Object)(object)val); j++)
								{
								}
							}
							if (newData[3] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val4 = val;
								Object obj4 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val4).Load((FVRFireArm)(object)((obj4 is FVRFireArm) ? obj4 : null));
								MagazinePatch.loadSkip--;
							}
							else
							{
								MagazinePatch.loadSkip++;
								? val5 = val;
								Object obj5 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val5).LoadIntoSecondary((FVRFireArm)(object)((obj5 is FVRFireArm) ? obj5 : null), (int)newData[3]);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
						else
						{
							if (newData[3] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val6 = val;
								Object obj6 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val6).Load((FVRFireArm)(object)((obj6 is FVRFireArm) ? obj6 : null));
								MagazinePatch.loadSkip--;
							}
							else
							{
								MagazinePatch.loadSkip++;
								? val7 = val;
								Object obj7 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmMagazine)val7).LoadIntoSecondary((FVRFireArm)(object)((obj7 is FVRFireArm) ? obj7 : null), (int)newData[3]);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
					}
				}
			}
			else if (newData[4] == 1)
			{
				if (data.parent != -1)
				{
					TrackedItemData trackedItemData2 = null;
					trackedItemData2 = ((!ThreadManager.host) ? (Client.objects[data.parent] as TrackedItemData) : (Server.objects[data.parent] as TrackedItemData));
					if (trackedItemData2 != null && (Object)(object)trackedItemData2.physicalItem != (Object)null && trackedItemData2.physicalItem.dataObject is AttachableFirearmPhysicalObject)
					{
						if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null)
						{
							AttachableFirearm attachableFireArm = ((FVRFireArmMagazine)val).AttachableFireArm;
							Object obj8 = trackedItemData2.physicalItem.dataObject;
							if ((Object)(object)attachableFireArm != (Object)(object)((AttachableFirearmPhysicalObject)((obj8 is AttachableFirearmPhysicalObject) ? obj8 : null)).FA)
							{
								if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.Magazine == (Object)(object)val)
								{
									((FVRFireArmMagazine)val).AttachableFireArm.EjectMag(true);
								}
								else
								{
									for (int k = 0; k < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[k].Magazine == (Object)(object)val); k++)
									{
									}
								}
								if (newData[5] == byte.MaxValue)
								{
									MagazinePatch.loadSkip++;
									? val8 = val;
									Object obj9 = trackedItemData2.physicalItem.dataObject;
									((FVRFireArmMagazine)val8).Load(((AttachableFirearmPhysicalObject)((obj9 is AttachableFirearmPhysicalObject) ? obj9 : null)).FA);
									MagazinePatch.loadSkip--;
								}
								flag = true;
							}
						}
						else if ((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null)
						{
							if ((Object)(object)((FVRFireArmMagazine)val).FireArm.Magazine == (Object)(object)val)
							{
								((FVRFireArmMagazine)val).FireArm.EjectMag(true);
							}
							else
							{
								for (int l = 0; l < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; l++)
								{
									if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[l].Magazine == (Object)(object)val)
									{
										((FVRFireArmMagazine)val).FireArm.EjectSecondaryMagFromSlot(l, true);
										break;
									}
								}
							}
							if (newData[5] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val9 = val;
								Object obj10 = trackedItemData2.physicalItem.dataObject;
								((FVRFireArmMagazine)val9).Load(((AttachableFirearmPhysicalObject)((obj10 is AttachableFirearmPhysicalObject) ? obj10 : null)).FA);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
						else
						{
							if (newData[5] == byte.MaxValue)
							{
								MagazinePatch.loadSkip++;
								? val10 = val;
								Object obj11 = trackedItemData2.physicalItem.dataObject;
								((FVRFireArmMagazine)val10).Load(((AttachableFirearmPhysicalObject)((obj11 is AttachableFirearmPhysicalObject) ? obj11 : null)).FA);
								MagazinePatch.loadSkip--;
							}
							flag = true;
						}
					}
				}
			}
			else if ((Object)(object)((FVRFireArmMagazine)val).FireArm != (Object)null)
			{
				if ((Object)(object)((FVRFireArmMagazine)val).FireArm.Magazine == (Object)(object)val)
				{
					((FVRFireArmMagazine)val).FireArm.EjectMag(true);
				}
				else
				{
					for (int m = 0; m < ((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots.Length; m++)
					{
						if ((Object)(object)((FVRFireArmMagazine)val).FireArm.SecondaryMagazineSlots[m].Magazine == (Object)(object)val)
						{
							((FVRFireArmMagazine)val).FireArm.EjectSecondaryMagFromSlot(m, true);
							break;
						}
					}
				}
				flag = true;
			}
			else if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm != (Object)null)
			{
				if ((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.Magazine == (Object)(object)val)
				{
					((FVRFireArmMagazine)val).AttachableFireArm.EjectMag(true);
				}
				else
				{
					for (int n = 0; n < ((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots.Length && !((Object)(object)((FVRFireArmMagazine)val).AttachableFireArm.SecondaryMagazineSlots[n].Magazine == (Object)(object)val); n++)
					{
					}
				}
				flag = true;
			}
			itemData.data = newData;
			return flag;
		}

		private bool UpdateClip()
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			FVRFireArmClip val = (FVRFireArmClip)(object)((obj is FVRFireArmClip) ? obj : null);
			int num = val.m_capacity * 2 + 3;
			if (itemData.data == null || itemData.data.Length < num)
			{
				itemData.data = new byte[num];
				flag = true;
			}
			byte b = itemData.data[0];
			byte b2 = itemData.data[1];
			BitConverter.GetBytes((short)val.m_numRounds).CopyTo(itemData.data, 0);
			flag |= b != itemData.data[0] || b2 != itemData.data[1];
			for (int i = 0; i < val.m_numRounds; i++)
			{
				b = itemData.data[i * 2 + 2];
				b2 = itemData.data[i * 2 + 3];
				BitConverter.GetBytes((short)val.LoadedRounds[i].LR_Class).CopyTo(itemData.data, i * 2 + 2);
				flag |= b != itemData.data[i * 2 + 2] || b2 != itemData.data[i * 2 + 3];
			}
			b = itemData.data[num - 1];
			itemData.data[num - 1] = (byte)(((Object)(object)val.FireArm != (Object)null) ? 1 : 0);
			return flag | (b != itemData.data[num - 1]);
		}

		private bool UpdateGivenClip(byte[] newData)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			FVRFireArmClip val = (FVRFireArmClip)(object)((obj is FVRFireArmClip) ? obj : null);
			if (itemData.data == null || itemData.data.Length != newData.Length)
			{
				flag = true;
			}
			int numRounds = val.m_numRounds;
			val.m_numRounds = 0;
			short num = BitConverter.ToInt16(newData, 0);
			for (int i = 0; i < num; i++)
			{
				int startIndex = i * 2 + 2;
				FireArmRoundClass val2 = (FireArmRoundClass)BitConverter.ToInt16(newData, startIndex);
				if (val.LoadedRounds.Length > i && val.LoadedRounds[i] != null && val2 == val.LoadedRounds[i].LR_Class)
				{
					val.m_numRounds++;
					continue;
				}
				ClipPatch.addRoundSkip++;
				val.AddRound(val2, false, false);
				ClipPatch.addRoundSkip--;
				flag = true;
			}
			flag |= numRounds != val.m_numRounds;
			if (flag)
			{
				val.UpdateBulletDisplay();
			}
			if (BitConverter.ToBoolean(newData, newData.Length - 1))
			{
				if (data.parent != -1)
				{
					TrackedItemData trackedItemData = null;
					trackedItemData = ((!ThreadManager.host) ? (Client.objects[data.parent] as TrackedItemData) : (Server.objects[data.parent] as TrackedItemData));
					if (trackedItemData != null && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.dataObject is FVRFireArm)
					{
						if ((Object)(object)val.FireArm != (Object)null)
						{
							if ((Object)(object)val.FireArm != trackedItemData.physicalItem.dataObject)
							{
								val.FireArm.EjectClip();
								ClipPatch.loadSkip++;
								? val3 = val;
								Object obj2 = trackedItemData.physicalItem.dataObject;
								((FVRFireArmClip)val3).Load((FVRFireArm)(object)((obj2 is FVRFireArm) ? obj2 : null));
								ClipPatch.loadSkip--;
								flag = true;
							}
						}
						else
						{
							ClipPatch.loadSkip++;
							? val4 = val;
							Object obj3 = trackedItemData.physicalItem.dataObject;
							((FVRFireArmClip)val4).Load((FVRFireArm)(object)((obj3 is FVRFireArm) ? obj3 : null));
							ClipPatch.loadSkip--;
							flag = true;
						}
					}
				}
			}
			else if ((Object)(object)val.FireArm != (Object)null)
			{
				val.FireArm.EjectClip();
				flag = true;
			}
			itemData.data = newData;
			return flag;
		}

		private bool UpdateSpeedloader()
		{
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			Object obj = dataObject;
			Speedloader val = (Speedloader)(object)((obj is Speedloader) ? obj : null);
			int num = val.Chambers.Count * 2;
			if (itemData.data == null || itemData.data.Length < num)
			{
				itemData.data = new byte[num];
				flag = true;
			}
			for (int i = 0; i < val.Chambers.Count; i++)
			{
				byte b = itemData.data[i * 2];
				byte b2 = itemData.data[i * 2 + 1];
				if (val.Chambers[i].IsLoaded && !val.Chambers[i].IsSpent)
				{
					BitConverter.GetBytes((short)val.Chambers[i].LoadedClass).CopyTo(itemData.data, i * 2);
				}
				else
				{
					BitConverter.GetBytes((short)(-1)).CopyTo(itemData.data, i * 2);
				}
				flag |= b != itemData.data[i * 2] || b2 != itemData.data[i * 2 + 1];
			}
			return flag;
		}

		private bool UpdateGivenSpeedloader(byte[] newData)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Object obj = dataObject;
			Speedloader val = (Speedloader)(object)((obj is Speedloader) ? obj : null);
			if (itemData.data == null || itemData.data.Length != newData.Length)
			{
				result = true;
			}
			for (int i = 0; i < val.Chambers.Count; i++)
			{
				int startIndex = i * 2;
				short num = BitConverter.ToInt16(newData, startIndex);
				if (num != -1 && (!val.Chambers[i].IsLoaded || (short)val.Chambers[i].LoadedClass != num))
				{
					FireArmRoundClass val2 = (FireArmRoundClass)num;
					SpeedloaderChamberPatch.loadSkip++;
					val.Chambers[i].Load(val2, false);
					SpeedloaderChamberPatch.loadSkip--;
				}
				else if (num == -1 && val.Chambers[i].IsLoaded)
				{
					val.Chambers[i].Unload();
				}
			}
			itemData.data = newData;
			return result;
		}

		public static bool CanAttachToMount(FVRFireArmAttachment attachment, FVRFireArmAttachmentMount mount)
		{
			if ((Object)(object)mount.Parent == (Object)null)
			{
				return false;
			}
			if (mount.MyObject is FVRFireArmAttachment && (Object)(object)((FVRFireArmAttachment)/*isinst with value type is only supported in some contexts*/).curMount == (Object)null)
			{
				return false;
			}
			if (mount.AttachmentsList.Count >= mount.m_maxAttachments)
			{
				return false;
			}
			if ((Object)(object)attachment.AttachmentInterface != (Object)null && attachment.AttachmentInterface is AttachableBipodInterface && (Object)(object)mount.GetRootMount().MyObject.Bipod != (Object)null)
			{
				return false;
			}
			if (attachment is Suppressor)
			{
				if (mount.GetRootMount().MyObject is SingleActionRevolver && !((SingleActionRevolver)/*isinst with value type is only supported in some contexts*/).AllowsSuppressor)
				{
					return false;
				}
				if (mount.GetRootMount().MyObject is Revolver && !((Revolver)/*isinst with value type is only supported in some contexts*/).AllowsSuppressor)
				{
					return false;
				}
			}
			if (attachment is AttachableMeleeWeapon && mount.GetRootMount().MyObject is FVRFireArm)
			{
				FVRPhysicalObject myObject = mount.GetRootMount().MyObject;
				FVRFireArm val = (FVRFireArm)(object)((myObject is FVRFireArm) ? myObject : null);
				if ((Object)(object)val.CurrentAttachableMeleeWeapon != (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		public virtual void FixedUpdate()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			if (!interpolated || !((Object)(object)physicalItem != (Object)null) || data.controller == GameManager.ID)
			{
				return;
			}
			_ = itemData.position;
			_ = itemData.rotation;
			if (1 == 0)
			{
				return;
			}
			if (Vector3.Distance((data.parent == -1) ? ((Component)physicalItem).transform.position : ((Component)physicalItem).transform.localPosition, itemData.position) > 0.001f)
			{
				positionSet = false;
				_ = itemData.previousPos;
				if (((Vector3)(ref itemData.velocity)).magnitude < 1f)
				{
					if (data.parent == -1)
					{
						((Component)physicalItem).transform.position = Vector3.Lerp(((Component)physicalItem).transform.position, itemData.position + itemData.velocity, interpolationSpeed * Time.deltaTime);
					}
					else
					{
						((Component)physicalItem).transform.localPosition = Vector3.Lerp(((Component)physicalItem).transform.localPosition, itemData.position + itemData.velocity, interpolationSpeed * Time.deltaTime);
					}
				}
				else if (data.parent == -1)
				{
					((Component)physicalItem).transform.position = itemData.position;
				}
				else
				{
					((Component)physicalItem).transform.localPosition = itemData.position;
				}
			}
			else if (!positionSet)
			{
				if (data.parent == -1)
				{
					((Component)physicalItem).transform.position = itemData.position;
				}
				else
				{
					((Component)physicalItem).transform.localPosition = itemData.position;
				}
				positionSet = true;
			}
			if (Quaternion.Angle((data.parent == -1) ? ((Component)physicalItem).transform.rotation : ((Component)physicalItem).transform.localRotation, itemData.rotation) > 0.1f)
			{
				rotationSet = false;
				if (data.parent == -1)
				{
					((Component)physicalItem).transform.rotation = Quaternion.Lerp(((Component)physicalItem).transform.rotation, itemData.rotation, interpolationSpeed * Time.deltaTime);
				}
				else
				{
					((Component)physicalItem).transform.localRotation = Quaternion.Lerp(((Component)physicalItem).transform.localRotation, itemData.rotation, interpolationSpeed * Time.deltaTime);
				}
			}
			else if (!rotationSet)
			{
				if (data.parent == -1)
				{
					((Component)physicalItem).transform.rotation = itemData.rotation;
				}
				else
				{
					((Component)physicalItem).transform.localRotation = itemData.rotation;
				}
				rotationSet = true;
			}
		}

		protected override void OnDestroy()
		{
			GameManager.OnSceneLeft -= OnSceneLeft;
			GameManager.OnSceneJoined -= OnSceneJoined;
			GameManager.OnInstanceJoined -= OnInstanceJoined;
			GameManager.OnPlayerBodyInit -= OnPlayerBodyInit;
			if (!skipFullDestroy)
			{
				GameManager.trackedItemByItem.Remove(physicalItem);
				if (physicalItem is SosigWeaponPlayerInterface)
				{
					Dictionary<SosigWeapon, TrackedItem> trackedItemBySosigWeapon = GameManager.trackedItemBySosigWeapon;
					FVRPhysicalObject obj = physicalItem;
					trackedItemBySosigWeapon.Remove(((SosigWeaponPlayerInterface)((obj is SosigWeaponPlayerInterface) ? obj : null)).W);
				}
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)physicalItem);
				if (removeTrackedDamageables != null)
				{
					removeTrackedDamageables();
				}
				if (onDestruction != null)
				{
					onDestruction();
				}
				EnsureUncontrolled();
				base.OnDestroy();
			}
		}

		public override void EnsureUncontrolled()
		{
			if ((Object)(object)((FVRInteractiveObject)physicalItem).m_hand != (Object)null)
			{
				((FVRInteractiveObject)physicalItem).ForceBreakInteraction();
			}
			if ((Object)(object)physicalItem.QuickbeltSlot != (Object)null)
			{
				physicalItem.ClearQuickbeltState();
			}
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			if (data.controller != GameManager.ID)
			{
				data.TakeControlRecursive();
				Mod.SetKinematicRecursive(((Component)physical).transform, value: false);
			}
		}

		public override void OnTransformParentChanged()
		{
			if (parentChanged != null)
			{
				parentChanged();
			}
			base.OnTransformParentChanged();
		}

		private void OnPlayerBodyInit(FVRPlayerBody playerBody)
		{
			if (securedCode != -1 && !GameManager.sceneLoading)
			{
				Unsecure();
			}
		}

		protected virtual void OnSceneLeft(string scene, string destination)
		{
			TrackedObjectData.ObjectBringType bring = TrackedObjectData.ObjectBringType.No;
			data.ShouldBring(scene: true, ref bring);
			if (data.IsControlled(out var interactionID) && bring > TrackedObjectData.ObjectBringType.No)
			{
				if (data.parent == -1)
				{
					EnsureUncontrolled();
					((Component)this).transform.parent = null;
					Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
					securedCode = interactionID;
				}
				data.SetScene(destination, send: true);
			}
		}

		protected virtual void OnSceneJoined(string scene, string source)
		{
			if (securedCode != -1 && (Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				Unsecure();
			}
		}

		public virtual void Unsecure()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			SceneManager.MoveGameObjectToScene(((Component)this).gameObject, SceneManager.GetActiveScene());
			if (securedCode == 1)
			{
				((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().ForceSetInteractable((FVRInteractiveObject)(object)physicalItem);
			}
			else if (securedCode == 2)
			{
				((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().ForceSetInteractable((FVRInteractiveObject)(object)physicalItem);
			}
			else if (securedCode >= 3 && securedCode <= 258)
			{
				if (GM.CurrentPlayerBody.QBSlots_Internal.Count > securedCode - 3)
				{
					physicalItem.SetQuickBeltSlot(GM.CurrentPlayerBody.QBSlots_Internal[securedCode - 3]);
				}
			}
			else if (securedCode >= 259 && securedCode <= 514 && GM.CurrentPlayerBody.QBSlots_Added.Count > securedCode - 259)
			{
				physicalItem.SetQuickBeltSlot(GM.CurrentPlayerBody.QBSlots_Added[securedCode - 259]);
			}
			securedCode = -1;
		}

		protected virtual void OnInstanceJoined(int instance, int source)
		{
			if (GameManager.sceneLoading)
			{
				if (securedCode != -1)
				{
					data.SetInstance(instance, send: true);
				}
				return;
			}
			TrackedObjectData.ObjectBringType bring = TrackedObjectData.ObjectBringType.No;
			data.ShouldBring(scene: false, ref bring);
			GameManager.giveControlOfDestroyed++;
			int interactionID2;
			if (bring == TrackedObjectData.ObjectBringType.Yes)
			{
				if (data.IsControlled(out var _))
				{
					data.SetInstance(instance, send: true);
				}
				else
				{
					bool flag = data.parent == -1;
					GameManager.DestroyTrackedScripts(data);
					if (flag)
					{
						GameManager.SyncTrackedObjects(((Component)this).transform, controlEverything: true, null);
					}
				}
			}
			else if (bring == TrackedObjectData.ObjectBringType.OnlyInteracted && data.IsControlled(out interactionID2))
			{
				data.SetInstance(instance, send: true);
			}
			else
			{
				Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
			}
			GameManager.giveControlOfDestroyed--;
		}

		public override bool HandleShatter(UberShatterable shatterable, Vector3 point, Vector3 dir, float intensity, bool received, int clientID, byte[] data)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (handleShatterSpecific != null)
			{
				return handleShatterSpecific(shatterable, point, dir, intensity, received, clientID, data);
			}
			return true;
		}

		private bool HandleShatterableShatter(UberShatterable shatterable, Vector3 point, Vector3 dir, float intensity, bool received, int clientID, byte[] data)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			itemData.additionalData[0] = 1;
			itemData.additionalData[1] = 1;
			BitConverter.GetBytes(point.x).CopyTo(itemData.additionalData, 2);
			BitConverter.GetBytes(point.y).CopyTo(itemData.additionalData, 6);
			BitConverter.GetBytes(point.z).CopyTo(itemData.additionalData, 10);
			BitConverter.GetBytes(dir.x).CopyTo(itemData.additionalData, 14);
			BitConverter.GetBytes(dir.y).CopyTo(itemData.additionalData, 18);
			BitConverter.GetBytes(dir.z).CopyTo(itemData.additionalData, 22);
			BitConverter.GetBytes(intensity).CopyTo(itemData.additionalData, 26);
			if (received)
			{
				UberShatterableShatterPatch.skip++;
				((UberShatterable)dataObject).Shatter(point, dir, intensity);
				UberShatterableShatterPatch.skip--;
				if (ThreadManager.host)
				{
					ServerSend.UberShatterableShatter(base.data.trackedID, point, dir, intensity, null, clientID);
				}
			}
			else if (ThreadManager.host)
			{
				ServerSend.UberShatterableShatter(base.data.trackedID, point, dir, intensity, null);
			}
			else if (itemData.trackedID != -1)
			{
				ClientSend.UberShatterableShatter(base.data.trackedID, point, dir, intensity, null);
			}
			return true;
		}
	}
	public class TrackedItemData : TrackedObjectData
	{
		public delegate void OnCollectAdditionalDataDelegate(ref bool collected, TrackedItemData trackedItemData);

		public delegate void OnProcessAdditionalDataDelegate(ref bool processed, TrackedItemData trackedItemData);

		public TrackedItem physicalItem;

		public bool underActiveControl;

		public bool previousActiveControl;

		public string itemID;

		public byte[] identifyingData;

		public byte[] additionalData;

		public Vector3 position;

		public Quaternion rotation;

		public Vector3 previousPos;

		public Quaternion previousRot;

		public Vector3 velocity = Vector3.zero;

		public byte[] data;

		public byte[] previousData;

		public int[] toPutInSosigInventory;

		public static event OnCollectAdditionalDataDelegate OnCollectAdditionalData;

		public static event OnProcessAdditionalDataDelegate OnProcessAdditionalData;

		public TrackedItemData()
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)


		public TrackedItemData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			int num = packet.ReadInt();
			if (num > 0)
			{
				data = packet.ReadBytes(num);
			}
			underActiveControl = packet.ReadBool();
			itemID = packet.ReadString();
			int num2 = packet.ReadInt();
			if (num2 > 0)
			{
				identifyingData = packet.ReadBytes(num2);
			}
			int num3 = packet.ReadInt();
			if (num3 > 0)
			{
				additionalData = packet.ReadBytes(num3);
			}
		}

		public static bool IsOfType(Transform t)
		{
			FVRPhysicalObject component = ((Component)t).GetComponent<FVRPhysicalObject>();
			if ((Object)(object)component != (Object)null)
			{
				return ((Object)(object)component.ObjectWrapper != (Object)null && IM.OD.ContainsKey(component.ObjectWrapper.ItemID)) || ((Object)(object)component.IDSpawnedFrom != (Object)null && (IM.OD.ContainsKey(((Object)component.IDSpawnedFrom).name) || IM.OD.ContainsKey(component.IDSpawnedFrom.ItemID))) || (Object)(object)((Component)component).GetComponent<TNH_ShatterableCrate>() != (Object)null;
			}
			return false;
		}

		public override bool IsIdentifiable()
		{
			return IM.OD.ContainsKey(itemID) || itemID.Equals("TNH_ShatterableCrate");
		}

		public static TrackedItem MakeTracked(Transform root, TrackedObjectData parent)
		{
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			Mod.LogInfo("Making item tracked", debug: false);
			TrackedItem trackedItem = ((Component)root).gameObject.AddComponent<TrackedItem>();
			TrackedItemData trackedItemData = (trackedItem.itemData = (TrackedItemData)(trackedItem.data = new TrackedItemData()));
			trackedItemData.physicalItem = trackedItem;
			trackedItemData.physical = trackedItem;
			trackedItemData.physicalItem.physicalItem = ((Component)root).GetComponent<FVRPhysicalObject>();
			trackedItemData.physical.physical = (MonoBehaviour)(object)trackedItemData.physicalItem.physicalItem;
			trackedItemData.typeIdentifier = "TrackedItemData";
			trackedItemData.active = ((Component)trackedItem).gameObject.activeInHierarchy;
			trackedItemData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedItemData.instance = GameManager.instance;
			trackedItemData.controller = GameManager.ID;
			trackedItemData.initTracker = GameManager.ID;
			trackedItemData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedItemByItem.Add(trackedItemData.physicalItem.physicalItem, trackedItem);
			if (trackedItemData.physicalItem.physicalItem is SosigWeaponPlayerInterface)
			{
				Dictionary<SosigWeapon, TrackedItem> trackedItemBySosigWeapon = GameManager.trackedItemBySosigWeapon;
				FVRPhysicalObject obj = trackedItemData.physicalItem.physicalItem;
				trackedItemBySosigWeapon.Add(((SosigWeaponPlayerInterface)((obj is SosigWeaponPlayerInterface) ? obj : null)).W, trackedItem);
			}
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedItemData.physicalItem.physicalItem, trackedItem);
			GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)trackedItemData.physicalItem.physicalItem, trackedItem);
			if (parent != null)
			{
				trackedItemData.parent = parent.trackedID;
				if (parent.children == null)
				{
					parent.children = new List<TrackedObjectData>();
				}
				trackedItemData.childIndex = parent.children.Count;
				parent.children.Add(trackedItemData);
				trackedItemData.position = ((Component)trackedItem).transform.localPosition;
				trackedItemData.rotation = ((Component)trackedItem).transform.localRotation;
			}
			else
			{
				trackedItemData.position = ((Component)trackedItem).transform.position;
				trackedItemData.rotation = ((Component)trackedItem).transform.rotation;
			}
			trackedItemData.SetItemIdentifyingInfo();
			Mod.LogInfo("\tItemID: " + trackedItemData.itemID, debug: false);
			trackedItemData.underActiveControl = trackedItemData.IsControlled(out var _);
			trackedItemData.CollectExternalData();
			trackedItemData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedItemData);
			if (trackedItem.updateFunc != null)
			{
				trackedItem.updateFunc();
			}
			return trackedItem;
		}

		public void CollectExternalData()
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0528: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0806: Expected O, but got Unknown
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0629: Unknown result type (might be due to invalid IL or missing references)
			//IL_0662: Unknown result type (might be due to invalid IL or missing references)
			bool collected = false;
			if (TrackedItemData.OnCollectAdditionalData != null)
			{
				TrackedItemData.OnCollectAdditionalData(ref collected, this);
			}
			if (collected)
			{
				return;
			}
			TNH_ShatterableCrate component = ((Component)physical).GetComponent<TNH_ShatterableCrate>();
			if ((Object)(object)component != (Object)null)
			{
				additionalData = new byte[6];
				additionalData[0] = (byte)(TNH_SupplyPointPatch.inSpawnBoxes ? 1 : 0);
				if (TNH_SupplyPointPatch.inSpawnBoxes)
				{
					BitConverter.GetBytes((short)TNH_SupplyPointPatch.supplyPointIndex).CopyTo(additionalData, 1);
				}
				additionalData[3] = (byte)(component.m_isHoldingHealth ? 1 : 0);
				additionalData[4] = (byte)(component.m_isHoldingToken ? 1 : 0);
				additionalData[5] = (byte)(component.m_usesLoot ? 1 : 0);
			}
			else if (physicalItem.physicalItem is GrappleThrowable)
			{
				GrappleThrowable val = (GrappleThrowable)physicalItem.physicalItem;
				additionalData = new byte[val.finalRopePoints.Count * 12 + 2];
				additionalData[0] = (byte)(val.m_hasLanded ? 1 : 0);
				additionalData[1] = (byte)val.finalRopePoints.Count;
				if (val.finalRopePoints.Count > 0)
				{
					for (int i = 0; i < val.finalRopePoints.Count; i++)
					{
						BitConverter.GetBytes(val.finalRopePoints[i].x).CopyTo(additionalData, i * 12 + 2);
						BitConverter.GetBytes(val.finalRopePoints[i].y).CopyTo(additionalData, i * 12 + 6);
						BitConverter.GetBytes(val.finalRopePoints[i].z).CopyTo(additionalData, i * 12 + 10);
					}
				}
			}
			else if (physicalItem.dataObject is UberShatterable)
			{
				Object dataObject = physicalItem.dataObject;
				UberShatterable val2 = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
				additionalData = new byte[40];
				additionalData[0] = (byte)(val2.m_hasShattered ? 1 : 0);
				additionalData[1] = 0;
				additionalData[34] = (byte)(TNH_SupplyPointPatch.inSpawnBoxes ? 1 : 0);
				if (TNH_SupplyPointPatch.inSpawnBoxes)
				{
					BitConverter.GetBytes((short)TNH_SupplyPointPatch.supplyPointIndex).CopyTo(additionalData, 35);
				}
				if (!((Object)(object)TNH_SupplyPointPatch.supplyPointInstance != (Object)null))
				{
					return;
				}
				if (val2.m_usesTNHLoot)
				{
					additionalData[39] = 1;
				}
				for (int j = 0; j < val2.SpawnOnShatter.Count; j++)
				{
					if ((Object)(object)val2.SpawnOnShatter[j] == (Object)(object)TNH_SupplyPointPatch.supplyPointInstance.M.ResourceLib.Prefab_HealthMinor)
					{
						additionalData[37] = 1;
					}
					if ((Object)(object)val2.SpawnOnShatter[j] == (Object)(object)TNH_SupplyPointPatch.supplyPointInstance.M.ResourceLib.Prefab_Token)
					{
						additionalData[38] = 1;
					}
				}
			}
			else if (physicalItem.dataObject is FVRFireArmAttachment)
			{
				Object dataObject2 = physicalItem.dataObject;
				FVRFireArmAttachment val3 = (FVRFireArmAttachment)(object)((dataObject2 is FVRFireArmAttachment) ? dataObject2 : null);
				if ((Object)(object)val3.curMount != (Object)null && GameManager.trackedItemByItem.TryGetValue(val3.curMount.MyObject, out var value))
				{
					physicalItem.mountObjectID = value.data.trackedID;
				}
				else
				{
					physicalItem.mountObjectID = -1;
				}
			}
			else if (physicalItem.dataObject is AttachableFirearm)
			{
				Object dataObject3 = physicalItem.dataObject;
				AttachableFirearm val4 = (AttachableFirearm)(object)((dataObject3 is AttachableFirearm) ? dataObject3 : null);
				if ((Object)(object)((FVRFireArmAttachment)val4.Attachment).curMount != (Object)null && GameManager.trackedItemByItem.TryGetValue(((FVRFireArmAttachment)val4.Attachment).curMount.MyObject, out var value2))
				{
					physicalItem.mountObjectID = value2.data.trackedID;
				}
				else
				{
					physicalItem.mountObjectID = -1;
				}
			}
			else if (physicalItem.dataObject is Brut_GasCuboid)
			{
				Object dataObject4 = physicalItem.dataObject;
				Brut_GasCuboid val5 = (Brut_GasCuboid)(object)((dataObject4 is Brut_GasCuboid) ? dataObject4 : null);
				additionalData = new byte[2 + val5.m_gouts.Count * 24];
				additionalData[0] = (byte)(val5.m_isHandleBrokenOff ? 1 : 0);
				additionalData[1] = (byte)val5.m_gouts.Count;
				for (int k = 0; k < val5.m_gouts.Count; k++)
				{
					int num = k * 24 + 2;
					Vector3 localPosition = ((Component)val5.m_gouts[k]).transform.localPosition;
					byte[] bytes = BitConverter.GetBytes(localPosition.x);
					for (int l = 0; l < 4; l++)
					{
						additionalData[num + l] = bytes[l];
					}
					bytes = BitConverter.GetBytes(localPosition.y);
					for (int m = 0; m < 4; m++)
					{
						additionalData[num + m + 4] = bytes[m];
					}
					bytes = BitConverter.GetBytes(localPosition.z);
					for (int n = 0; n < 4; n++)
					{
						additionalData[num + n + 8] = bytes[n];
					}
					Vector3 localEulerAngles = ((Component)val5.m_gouts[k]).transform.localEulerAngles;
					bytes = BitConverter.GetBytes(localEulerAngles.x);
					for (int num2 = 0; num2 < 4; num2++)
					{
						additionalData[num + num2] = bytes[num2];
					}
					bytes = BitConverter.GetBytes(localEulerAngles.y);
					for (int num3 = 0; num3 < 4; num3++)
					{
						additionalData[num + num3 + 4] = bytes[num3];
					}
					bytes = BitConverter.GetBytes(localEulerAngles.z);
					for (int num4 = 0; num4 < 4; num4++)
					{
						additionalData[num + num4 + 8] = bytes[num4];
					}
				}
			}
			else
			{
				if (!(physicalItem.dataObject != (Object)null))
				{
					return;
				}
				Type[] interfaces = ((object)physicalItem.dataObject).GetType().GetInterfaces();
				if (interfaces == null)
				{
					return;
				}
				for (int num5 = 0; num5 < interfaces.Length; num5++)
				{
					if ((object)interfaces[num5] != PatchController.MW_IModularWeapon)
					{
						continue;
					}
					IDictionary dictionary = PatchController.MW_IModularWeapon_get_AllAttachmentPoints.Invoke(physicalItem.dataObject, null) as IDictionary;
					List<byte> list = new List<byte>();
					list.AddRange(BitConverter.GetBytes(dictionary.Count));
					foreach (DictionaryEntry item in dictionary)
					{
						string text = (string)item.Key;
						string text2 = (string)PatchController.MW_ModularWeaponPartsAttachmentPoint_SelectedModularWeaponPart.GetValue(item.Value);
						list.AddRange(BitConverter.GetBytes(text.Length));
						list.AddRange(Encoding.ASCII.GetBytes(text));
						list.AddRange(BitConverter.GetBytes(text2.Length));
						list.AddRange(Encoding.ASCII.GetBytes(text2));
						Transform val6 = (Transform)PatchController.MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint.GetValue(item.Value);
						MonoBehaviour[] components = ((Component)val6).GetComponents<MonoBehaviour>();
						MonoBehaviour val7 = null;
						for (int num6 = 0; num6 < components.Length; num6++)
						{
							if ((object)((object)components[num6]).GetType() == PatchController.MW_ModularWeaponPart || ((object)components[num6]).GetType().IsSubclassOf(PatchController.MW_ModularWeaponPart))
							{
								val7 = components[num6];
								break;
							}
						}
						if ((Object)(object)val7 == (Object)null)
						{
							list.AddRange(BitConverter.GetBytes(0));
						}
						else
						{
							string text3 = (string)PatchController.MW_ModularWeaponPart_SelectedModularWeaponPartSkinID.GetValue(val7);
							list.AddRange(BitConverter.GetBytes(text3.Length));
							list.AddRange(Encoding.ASCII.GetBytes(text3));
						}
						List<byte> list2 = new List<byte>();
						TrackedItem.AddModulPartDataInvoke(list2, text, text2, dictionary, physicalItem);
						list.AddRange(BitConverter.GetBytes(list2.Count));
						list.AddRange(list2);
					}
					additionalData = list.ToArray();
					break;
				}
			}
		}

		public void SetItemIdentifyingInfo()
		{
			if ((Object)(object)physicalItem.physicalItem.ObjectWrapper != (Object)null)
			{
				itemID = physicalItem.physicalItem.ObjectWrapper.ItemID;
				if (itemID.Equals("BrutBarrelExplosive") && ((Object)physicalItem).name.Contains("Wieners"))
				{
					itemID = "BrutBarrelWieners";
				}
				return;
			}
			if ((Object)(object)physicalItem.physicalItem.IDSpawnedFrom != (Object)null)
			{
				if (IM.OD.ContainsKey(((Object)physicalItem.physicalItem.IDSpawnedFrom).name))
				{
					itemID = ((Object)physicalItem.physicalItem.IDSpawnedFrom).name;
				}
				else if (IM.OD.ContainsKey(physicalItem.physicalItem.IDSpawnedFrom.ItemID))
				{
					itemID = physicalItem.physicalItem.IDSpawnedFrom.ItemID;
				}
				return;
			}
			TNH_ShatterableCrate component = ((Component)physicalItem.physicalItem).GetComponent<TNH_ShatterableCrate>();
			if ((Object)(object)component != (Object)null)
			{
				itemID = "TNH_ShatterableCrate";
				identifyingData = new byte[1];
				if (((Object)component).name[9] == 'S')
				{
					identifyingData[0] = 2;
				}
				else if (((Object)component).name[9] == 'M')
				{
					identifyingData[0] = 1;
				}
				else
				{
					identifyingData[0] = 0;
				}
			}
		}

		public override IEnumerator Instantiate()
		{
			GameObject itemPrefab = GetItemPrefab();
			if ((Object)(object)itemPrefab == (Object)null && IM.OD.TryGetValue(itemID, out var obj))
			{
				yield return ((AnvilAsset)obj).GetGameObjectAsync();
				itemPrefab = ((AnvilAsset)obj).GetGameObject();
			}
			if ((Object)(object)itemPrefab == (Object)null)
			{
				Mod.LogError($"Attempted to instantiate {itemID} sent from {base.controller} but failed to get item prefab.");
				awaitingInstantiation = false;
			}
			else
			{
				if (!awaitingInstantiation)
				{
					yield break;
				}
				try
				{
					Mod.LogInfo("Instantiating item at " + trackedID + ": " + itemID, debug: false);
					Mod.skipAllInstantiates++;
					if (Mod.skipAllInstantiates <= 0)
					{
						Mod.LogError("SkipAllInstantiates negative or 0 at item instantiation, setting to 1");
						Mod.skipAllInstantiates = 1;
					}
					GameObject itemObject = Object.Instantiate<GameObject>(itemPrefab, position, rotation);
					Mod.skipAllInstantiates--;
					physicalItem = itemObject.AddComponent<TrackedItem>();
					physical = physicalItem;
					awaitingInstantiation = false;
					physicalItem.itemData = this;
					physical.data = this;
					physicalItem.physicalItem = itemObject.GetComponent<FVRPhysicalObject>();
					physical.physical = (MonoBehaviour)(object)physicalItem.physicalItem;
					if (GameManager.trackedItemByItem.TryGetValue(physicalItem.physicalItem, out var t))
					{
						Mod.LogError("Error at instantiation of: " + itemID + ": Item's physical item object already exists in trackedItemByItem\n\tTrackedID: " + t.data.trackedID);
					}
					else
					{
						GameManager.trackedItemByItem.Add(physicalItem.physicalItem, physicalItem);
					}
					if (physicalItem.physicalItem is SosigWeaponPlayerInterface)
					{
						Dictionary<SosigWeapon, TrackedItem> trackedItemBySosigWeapon = GameManager.trackedItemBySosigWeapon;
						FVRPhysicalObject obj2 = physicalItem.physicalItem;
						trackedItemBySosigWeapon.Add(((SosigWeaponPlayerInterface)((obj2 is SosigWeaponPlayerInterface) ? obj2 : null)).W, physicalItem);
					}
					if (GameManager.trackedObjectByObject.TryGetValue((MonoBehaviour)(object)physicalItem.physicalItem, out var to))
					{
						Mod.LogError("Error at instantiation of: " + itemID + ": Item's physical object already exists in trackedObjectByObject\n\tTrackedID: " + to.data.trackedID);
					}
					else
					{
						GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalItem.physicalItem, physicalItem);
					}
					GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)physicalItem.physicalItem, physicalItem);
					if (parent != -1)
					{
						TrackedObjectData parentObject = (ThreadManager.host ? Server.objects : Client.objects)[parent];
						if ((Object)(object)parentObject.physical == (Object)null)
						{
							parentObject.childrenToParent.Add(trackedID);
						}
						else
						{
							ignoreParentChanged++;
							itemObject.transform.parent = ((Component)parentObject.physical).transform;
							ignoreParentChanged--;
						}
					}
					if (base.controller != GameManager.ID)
					{
						Mod.SetKinematicRecursive(((Component)physical).transform, value: true);
					}
					UpdateFromData(this);
					ProcessAdditionalData();
					int i = 0;
					while (i < childrenToParent.Count)
					{
						TrackedObjectData childObject = (ThreadManager.host ? Server.objects : Client.objects)[childrenToParent[i]];
						if (childObject != null && childObject.parent == trackedID && (Object)(object)childObject.physical != (Object)null)
						{
							childObject.ignoreParentChanged++;
							((Component)childObject.physical).transform.parent = ((Component)physical).transform;
							childObject.ignoreParentChanged--;
							childObject.UpdateFromData(childObject);
						}
						int num = i + 1;
						i = num;
					}
					childrenToParent.Clear();
					if (toPutInSosigInventory == null)
					{
						yield break;
					}
					TrackedSosigData trackedSosig = (ThreadManager.host ? Server.objects[toPutInSosigInventory[0]] : Client.objects[toPutInSosigInventory[0]]) as TrackedSosigData;
					if (trackedSosig != null && trackedSosig.inventory[toPutInSosigInventory[1]] == trackedID)
					{
						SosigPickUpPatch.skip++;
						SosigPlaceObjectInPatch.skip++;
						if (toPutInSosigInventory[1] == 0)
						{
							trackedSosig.physicalSosig.physicalSosig.Hand_Primary.PickUp(((SosigWeaponPlayerInterface)physicalItem.physicalItem).W);
						}
						else if (toPutInSosigInventory[1] == 1)
						{
							trackedSosig.physicalSosig.physicalSosig.Hand_Secondary.PickUp(((SosigWeaponPlayerInterface)physicalItem.physicalItem).W);
						}
						else
						{
							trackedSosig.physicalSosig.physicalSosig.Inventory.Slots[toPutInSosigInventory[1] - 2].PlaceObjectIn(((SosigWeaponPlayerInterface)physicalItem.physicalItem).W);
						}
						SosigPickUpPatch.skip--;
						SosigPlaceObjectInPatch.skip--;
					}
				}
				catch (Exception ex)
				{
					Mod.LogError("Error while trying to instantiate item: " + itemID + ":\n" + ex.Message + "\n" + ex.StackTrace);
				}
			}
		}

		public void ProcessAdditionalData()
		{
			//IL_0730: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			bool processed = false;
			if (TrackedItemData.OnProcessAdditionalData != null)
			{
				TrackedItemData.OnProcessAdditionalData(ref processed, this);
			}
			if (processed)
			{
				return;
			}
			TNH_ShatterableCrate component = ((Component)physical).GetComponent<TNH_ShatterableCrate>();
			if ((Object)(object)component != (Object)null)
			{
				if (Mod.currentTNHInstance != null && Mod.currentlyPlayingTNH)
				{
					if (additionalData[0] == 1)
					{
						Mod.currentTNHInstance.manager.SupplyPoints[BitConverter.ToInt16(additionalData, 1)].m_spawnBoxes.Add(((Component)physical).gameObject);
					}
					if (additionalData[3] == 1)
					{
						component.SetHoldingHealth(Mod.currentTNHInstance.manager);
					}
					if (additionalData[4] == 1)
					{
						component.SetHoldingToken(Mod.currentTNHInstance.manager);
					}
				}
			}
			else if (physical.physical is GrappleThrowable)
			{
				if (additionalData[0] == 1 && data[0] == 1)
				{
					MonoBehaviour obj = physical.physical;
					GrappleThrowable val = (GrappleThrowable)(object)((obj is GrappleThrowable) ? obj : null);
					((FVRPhysicalObject)val).RootRigidbody.isKinematic = true;
					val.m_isRopeFree = true;
					val.BundledRope.SetActive(false);
					val.m_hasBeenThrown = true;
					val.m_hasLanded = true;
					if (val.m_ropeLengths.Count > 0)
					{
						for (int num = val.m_ropeLengths.Count - 1; num >= 0; num--)
						{
							Object.Destroy((Object)(object)val.m_ropeLengths[num]);
						}
						val.m_ropeLengths.Clear();
					}
					val.finalRopePoints.Clear();
					val.FakeRopeLength.SetActive(false);
					int num2 = additionalData[1];
					Vector3 val2 = default(Vector3);
					((Vector3)(ref val2))..ctor(BitConverter.ToSingle(additionalData, 2), BitConverter.ToSingle(additionalData, 6), BitConverter.ToSingle(additionalData, 10));
					Vector3 val3 = default(Vector3);
					for (int i = 1; i < num2; i++)
					{
						((Vector3)(ref val3))..ctor(BitConverter.ToSingle(additionalData, i * 12 + 2), BitConverter.ToSingle(additionalData, i * 12 + 6), BitConverter.ToSingle(additionalData, i * 12 + 10));
						Vector3 val4 = val3 - val2;
						GameObject val5 = Object.Instantiate<GameObject>(val.RopeLengthPrefab, val3, Quaternion.LookRotation(-val4, Vector3.up));
						val5.transform.localScale = new Vector3(1f, 1f, ((Vector3)(ref val4)).magnitude);
						FVRHandGrabPoint val6 = null;
						if (val.m_ropeLengths.Count > 0)
						{
							val6 = val.m_ropeLengths[val.m_ropeLengths.Count - 1].GetComponent<FVRHandGrabPoint>();
						}
						FVRHandGrabPoint component2 = val5.GetComponent<FVRHandGrabPoint>();
						val.m_ropeLengths.Add(val5);
						if ((Object)(object)val6 != (Object)null && (Object)(object)component2 != (Object)null)
						{
							val6.ConnectedGrabPoint_Base = component2;
							component2.ConnectedGrabPoint_End = val6;
						}
						val.finalRopePoints.Add(val3);
						val2 = val3;
					}
				}
			}
			else if (physicalItem.dataObject is UberShatterable)
			{
				if (additionalData[34] == 1)
				{
					Object dataObject = physicalItem.dataObject;
					UberShatterable val7 = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
					if (additionalData[37] == 1)
					{
						if ((Object)(object)val7 != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
						{
							val7.SpawnOnShatter.Clear();
							val7.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
							val7.SpawnOnShatterPoints.Add(((Component)val7).transform);
							val7.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
							val7.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_HealthMinor);
							val7.SpawnOnShatterPoints.Add(((Component)val7).transform);
							val7.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)2);
						}
					}
					else if (additionalData[38] == 1 && (Object)(object)val7 != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
					{
						val7.SpawnOnShatter.Clear();
						val7.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
						val7.SpawnOnShatterPoints.Add(((Component)val7).transform);
						val7.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
						val7.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Token);
						val7.SpawnOnShatterPoints.Add(((Component)val7).transform);
						val7.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)2);
					}
				}
				if (additionalData[0] == 1)
				{
					if (additionalData[1] == 0)
					{
						UberShatterableShatterPatch.skip++;
						Object dataObject2 = physicalItem.dataObject;
						((UberShatterable)((dataObject2 is UberShatterable) ? dataObject2 : null)).Shatter(Vector3.zero, Vector3.zero, 0f);
						UberShatterableShatterPatch.skip--;
					}
					else
					{
						Vector3 val8 = default(Vector3);
						((Vector3)(ref val8))..ctor(BitConverter.ToSingle(additionalData, 2), BitConverter.ToSingle(additionalData, 6), BitConverter.ToSingle(additionalData, 10));
						Vector3 val9 = default(Vector3);
						((Vector3)(ref val9))..ctor(BitConverter.ToSingle(additionalData, 14), BitConverter.ToSingle(additionalData, 18), BitConverter.ToSingle(additionalData, 22));
						float num3 = BitConverter.ToSingle(additionalData, 26);
						UberShatterableShatterPatch.skip++;
						Object dataObject3 = physicalItem.dataObject;
						((UberShatterable)((dataObject3 is UberShatterable) ? dataObject3 : null)).Shatter(val8, val9, num3);
						UberShatterableShatterPatch.skip--;
					}
				}
			}
			else if (physicalItem.dataObject is Brut_GasCuboid)
			{
				Object dataObject4 = physicalItem.dataObject;
				Brut_GasCuboid val10 = (Brut_GasCuboid)(object)((dataObject4 is Brut_GasCuboid) ? dataObject4 : null);
				val10.m_isHandleBrokenOff = additionalData[0] == 1;
				val10.Handle.SetActive(!val10.m_isHandleBrokenOff);
				Vector3 val11 = default(Vector3);
				Vector3 val12 = default(Vector3);
				for (int j = 0; j < additionalData[1]; j++)
				{
					int num4 = j * 24 + 2;
					((Vector3)(ref val11))..ctor(BitConverter.ToSingle(additionalData, num4), BitConverter.ToSingle(additionalData, num4 + 4), BitConverter.ToSingle(additionalData, num4 + 8));
					((Vector3)(ref val12))..ctor(BitConverter.ToSingle(additionalData, num4), BitConverter.ToSingle(additionalData, num4 + 4), BitConverter.ToSingle(additionalData, num4 + 8));
					val10.hasGeneratedGoutYet = false;
					val10.GenerateGout(val11, val12);
				}
			}
			else
			{
				Type[] interfaces = ((object)physicalItem.dataObject).GetType().GetInterfaces();
				if (interfaces != null)
				{
					int num5 = 0;
					for (int k = 0; k < interfaces.Length; k++)
					{
						if ((object)interfaces[k] != PatchController.MW_IModularWeapon)
						{
							continue;
						}
						IDictionary dictionary = PatchController.MW_IModularWeapon_get_AllAttachmentPoints.Invoke(physicalItem.dataObject, null) as IDictionary;
						int num6 = BitConverter.ToInt32(additionalData, num5);
						num5 += 4;
						for (int l = 0; l < num6; l++)
						{
							int num7 = BitConverter.ToInt32(additionalData, num5);
							num5 += 4;
							string text = Encoding.ASCII.GetString(additionalData, num5, num7);
							num5 += num7;
							int num8 = BitConverter.ToInt32(additionalData, num5);
							num5 += 4;
							string text2 = Encoding.ASCII.GetString(additionalData, num5, num8);
							num5 += num8;
							int num9 = BitConverter.ToInt32(additionalData, num5);
							num5 += 4;
							bool flag = num9 > 0;
							string text3 = null;
							if (flag)
							{
								text3 = Encoding.ASCII.GetString(additionalData, num5, num9);
								num5 += num9;
							}
							int num10 = BitConverter.ToInt32(additionalData, num5);
							num5 += 4;
							TrackedItem.PreConfigureModulPartInvoke(additionalData, num5, text, dictionary, physicalItem);
							ModularWeaponPartPatch.skip++;
							PatchController.MW_IModularWeapon_ConfigureModularWeaponPart.Invoke(physicalItem.dataObject, new object[3]
							{
								dictionary[text],
								text2,
								false
							});
							if (flag)
							{
								PatchController.MW_IModularWeapon_ApplySkin.Invoke(physicalItem.dataObject, new object[2] { text, text3 });
							}
							ModularWeaponPartPatch.skip--;
							TrackedItem.ReadModulPartDataInvoke(additionalData, num5, text, dictionary, physicalItem);
							num5 += num10;
						}
						break;
					}
				}
			}
			if ((Object)(object)physicalItem.integratedLaser != (Object)null && base.controller != GameManager.ID)
			{
				physicalItem.integratedLaser.UsesAutoOnOff = false;
			}
		}

		public virtual GameObject GetItemPrefab()
		{
			if (itemID.Equals("TNH_ShatterableCrate") && (Object)(object)GM.TNH_Manager != (Object)null)
			{
				return GM.TNH_Manager.Prefabs_ShatterableCrates[identifyingData[0]];
			}
			return null;
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedItemData trackedItemData = updatedObject as TrackedItemData;
			if (full)
			{
				itemID = trackedItemData.itemID;
				identifyingData = trackedItemData.identifyingData;
				additionalData = trackedItemData.additionalData;
			}
			previousPos = position;
			previousRot = rotation;
			position = trackedItemData.position;
			_ = previousPos;
			velocity = position - previousPos;
			rotation = trackedItemData.rotation;
			previousActiveControl = underActiveControl;
			underActiveControl = trackedItemData.underActiveControl;
			if ((Object)(object)physical != (Object)null && !TrackedItem.interpolated)
			{
				if (parent == -1)
				{
					((Component)physical).transform.position = trackedItemData.position;
					((Component)physical).transform.rotation = trackedItemData.rotation;
				}
				else
				{
					((Component)physical).transform.localPosition = trackedItemData.position;
					((Component)physical).transform.localRotation = trackedItemData.rotation;
				}
			}
			UpdateData(trackedItemData.data);
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			previousPos = position;
			previousRot = rotation;
			position = packet.ReadVector3();
			_ = previousPos;
			velocity = position - previousPos;
			rotation = packet.ReadQuaternion();
			int length = packet.ReadInt();
			byte[] newData = packet.ReadBytes(length);
			previousActiveControl = underActiveControl;
			underActiveControl = packet.ReadBool();
			if (full)
			{
				itemID = packet.ReadString();
				int num = packet.ReadInt();
				if (num > 0)
				{
					identifyingData = packet.ReadBytes(num);
				}
				else
				{
					identifyingData = null;
				}
				int num2 = packet.ReadInt();
				if (num2 > 0)
				{
					additionalData = packet.ReadBytes(num2);
				}
				else
				{
					additionalData = null;
				}
			}
			if ((Object)(object)physical != (Object)null && !TrackedItem.interpolated)
			{
				if (parent == -1)
				{
					((Component)physical).transform.position = position;
					((Component)physical).transform.rotation = rotation;
				}
				else
				{
					((Component)physical).transform.localPosition = position;
					((Component)physical).transform.localRotation = rotation;
				}
			}
			UpdateData(newData);
		}

		public override bool Update(bool full = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			bool flag = base.Update(full);
			if ((Object)(object)physical == (Object)null)
			{
				return false;
			}
			previousPos = position;
			previousRot = rotation;
			if (parent == -1)
			{
				position = ((Component)physical).transform.position;
				rotation = ((Component)physical).transform.rotation;
			}
			else
			{
				position = ((Component)physical).transform.localPosition;
				rotation = ((Component)physical).transform.localRotation;
			}
			previousActiveControl = underActiveControl;
			underActiveControl = IsControlled(out var _);
			int result;
			if (!(UpdateData() || flag) && previousActiveControl == underActiveControl)
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					result = ((!((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2)) ? 1 : 0);
					goto IL_0119;
				}
			}
			result = 1;
			goto IL_0119;
			IL_0119:
			return (byte)result != 0;
		}

		public override bool NeedsUpdate()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (!base.NeedsUpdate() && previousActiveControl == underActiveControl)
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2))
					{
						result = ((!DataEqual()) ? 1 : 0);
						goto IL_005f;
					}
				}
			}
			result = 1;
			goto IL_005f;
			IL_005f:
			return (byte)result != 0;
		}

		public static bool IsControlled(Transform root)
		{
			FVRPhysicalObject component = ((Component)root).GetComponent<FVRPhysicalObject>();
			if ((Object)(object)component != (Object)null)
			{
				bool flag = (Object)(object)component.QuickbeltSlot != (Object)null && (Object)(object)GM.CurrentPlayerBody != (Object)null && (GM.CurrentPlayerBody.QBSlots_Internal.Contains(component.QuickbeltSlot) || GM.CurrentPlayerBody.QBSlots_Added.Contains(component.QuickbeltSlot));
				return (Object)(object)((FVRInteractiveObject)component).m_hand != (Object)null || flag;
			}
			return false;
		}

		public override bool IsControlled(out int interactionID)
		{
			interactionID = -1;
			bool flag = (Object)(object)physicalItem.physicalItem.QuickbeltSlot != (Object)null && (Object)(object)GM.CurrentPlayerBody != (Object)null;
			bool flag2 = false;
			if (flag)
			{
				for (int i = 0; i < GM.CurrentPlayerBody.QBSlots_Internal.Count; i++)
				{
					if ((Object)(object)GM.CurrentPlayerBody.QBSlots_Internal[i] == (Object)(object)physicalItem.physicalItem.QuickbeltSlot)
					{
						interactionID = i + 3;
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					for (int j = 0; j < GM.CurrentPlayerBody.QBSlots_Added.Count; j++)
					{
						if ((Object)(object)GM.CurrentPlayerBody.QBSlots_Added[j] == (Object)(object)physicalItem.physicalItem.QuickbeltSlot)
						{
							interactionID = j + 259;
							flag2 = true;
							break;
						}
					}
				}
			}
			if (!flag2 && (Object)(object)((FVRInteractiveObject)physicalItem.physicalItem).m_hand != (Object)null)
			{
				if (((FVRInteractiveObject)physicalItem.physicalItem).m_hand.IsThisTheRightHand)
				{
					interactionID = 2;
				}
				else
				{
					interactionID = 1;
				}
			}
			return (Object)(object)((FVRInteractiveObject)physicalItem.physicalItem).m_hand != (Object)null || flag2;
		}

		private bool DataEqual()
		{
			if (data == null && previousData == null)
			{
				return true;
			}
			if ((data == null && previousData != null) || (data != null && previousData == null) || data.Length != previousData.Length)
			{
				return false;
			}
			for (int i = 0; i < data.Length; i++)
			{
				if (data[i] != previousData[i])
				{
					return false;
				}
			}
			return true;
		}

		private bool UpdateData(byte[] newData = null)
		{
			previousData = data;
			if ((Object)(object)physicalItem == (Object)null)
			{
				data = newData;
				return false;
			}
			return physicalItem.UpdateItemData(newData);
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			base.OnTrackedIDReceived(newData);
			if (localTrackedID != -1 && TrackedItem.unknownCrateHolding.TryGetValue(localWaitingIndex, out var value))
			{
				bool flag = value == 0;
				bool flag2 = value == 1;
				bool flag3 = value == 2;
				if (ThreadManager.host)
				{
					if (flag)
					{
						ServerSend.ShatterableCrateSetHoldingHealth(trackedID);
					}
					if (flag2)
					{
						ServerSend.ShatterableCrateSetHoldingToken(trackedID);
					}
					if (flag3)
					{
						ServerSend.ShatterableCrateSetUsesLoot(trackedID);
					}
				}
				else
				{
					if (flag)
					{
						ClientSend.ShatterableCrateSetHoldingHealth(trackedID);
					}
					if (flag2)
					{
						ClientSend.ShatterableCrateSetHoldingToken(trackedID);
					}
					if (flag3)
					{
						ClientSend.ShatterableCrateSetUsesLoot(trackedID);
					}
				}
				TrackedItem.unknownCrateHolding.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedItem.unknownSosigInventoryItems.TryGetValue(localWaitingIndex, out var value2))
			{
				if ((Object)(object)value2.Key.physicalSosig != (Object)null && value2.Key.trackedID != -1)
				{
					value2.Key.inventory[value2.Value] = trackedID;
					if (value2.Value == 0)
					{
						ClientSend.SosigPickUpItem(value2.Key.physicalSosig, trackedID, primaryHand: true);
					}
					else if (value2.Value == 1)
					{
						ClientSend.SosigPickUpItem(value2.Key.physicalSosig, trackedID, primaryHand: false);
					}
					else
					{
						ClientSend.SosigPlaceItemIn(value2.Key.trackedID, value2.Value - 2, trackedID);
					}
				}
				TrackedItem.unknownSosigInventoryItems.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedItem.unknownGasCuboidGout.TryGetValue(localWaitingIndex, out var value3))
			{
				for (int i = 0; i < value3.Count; i++)
				{
					ClientSend.GasCuboidGout(trackedID, value3[i].Key, value3[i].Value);
				}
				TrackedItem.unknownGasCuboidGout.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedItem.unknownGasCuboidDamageHandle.Contains(localWaitingIndex))
			{
				ClientSend.GasCuboidDamageHandle(trackedID);
				TrackedItem.unknownGasCuboidDamageHandle.Remove(localWaitingIndex);
			}
		}

		public override void OnTracked()
		{
			if (!(physicalItem.physicalItem is SosigWeaponPlayerInterface) || !TrackedItem.unknownSosigInventoryObjects.TryGetValue(((SosigWeaponPlayerInterface)/*isinst with value type is only supported in some contexts*/).W, out var value))
			{
				return;
			}
			if ((Object)(object)value.Key.physicalSosig != (Object)null)
			{
				if (trackedID == -1)
				{
					TrackedItem.unknownSosigInventoryItems.Add(localWaitingIndex, new KeyValuePair<TrackedSosigData, int>(value.Key, value.Value));
				}
				else if (value.Key.trackedID != -1)
				{
					value.Key.inventory[value.Value] = trackedID;
					if (value.Value == 0)
					{
						if (ThreadManager.host)
						{
							ServerSend.SosigPickUpItem(value.Key.trackedID, trackedID, primaryHand: true);
						}
						else
						{
							ClientSend.SosigPickUpItem(value.Key.physicalSosig, trackedID, primaryHand: true);
						}
					}
					else if (value.Value == 1)
					{
						if (ThreadManager.host)
						{
							ServerSend.SosigPickUpItem(value.Key.trackedID, trackedID, primaryHand: false);
						}
						else
						{
							ClientSend.SosigPickUpItem(value.Key.physicalSosig, trackedID, primaryHand: false);
						}
					}
					else if (ThreadManager.host)
					{
						ServerSend.SosigPlaceItemIn(value.Key.trackedID, value.Value - 2, trackedID);
					}
					else
					{
						ClientSend.SosigPlaceItemIn(value.Key.trackedID, value.Value - 2, trackedID);
					}
				}
			}
			Dictionary<SosigWeapon, KeyValuePair<TrackedSosigData, int>> unknownSosigInventoryObjects = TrackedItem.unknownSosigInventoryObjects;
			FVRPhysicalObject obj = physicalItem.physicalItem;
			unknownSosigInventoryObjects.Remove(((SosigWeaponPlayerInterface)((obj is SosigWeaponPlayerInterface) ? obj : null)).W);
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID != -1)
			{
				return;
			}
			TrackedItem.unknownCrateHolding.Remove(localWaitingIndex);
			TrackedItem.unknownSosigInventoryItems.Remove(localWaitingIndex);
			if ((Object)(object)physical != (Object)null && physical.physical is SosigWeaponPlayerInterface)
			{
				Dictionary<SosigWeapon, KeyValuePair<TrackedSosigData, int>> unknownSosigInventoryObjects = TrackedItem.unknownSosigInventoryObjects;
				MonoBehaviour obj = physical.physical;
				unknownSosigInventoryObjects.Remove(((SosigWeaponPlayerInterface)((obj is SosigWeaponPlayerInterface) ? obj : null)).W);
			}
			if ((Object)(object)physicalItem != (Object)null && (Object)(object)physicalItem.physicalItem != (Object)null)
			{
				GameManager.trackedItemByItem.Remove(physicalItem.physicalItem);
				if (physicalItem.physicalItem is SosigWeaponPlayerInterface)
				{
					Dictionary<SosigWeapon, TrackedItem> trackedItemBySosigWeapon = GameManager.trackedItemBySosigWeapon;
					FVRPhysicalObject obj2 = physicalItem.physicalItem;
					trackedItemBySosigWeapon.Remove(((SosigWeaponPlayerInterface)((obj2 is SosigWeaponPlayerInterface) ? obj2 : null)).W);
				}
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)physicalItem.physicalItem);
				if (physicalItem.removeTrackedDamageables != null)
				{
					physicalItem.removeTrackedDamageables();
				}
			}
		}

		public override void OnControlChanged(int newController)
		{
			base.OnControlChanged(newController);
			if (newController == GameManager.ID)
			{
				if ((Object)(object)physicalItem != (Object)null)
				{
					if (parent == -1)
					{
						Mod.SetKinematicRecursive(((Component)physicalItem).transform, value: false);
					}
					if ((Object)(object)physicalItem.integratedLaser != (Object)null)
					{
						physicalItem.integratedLaser.UsesAutoOnOff = physicalItem.usesAutoToggle;
					}
				}
			}
			else if (base.controller == GameManager.ID && (Object)(object)physicalItem != (Object)null)
			{
				physicalItem.EnsureUncontrolled();
				Mod.SetKinematicRecursive(((Component)physicalItem).transform, value: true);
				if ((Object)(object)physicalItem.integratedLaser != (Object)null)
				{
					physicalItem.integratedLaser.UsesAutoOnOff = false;
				}
			}
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
			if (data == null || data.Length == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(data.Length);
				packet.Write(data);
			}
			packet.Write(underActiveControl);
			if (full)
			{
				packet.Write(itemID);
				if (identifyingData == null || identifyingData.Length == 0)
				{
					packet.Write(0);
				}
				else
				{
					packet.Write(identifyingData.Length);
					packet.Write(identifyingData);
				}
				if (additionalData == null || additionalData.Length == 0)
				{
					packet.Write(0);
					return;
				}
				packet.Write(additionalData.Length);
				packet.Write(additionalData);
			}
		}

		public override void ParentChanged()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (physicalItem.updateParentFunc != null)
			{
				physicalItem.updateParentFunc();
			}
			if (parent != -1)
			{
				((Component)physicalItem).transform.localPosition = position;
				((Component)physicalItem).transform.localRotation = rotation;
			}
		}
	}
	public class TrackedNode : TrackedObject
	{
		public Construct_Node physicalNode;

		public TrackedNodeData nodeData;

		public static List<uint> unknownInit = new List<uint>();

		public override void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			base.Awake();
			GameObject val = new GameObject();
			TrackedObjectReference trackedObjectReference = val.AddComponent<TrackedObjectReference>();
			val.SetActive(false);
			CheckReferenceSize();
			int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
			TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
			TrackedObject.trackedReferences[num] = this;
			((Object)val).name = num.ToString();
			trackedObjectReference.refIndex = num;
			((Component)this).GetComponent<Construct_Node>().Stems.Add(val.transform);
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			if (data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.GiveObjectControl(data.trackedID, GameManager.ID, null);
				}
				else
				{
					ClientSend.GiveObjectControl(data.trackedID, GameManager.ID, null);
				}
				data.controller = GameManager.ID;
				data.localTrackedID = GameManager.objects.Count;
				GameManager.objects.Add(data);
			}
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedNodeByNode.Remove(physicalNode);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)physicalNode);
				base.OnDestroy();
			}
		}
	}
	public class TrackedNodeData : TrackedObjectData
	{
		public TrackedNode physicalNode;

		public Vector3 previousPos;

		public Vector3 position;

		public Quaternion previousRot;

		public Quaternion rotation;

		public bool underActiveControl;

		public bool previousActiveControl;

		public List<Vector3> points;

		public List<Vector3> ups;

		public TrackedNodeData()
		{
		}

		public TrackedNodeData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			points = new List<Vector3>();
			int num = packet.ReadByte();
			for (int i = 0; i < num; i++)
			{
				points.Add(packet.ReadVector3());
			}
			ups = new List<Vector3>();
			int num2 = packet.ReadByte();
			for (int j = 0; j < num2; j++)
			{
				ups.Add(packet.ReadVector3());
			}
			underActiveControl = packet.ReadBool();
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<Construct_Node>() != (Object)null;
		}

		public override bool IsControlled(out int interactionID)
		{
			interactionID = -1;
			return (Object)(object)((FVRInteractiveObject)physicalNode.physicalNode).m_hand != (Object)null;
		}

		private static TrackedNode MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedNode trackedNode = ((Component)root).gameObject.AddComponent<TrackedNode>();
			TrackedNodeData trackedNodeData = (TrackedNodeData)(trackedNode.data = (trackedNode.nodeData = new TrackedNodeData()));
			trackedNodeData.physicalNode = trackedNode;
			trackedNodeData.physical = trackedNode;
			Construct_Node component = ((Component)root).GetComponent<Construct_Node>();
			trackedNodeData.physicalNode.physicalNode = component;
			trackedNodeData.physical.physical = (MonoBehaviour)(object)component;
			trackedNodeData.typeIdentifier = "TrackedNodeData";
			trackedNodeData.active = ((Component)trackedNode).gameObject.activeInHierarchy;
			trackedNodeData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedNodeData.instance = GameManager.instance;
			trackedNodeData.controller = GameManager.ID;
			trackedNodeData.initTracker = GameManager.ID;
			trackedNodeData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedNodeByNode.Add(trackedNode.physicalNode, trackedNode);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedNode.physicalNode, trackedNode);
			GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)trackedNode.physicalNode, trackedNode);
			trackedNodeData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedNodeData);
			if (trackedNode.awoken)
			{
				trackedNode.data.Update(full: true);
			}
			Mod.LogInfo("Made node " + ((Object)trackedNode).name + " tracked", debug: false);
			return trackedNode;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			if (full)
			{
				if (points == null || points.Count == 0)
				{
					packet.Write((byte)0);
				}
				else
				{
					packet.Write((byte)points.Count);
					for (int i = 0; i < points.Count; i++)
					{
						packet.Write(points[i]);
					}
				}
				if (ups == null || ups.Count == 0)
				{
					packet.Write((byte)0);
				}
				else
				{
					packet.Write((byte)ups.Count);
					for (int j = 0; j < ups.Count; j++)
					{
						packet.Write(ups[j]);
					}
				}
			}
			packet.Write(underActiveControl);
			packet.Write(position);
			packet.Write(rotation);
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating node at " + trackedID, debug: false);
			Construct_Node_Volume nodeVolume = Object.FindObjectOfType<Construct_Node_Volume>();
			if ((Object)(object)nodeVolume == (Object)null)
			{
				Mod.LogError("Failed to instantiate node: " + trackedID + ": Could not find suitable node path to get prefab from");
				yield break;
			}
			GameObject prefab = nodeVolume.Node_Prefab;
			Mod.skipAllInstantiates++;
			GameObject nodeInstance = Object.Instantiate<GameObject>(prefab, position, rotation);
			Mod.skipAllInstantiates--;
			physicalNode = nodeInstance.AddComponent<TrackedNode>();
			physical = physicalNode;
			physicalNode.physicalNode = nodeInstance.GetComponent<Construct_Node>();
			physical.physical = (MonoBehaviour)(object)physicalNode.physicalNode;
			awaitingInstantiation = false;
			physicalNode.nodeData = this;
			physicalNode.data = this;
			GameManager.trackedNodeByNode.Add(physicalNode.physicalNode, physicalNode);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalNode.physicalNode, physicalNode);
			GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)physicalNode.physicalNode, physicalNode);
			UpdateFromData(this, full: true);
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedNodeData trackedNodeData = updatedObject as TrackedNodeData;
			if (full)
			{
				points = trackedNodeData.points;
				ups = trackedNodeData.ups;
			}
			previousActiveControl = underActiveControl;
			underActiveControl = trackedNodeData.underActiveControl;
			previousPos = position;
			position = trackedNodeData.position;
			previousRot = rotation;
			rotation = trackedNodeData.rotation;
			if ((Object)(object)physicalNode != (Object)null)
			{
				((Component)physicalNode.physicalNode).transform.position = position;
				((Component)physicalNode.physicalNode).transform.rotation = rotation;
				if (full)
				{
					physicalNode.physicalNode.initialPos = position;
					physicalNode.physicalNode.m_center = position;
					physicalNode.physicalNode.UpdateCageStems();
				}
			}
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			if (full)
			{
				points = new List<Vector3>();
				int num = packet.ReadByte();
				for (int i = 0; i < num; i++)
				{
					points.Add(packet.ReadVector3());
				}
				ups = new List<Vector3>();
				int num2 = packet.ReadByte();
				for (int j = 0; j < num2; j++)
				{
					ups.Add(packet.ReadVector3());
				}
			}
			previousActiveControl = underActiveControl;
			underActiveControl = packet.ReadBool();
			previousPos = position;
			position = packet.ReadVector3();
			previousRot = rotation;
			rotation = packet.ReadQuaternion();
			if ((Object)(object)physicalNode != (Object)null)
			{
				((Component)physicalNode.physicalNode).transform.position = position;
				((Component)physicalNode.physicalNode).transform.rotation = rotation;
				if (full)
				{
					physicalNode.physicalNode.initialPos = position;
					physicalNode.physicalNode.m_center = position;
					physicalNode.physicalNode.UpdateCageStems();
				}
			}
		}

		public override bool Update(bool full = false)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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)
			bool flag = base.Update(full);
			if ((Object)(object)physicalNode == (Object)null)
			{
				return false;
			}
			if (full)
			{
				points = physicalNode.physicalNode.Points;
				ups = physicalNode.physicalNode.Ups;
			}
			previousActiveControl = underActiveControl;
			underActiveControl = IsControlled(out var _);
			previousPos = position;
			previousRot = rotation;
			position = ((Component)physicalNode.physicalNode).transform.position;
			rotation = ((Component)physicalNode.physicalNode).transform.rotation;
			int result;
			if (!flag)
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					if (((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2))
					{
						result = ((previousActiveControl != underActiveControl) ? 1 : 0);
						goto IL_0111;
					}
				}
			}
			result = 1;
			goto IL_0111;
			IL_0111:
			return (byte)result != 0;
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			base.OnTrackedIDReceived(newData);
			if (localTrackedID != -1 && TrackedNode.unknownInit.Contains(localWaitingIndex))
			{
				ClientSend.NodeInit(trackedID, physicalNode.physicalNode.Points, physicalNode.physicalNode.Ups);
				TrackedNode.unknownInit.Remove(localWaitingIndex);
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalNode != (Object)null && (Object)(object)physicalNode.physicalNode != (Object)null)
			{
				GameManager.trackedNodeByNode.Remove(physicalNode.physicalNode);
				GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)physicalNode.physicalNode);
			}
		}
	}
	public abstract class TrackedObject : MonoBehaviour
	{
		public TrackedObjectData data;

		public MonoBehaviour physical;

		public static List<uint> unknownDestroyTrackedIDs = new List<uint>();

		public static Dictionary<uint, int> unknownControlTrackedIDs = new Dictionary<uint, int>();

		public static Dictionary<uint, KeyValuePair<uint, bool>> unknownTrackedIDs = new Dictionary<uint, KeyValuePair<uint, bool>>();

		public static Dictionary<uint, List<uint>> unknownParentWaitList = new Dictionary<uint, List<uint>>();

		public static Dictionary<uint, List<int>> unknownParentTrackedIDs = new Dictionary<uint, List<int>>();

		public static Dictionary<uint, string> unknownSceneChange = new Dictionary<uint, string>();

		public static Dictionary<uint, int> unknownInstanceChange = new Dictionary<uint, int>();

		public static GameObject[] trackedReferenceObjects = (GameObject[])(object)new GameObject[100];

		public static TrackedObject[] trackedReferences = new TrackedObject[100];

		public static List<int> availableTrackedRefIndices = new List<int>
		{
			1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
			11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
			21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
			31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
			41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
			51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
			61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
			71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
			81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
			91, 92, 93, 94, 95, 96, 97, 98, 99
		};

		public bool awoken;

		public bool sendOnAwake;

		public bool sendDestroy = true;

		public bool skipDestroyProcessing;

		public bool skipFullDestroy;

		public bool dontGiveControl;

		public virtual void Awake()
		{
			if (data != null)
			{
				data.Update(full: true);
			}
			awoken = true;
			if (sendOnAwake)
			{
				Mod.LogInfo(((Object)((Component)this).gameObject).name + " awoken");
				if (ThreadManager.host)
				{
					Server.AddTrackedObject(data, 0);
					return;
				}
				data.localWaitingIndex = Client.localObjectCounter++;
				Client.waitingLocalObjects.Add(data.localWaitingIndex, data);
				ClientSend.TrackedObject(data);
			}
		}

		public void CheckReferenceSize()
		{
			if (availableTrackedRefIndices.Count == 0)
			{
				GameObject[] array = trackedReferenceObjects;
				trackedReferenceObjects = (GameObject[])(object)new GameObject[array.Length + 100];
				for (int i = 0; i < array.Length; i++)
				{
					trackedReferenceObjects[i] = array[i];
				}
				TrackedObject[] array2 = trackedReferences;
				trackedReferences = new TrackedObject[array2.Length + 100];
				for (int j = 0; j < array2.Length; j++)
				{
					trackedReferences[j] = array2[j];
				}
				for (int k = array2.Length; k < trackedReferences.Length; k++)
				{
					availableTrackedRefIndices.Add(k);
				}
			}
		}

		public virtual void OnTransformParentChanged()
		{
			if (data.ignoreParentChanged > 0)
			{
				return;
			}
			Transform parent = ((Component)this).transform.parent;
			TrackedObject trackedObject = null;
			while ((Object)(object)parent != (Object)null)
			{
				trackedObject = ((Component)parent).GetComponent<TrackedObject>();
				if ((Object)(object)trackedObject != (Object)null)
				{
					break;
				}
				parent = parent.parent;
			}
			if ((Object)(object)trackedObject != (Object)null)
			{
				bool flag = trackedObject.data.trackedID > -1;
				if (data.trackedID == -1)
				{
					KeyValuePair<uint, bool> value = new KeyValuePair<uint, bool>(flag ? ((uint)trackedObject.data.trackedID) : trackedObject.data.localWaitingIndex, flag);
					if (unknownTrackedIDs.ContainsKey(data.localWaitingIndex))
					{
						unknownTrackedIDs[data.localWaitingIndex] = value;
					}
					else
					{
						unknownTrackedIDs.Add(data.localWaitingIndex, value);
					}
					if (!flag)
					{
						if (unknownParentWaitList.TryGetValue(trackedObject.data.localWaitingIndex, out var value2))
						{
							value2.Add(data.localWaitingIndex);
							return;
						}
						unknownParentWaitList.Add(trackedObject.data.localWaitingIndex, new List<uint> { data.localWaitingIndex });
					}
				}
				else if (flag)
				{
					if (trackedObject.data.trackedID == data.parent)
					{
						return;
					}
					if (data.controller == GameManager.ID)
					{
						if (ThreadManager.host)
						{
							ServerSend.ObjectParent(data.trackedID, trackedObject.data.trackedID);
						}
						else
						{
							ClientSend.ObjectParent(data.trackedID, trackedObject.data.trackedID);
						}
						data.Update();
						if (ThreadManager.host)
						{
							ServerSend.ObjectUpdate(data);
						}
						else
						{
							ClientSend.ObjectUpdate(data);
						}
					}
					data.SetParent(trackedObject.data, physicallyParent: false);
				}
				else if (data.controller == GameManager.ID)
				{
					if (unknownParentTrackedIDs.ContainsKey(trackedObject.data.localWaitingIndex))
					{
						unknownParentTrackedIDs[trackedObject.data.localWaitingIndex].Add(data.trackedID);
						return;
					}
					unknownParentTrackedIDs.Add(trackedObject.data.localWaitingIndex, new List<int> { data.trackedID });
				}
			}
			else
			{
				if (data.parent == -1)
				{
					return;
				}
				if (data.trackedID == -1)
				{
					if (data.controller == GameManager.ID)
					{
						if (unknownTrackedIDs.TryGetValue(data.localWaitingIndex, out var value3) && !value3.Value && unknownParentWaitList.TryGetValue(value3.Key, out var value4))
						{
							value4.Remove(data.localWaitingIndex);
						}
						unknownTrackedIDs.Remove(data.localWaitingIndex);
					}
					return;
				}
				if (data.controller == GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.ObjectParent(data.trackedID, -1);
					}
					else
					{
						ClientSend.ObjectParent(data.trackedID, -1);
					}
				}
				data.SetParent(null, physicallyParent: false);
			}
		}

		protected virtual void OnDestroy()
		{
			Mod.LogInfo("OnDestroy for object at " + data.trackedID + " with local waiting index: " + data.localWaitingIndex, debug: false);
			if (skipFullDestroy)
			{
				return;
			}
			GameManager.trackedObjectByObject.Remove(physical);
			bool removeFromLocal = true;
			if (!skipDestroyProcessing)
			{
				if (GameManager.giveControlOfDestroyed == 0 || dontGiveControl)
				{
					Mod.LogInfo("\tNot giving control", debug: false);
					DestroyGlobally(ref removeFromLocal);
				}
				else
				{
					Mod.LogInfo("\tGiving control if we control", debug: false);
					if (data.controller == GameManager.ID)
					{
						Mod.LogInfo("\t\tWe control", debug: false);
						int bestPotentialObjectHost = Mod.GetBestPotentialObjectHost(data.controller, forUs: true, hasWhiteList: true, GameManager.playersAtLoadStart);
						if (bestPotentialObjectHost == -1)
						{
							Mod.LogInfo("\t\t\tNo potential host, destroying globally", debug: false);
							DestroyGlobally(ref removeFromLocal);
						}
						else
						{
							Mod.LogInfo("\t\t\tPotential host: " + bestPotentialObjectHost, debug: false);
							if (data.trackedID > -1)
							{
								Mod.LogInfo("\t\t\t\tGot trackedID, giving control", debug: false);
								if (ThreadManager.host)
								{
									ServerSend.GiveObjectControl(data.trackedID, bestPotentialObjectHost, new List<int> { GameManager.ID });
								}
								else
								{
									ClientSend.GiveObjectControl(data.trackedID, bestPotentialObjectHost, new List<int> { GameManager.ID });
								}
								data.SetController(bestPotentialObjectHost);
							}
							else
							{
								Mod.LogInfo("\t\t\t\tNo trackedID, adding to unknown", debug: false);
								removeFromLocal = false;
								if (unknownControlTrackedIDs.TryGetValue(data.localWaitingIndex, out var value))
								{
									if (value != bestPotentialObjectHost)
									{
										unknownControlTrackedIDs[data.localWaitingIndex] = bestPotentialObjectHost;
									}
								}
								else
								{
									unknownControlTrackedIDs.Add(data.localWaitingIndex, bestPotentialObjectHost);
								}
							}
						}
					}
				}
			}
			if (data.localTrackedID != -1 && removeFromLocal)
			{
				data.RemoveFromLocal();
			}
			data.removeFromListOnDestroy = true;
			sendDestroy = true;
			skipDestroyProcessing = false;
		}

		private void DestroyGlobally(ref bool removeFromLocal)
		{
			Mod.LogInfo("DestroyGlobally for object at " + data.trackedID + " with local waiting index: " + data.localWaitingIndex, debug: false);
			if (data.trackedID > -1)
			{
				Mod.LogInfo("\tGot tracked ID", debug: false);
				if (sendDestroy)
				{
					Mod.LogInfo("\t\tSending destroy", debug: false);
					if (ThreadManager.host)
					{
						ServerSend.DestroyObject(data.trackedID, data.removeFromListOnDestroy);
					}
					else
					{
						ClientSend.DestroyObject(data.trackedID, data.removeFromListOnDestroy);
					}
				}
				if (data.removeFromListOnDestroy)
				{
					Mod.LogInfo("\t\tRemoving from lists", debug: false);
					data.RemoveFromLists();
				}
			}
			else
			{
				Mod.LogInfo("\tNo tracked ID, adding to unknown", debug: false);
				removeFromLocal = false;
				if (!unknownDestroyTrackedIDs.Contains(data.localWaitingIndex))
				{
					unknownDestroyTrackedIDs.Add(data.localWaitingIndex);
				}
			}
		}

		public virtual void SecondaryDestroy()
		{
		}

		public virtual void BeginInteraction(FVRViveHand hand)
		{
		}

		public virtual void EndInteraction(FVRViveHand hand)
		{
		}

		public virtual void EnsureUncontrolled()
		{
		}

		public virtual bool HandleShatter(UberShatterable shatterable, Vector3 point, Vector3 dir, float intensity, bool received, int clientID, byte[] data)
		{
			return true;
		}
	}
	public abstract class TrackedObjectData
	{
		public delegate void OnBringRequestDelegate(TrackedObjectData trackedObjectData, bool scene, ref ObjectBringType bring);

		public enum ObjectBringType
		{
			No,
			OnlyInteracted,
			Yes
		}

		public TrackedObject physical;

		public string typeIdentifier;

		public bool latestUpdateSent = false;

		public byte order;

		public int trackedID = -1;

		public int localTrackedID = -1;

		public uint localWaitingIndex = uint.MaxValue;

		public int initTracker;

		private int _controller = 0;

		public string scene;

		public int instance;

		public bool sceneInit;

		public bool awaitingInstantiation;

		public int parent = -1;

		public List<TrackedObjectData> children;

		public List<int> childrenToParent = new List<int>();

		public int childIndex = -1;

		public int ignoreParentChanged;

		public bool removeFromListOnDestroy = true;

		public bool active;

		private bool previousActive;

		public int controller
		{
			get
			{
				return _controller;
			}
			set
			{
				if (_controller != value)
				{
					OnControlChanged(value);
				}
				_controller = value;
			}
		}

		public static event OnBringRequestDelegate OnBringRequest;

		public TrackedObjectData()
		{
		}

		public TrackedObjectData(Packet packet, string typeID, int trackedID)
		{
			typeIdentifier = typeID;
			initTracker = packet.ReadInt();
			controller = packet.ReadInt();
			parent = packet.ReadInt();
			localTrackedID = packet.ReadInt();
			scene = packet.ReadString();
			instance = packet.ReadInt();
			sceneInit = packet.ReadBool();
			localWaitingIndex = packet.ReadUInt();
			this.trackedID = trackedID;
			active = packet.ReadBool();
		}

		public abstract IEnumerator Instantiate();

		public virtual void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			if (full)
			{
				packet.Write(trackedID);
				packet.Write(typeIdentifier);
				packet.Write(initTracker);
				packet.Write(controller);
				packet.Write(parent);
				packet.Write(localTrackedID);
				packet.Write(scene);
				packet.Write(instance);
				packet.Write(sceneInit);
				packet.Write(localWaitingIndex);
			}
			else
			{
				if (incrementOrder)
				{
					packet.Write(order++);
				}
				else
				{
					packet.Write(order);
				}
				packet.Write(trackedID);
			}
			packet.Write(active);
		}

		public static void Update(Packet packet, bool includesLength = true, bool full = false)
		{
			byte b = packet.ReadByte();
			int num = packet.ReadInt();
			if (num < 0)
			{
				if (num == -2)
				{
					Mod.LogWarning("Got update packet for object with trackedID -2");
				}
				return;
			}
			TrackedObjectData trackedObjectData = null;
			if (ThreadManager.host)
			{
				if (Server.objects.Length < num)
				{
					Mod.LogError("Server got update for object at " + num + " which is out of range of objects array");
					return;
				}
				trackedObjectData = Server.objects[num];
			}
			else
			{
				if (Client.objects.Length < num)
				{
					return;
				}
				trackedObjectData = Client.objects[num];
			}
			if (trackedObjectData != null && trackedObjectData.controller != GameManager.ID && (full || b > trackedObjectData.order || trackedObjectData.order - b > 128))
			{
				trackedObjectData.order = b;
				trackedObjectData.UpdateFromPacket(packet, full);
			}
		}

		public virtual void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			if (full)
			{
				controller = updatedObject.controller;
				parent = updatedObject.parent;
				scene = updatedObject.scene;
				instance = updatedObject.instance;
				localWaitingIndex = updatedObject.localWaitingIndex;
			}
			previousActive = active;
			active = updatedObject.active;
			order = updatedObject.order;
			if (!((Object)(object)physical != (Object)null))
			{
				return;
			}
			if (active)
			{
				if (!((Component)physical).gameObject.activeSelf)
				{
					((Component)physical).gameObject.SetActive(true);
				}
			}
			else if (((Component)physical).gameObject.activeSelf)
			{
				((Component)physical).gameObject.SetActive(false);
			}
		}

		public virtual void UpdateFromPacket(Packet packet, bool full = false)
		{
			if (full)
			{
				packet.ReadString();
				packet.readPos += 4;
				controller = packet.ReadInt();
				parent = packet.ReadInt();
				packet.readPos += 4;
				scene = packet.ReadString();
				instance = packet.ReadInt();
				packet.readPos++;
				localWaitingIndex = packet.ReadUInt();
			}
			previousActive = active;
			active = packet.ReadBool();
			if (!((Object)(object)physical != (Object)null))
			{
				return;
			}
			if (active)
			{
				if (!((Component)physical).gameObject.activeSelf)
				{
					((Component)physical).gameObject.SetActive(true);
				}
			}
			else if (((Component)physical).gameObject.activeSelf)
			{
				((Component)physical).gameObject.SetActive(false);
			}
		}

		public virtual bool Update(bool full = false)
		{
			if ((Object)(object)physical == (Object)null)
			{
				return false;
			}
			previousActive = active;
			active = ((Component)physical).gameObject.activeInHierarchy;
			return previousActive != active;
		}

		public virtual bool NeedsUpdate()
		{
			return previousActive != active;
		}

		public virtual bool IsIdentifiable()
		{
			return true;
		}

		public virtual bool IsControlled(out int interactionID)
		{
			interactionID = -1;
			return false;
		}

		public virtual void OnControlChanged(int newController)
		{
			latestUpdateSent = false;
		}

		public virtual void OnTrackedIDReceived(TrackedObjectData newData)
		{
			Mod.LogInfo("Received trackedID " + trackedID + " for object with local waiting index: " + localWaitingIndex, debug: false);
			if (TrackedObject.unknownDestroyTrackedIDs.Contains(localWaitingIndex))
			{
				ClientSend.DestroyObject(trackedID);
				Mod.LogInfo("\tDestroying from unknown", debug: false);
				Client.objects[trackedID] = null;
				GameManager.objectsByInstanceByScene[scene][instance].Remove(trackedID);
				RemoveFromLocal();
			}
			if (localTrackedID != -1 && TrackedObject.unknownControlTrackedIDs.ContainsKey(localWaitingIndex))
			{
				int newController = TrackedObject.unknownControlTrackedIDs[localWaitingIndex];
				ClientSend.GiveObjectControl(trackedID, newController, null);
				SetController(newController, recursive: true);
				TrackedObject.unknownControlTrackedIDs.Remove(localWaitingIndex);
				if (GameManager.ID != controller)
				{
					RemoveFromLocal();
				}
			}
			if (localTrackedID != -1 && TrackedObject.unknownTrackedIDs.ContainsKey(localWaitingIndex))
			{
				KeyValuePair<uint, bool> keyValuePair = TrackedObject.unknownTrackedIDs[localWaitingIndex];
				if (keyValuePair.Value)
				{
					TrackedObjectData trackedObjectData = null;
					trackedObjectData = ((!ThreadManager.host) ? Client.objects[keyValuePair.Key] : Server.objects[keyValuePair.Key]);
					if (trackedObjectData != null && trackedObjectData.trackedID != parent)
					{
						if (ThreadManager.host)
						{
							ServerSend.ObjectParent(trackedID, trackedObjectData.trackedID);
						}
						else
						{
							ClientSend.ObjectParent(trackedID, trackedObjectData.trackedID);
						}
						SetParent(trackedObjectData, physicallyParent: false);
					}
				}
				else if (keyValuePair.Key == uint.MaxValue)
				{
					if (ThreadManager.host)
					{
						ServerSend.ObjectParent(trackedID, -1);
					}
					else
					{
						ClientSend.ObjectParent(trackedID, -1);
					}
					SetParent(null, physicallyParent: false);
				}
				else if (TrackedObject.unknownParentTrackedIDs.ContainsKey(keyValuePair.Key))
				{
					TrackedObject.unknownParentTrackedIDs[keyValuePair.Key].Add(trackedID);
				}
				else
				{
					TrackedObject.unknownParentTrackedIDs.Add(keyValuePair.Key, new List<int> { trackedID });
				}
				if (!keyValuePair.Value && TrackedObject.unknownParentWaitList.TryGetValue(keyValuePair.Key, out var value))
				{
					value.Remove(localWaitingIndex);
				}
				TrackedObject.unknownTrackedIDs.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedObject.unknownParentWaitList.ContainsKey(localWaitingIndex))
			{
				List<uint> list = TrackedObject.unknownParentWaitList[localWaitingIndex];
				foreach (uint item in list)
				{
					if (TrackedObject.unknownTrackedIDs.TryGetValue(item, out var _))
					{
						TrackedObject.unknownTrackedIDs[item] = new KeyValuePair<uint, bool>((uint)trackedID, value: true);
					}
				}
				TrackedObject.unknownParentWaitList.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedObject.unknownParentTrackedIDs.ContainsKey(localWaitingIndex))
			{
				List<int> list2 = TrackedObject.unknownParentTrackedIDs[localWaitingIndex];
				TrackedObjectData[] array = null;
				array = ((!ThreadManager.host) ? Client.objects : Server.objects);
				foreach (int item2 in list2)
				{
					if (array[item2] != null)
					{
						if (ThreadManager.host)
						{
							ServerSend.ObjectParent(array[item2].trackedID, trackedID);
						}
						else
						{
							ClientSend.ObjectParent(array[item2].trackedID, trackedID);
						}
						array[item2].SetParent(this, physicallyParent: false);
					}
				}
				TrackedObject.unknownParentTrackedIDs.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedObject.unknownSceneChange.TryGetValue(localWaitingIndex, out var value3))
			{
				SetScene(value3, send: true);
				TrackedObject.unknownSceneChange.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedObject.unknownInstanceChange.TryGetValue(localWaitingIndex, out var value4))
			{
				SetInstance(value4, send: true);
				TrackedObject.unknownSceneChange.Remove(localWaitingIndex);
			}
		}

		public virtual void OnTracked()
		{
		}

		public virtual void RemoveFromLocal()
		{
			if (trackedID == -1)
			{
				if (TrackedObject.unknownTrackedIDs.TryGetValue(localWaitingIndex, out var value) && !value.Value && TrackedObject.unknownParentWaitList.TryGetValue(value.Key, out var value2))
				{
					value2.Remove(localWaitingIndex);
				}
				TrackedObject.unknownTrackedIDs.Remove(localWaitingIndex);
				TrackedObject.unknownParentTrackedIDs.Remove(localWaitingIndex);
				TrackedObject.unknownControlTrackedIDs.Remove(localWaitingIndex);
				TrackedObject.unknownDestroyTrackedIDs.Remove(localWaitingIndex);
				if ((Object)(object)physical != (Object)null && (Object)(object)physical.physical != (Object)null)
				{
					GameManager.trackedObjectByObject.Remove(physical.physical);
				}
			}
			if (localTrackedID > -1 && localTrackedID < GameManager.objects.Count)
			{
				GameManager.objects[localTrackedID] = GameManager.objects[GameManager.objects.Count - 1];
				GameManager.objects[localTrackedID].localTrackedID = localTrackedID;
				GameManager.objects.RemoveAt(GameManager.objects.Count - 1);
				localTrackedID = -1;
			}
			else
			{
				Mod.LogWarning("\tlocaltrackedID " + localTrackedID + " for object at " + trackedID + " out of range!:\n" + Environment.StackTrace);
			}
		}

		public void SetController(int newController, bool recursive = false)
		{
			if (recursive)
			{
				SetControllerRecursive(this, newController);
			}
			else
			{
				controller = newController;
			}
		}

		private void SetControllerRecursive(TrackedObjectData otherTrackedObject, int newController)
		{
			otherTrackedObject.controller = newController;
			if (otherTrackedObject.children == null)
			{
				return;
			}
			foreach (TrackedObjectData child in otherTrackedObject.children)
			{
				SetControllerRecursive(child, newController);
			}
		}

		public void TakeControlRecursive(TrackedObjectData trackedObject = null)
		{
			TrackedObjectData trackedObjectData = ((trackedObject == null) ? this : trackedObject);
			if (trackedObjectData.trackedID < 0)
			{
				return;
			}
			if (ThreadManager.host)
			{
				ServerSend.GiveObjectControl(trackedObjectData.trackedID, GameManager.ID, null);
			}
			else
			{
				ClientSend.GiveObjectControl(trackedObjectData.trackedID, GameManager.ID, null);
			}
			trackedObjectData.SetController(GameManager.ID);
			if (trackedObjectData.localTrackedID == -1)
			{
				trackedObjectData.localTrackedID = GameManager.objects.Count;
				GameManager.objects.Add(trackedObjectData);
			}
			if (trackedObjectData.children == null)
			{
				return;
			}
			foreach (TrackedItemData child in trackedObjectData.children)
			{
				TakeControlRecursive(child);
			}
		}

		public void SetParent(int trackedID)
		{
			if (trackedID == -1)
			{
				SetParent(null, physicallyParent: true);
			}
			else if (ThreadManager.host)
			{
				SetParent(Server.objects[trackedID], physicallyParent: true);
			}
			else
			{
				SetParent(Client.objects[trackedID], physicallyParent: true);
			}
		}

		public void SetParent(TrackedObjectData newParent, bool physicallyParent)
		{
			if (newParent == null)
			{
				if (parent == -1)
				{
					return;
				}
				TrackedObjectData trackedObjectData = null;
				int num = -1;
				if (ThreadManager.host)
				{
					trackedObjectData = Server.objects[parent];
					num = 0;
				}
				else
				{
					trackedObjectData = Client.objects[parent];
					num = GameManager.ID;
				}
				trackedObjectData.children[childIndex] = trackedObjectData.children[trackedObjectData.children.Count - 1];
				trackedObjectData.children[childIndex].childIndex = childIndex;
				trackedObjectData.children.RemoveAt(trackedObjectData.children.Count - 1);
				if (trackedObjectData.children.Count == 0)
				{
					trackedObjectData.children = null;
				}
				parent = -1;
				childIndex = -1;
				if (physicallyParent && (Object)(object)physical != (Object)null)
				{
					ignoreParentChanged++;
					((Component)physical).transform.parent = null;
					ignoreParentChanged--;
					if (controller == num)
					{
						Mod.SetKinematicRecursive(((Component)physical).transform, value: false);
					}
					ParentChanged();
				}
				return;
			}
			if (parent != -1)
			{
				if (newParent.trackedID == parent)
				{
					return;
				}
				TrackedObjectData trackedObjectData2 = null;
				trackedObjectData2 = ((!ThreadManager.host) ? Client.objects[parent] : Server.objects[parent]);
				trackedObjectData2.children[childIndex] = trackedObjectData2.children[trackedObjectData2.children.Count - 1];
				trackedObjectData2.children[childIndex].childIndex = childIndex;
				trackedObjectData2.children.RemoveAt(trackedObjectData2.children.Count - 1);
				if (trackedObjectData2.children.Count == 0)
				{
					trackedObjectData2.children = null;
				}
			}
			parent = newParent.trackedID;
			if (newParent.children == null)
			{
				newParent.children = new List<TrackedObjectData>();
			}
			childIndex = newParent.children.Count;
			newParent.children.Add(this);
			if (physicallyParent && (Object)(object)physical != (Object)null)
			{
				if ((Object)(object)newParent.physical == (Object)null)
				{
					newParent.childrenToParent.Add(trackedID);
				}
				else
				{
					ignoreParentChanged++;
					((Component)physical).transform.parent = ((Component)newParent.physical).transform;
					ignoreParentChanged--;
					ParentChanged();
				}
			}
			int num2 = controller;
			SetController(newParent.controller, recursive: true);
			if (controller == GameManager.ID && num2 != controller)
			{
				localTrackedID = GameManager.objects.Count;
				GameManager.objects.Add(this);
			}
		}

		public virtual void ParentChanged()
		{
		}

		public virtual void RemoveFromLists()
		{
			Mod.LogInfo("Remove from lists called for object with trackedID: " + trackedID, debug: false);
			if (ThreadManager.host)
			{
				Mod.LogInfo("\tHost", debug: false);
				Server.objects[trackedID] = null;
				if (Server.connectedClients.Count > 0)
				{
					if (Server.availableIndexBufferWaitingFor.TryGetValue(trackedID, out var value))
					{
						for (int i = 0; i < Server.connectedClients.Count; i++)
						{
							if (!value.Contains(Server.connectedClients[i]))
							{
								value.Add(Server.connectedClients[i]);
							}
						}
					}
					else
					{
						Server.availableIndexBufferWaitingFor.Add(trackedID, new List<int>(Server.connectedClients));
					}
					for (int j = 0; j < Server.connectedClients.Count; j++)
					{
						if (Server.availableIndexBufferClients.TryGetValue(Server.connectedClients[j], out var value2))
						{
							value2.Add(trackedID);
							continue;
						}
						Server.availableIndexBufferClients.Add(Server.connectedClients[j], new List<int> { trackedID });
					}
					if (Server.IDsToConfirm.TryGetValue(trackedID, out var value3))
					{
						for (int k = 0; k < Server.connectedClients.Count; k++)
						{
							if (!value3.Contains(Server.connectedClients[k]))
							{
								value3.Add(Server.connectedClients[k]);
							}
						}
					}
					else
					{
						Server.IDsToConfirm.Add(trackedID, new List<int>(Server.connectedClients));
					}
					Mod.LogInfo("Added " + trackedID + " to ID buffer");
				}
				else
				{
					Server.availableObjectIndices.Add(trackedID);
				}
			}
			else
			{
				Mod.LogInfo("\tClient", debug: false);
				Client.objects[trackedID] = null;
			}
			GameManager.objectsByInstanceByScene[scene][instance].Remove(trackedID);
		}

		public void SetScene(string scene, bool send)
		{
			Mod.LogInfo("Setting scene of object at " + trackedID + " with local waiting index: " + localWaitingIndex + " from " + this.scene + " to " + scene);
			if (children != null)
			{
				for (int i = 0; i < children.Count; i++)
				{
					children[i].SetScene(scene, send);
				}
			}
			if (trackedID == -1)
			{
				Mod.LogInfo("\tNo tracked ID, adding to unknown");
				if (TrackedObject.unknownSceneChange.ContainsKey(localWaitingIndex))
				{
					TrackedObject.unknownSceneChange[localWaitingIndex] = scene;
				}
				else
				{
					TrackedObject.unknownSceneChange.Add(localWaitingIndex, scene);
				}
				return;
			}
			Mod.LogInfo("\tGot tracked ID");
			if (scene.Equals(this.scene))
			{
				return;
			}
			Mod.LogInfo("\t\tScenes different");
			if (GameManager.objectsByInstanceByScene.TryGetValue(this.scene, out var value))
			{
				if (value.TryGetValue(instance, out var value2))
				{
					value2.Remove(trackedID);
					if (value2.Count == 0)
					{
						value.Remove(instance);
					}
				}
				else
				{
					Mod.LogError("\t\t\tTracked object " + trackedID + " with local waiting index: " + localWaitingIndex + ": SetScene: from " + this.scene + " to " + scene + ", current instance " + instance + " missing from dict");
				}
				if (value.Count == 0)
				{
					GameManager.objectsByInstanceByScene.Remove(this.scene);
				}
			}
			else
			{
				Mod.LogError("\t\t\tTracked object " + trackedID + " with local waiting index: " + localWaitingIndex + ": SetScene: from " + this.scene + " to " + scene + ", current scene missing from dict");
			}
			if (GameManager.objectsByInstanceByScene.TryGetValue(scene, out var value3))
			{
				if (value3.TryGetValue(instance, out var value4))
				{
					value4.Add(trackedID);
				}
				else
				{
					value3.Add(instance, new List<int> { trackedID });
				}
			}
			else
			{
				Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
				dictionary.Add(instance, new List<int> { trackedID });
				GameManager.objectsByInstanceByScene.Add(scene, dictionary);
			}
			this.scene = scene;
			if (!scene.Equals(GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene))
			{
				if ((Object)(object)physical == (Object)null)
				{
					awaitingInstantiation = false;
				}
				else
				{
					removeFromListOnDestroy = false;
					physical.sendDestroy = false;
					physical.dontGiveControl = true;
					TrackedObject[] componentsInChildren = ((Component)physical).GetComponentsInChildren<TrackedObject>();
					for (int j = 0; j < componentsInChildren.Length; j++)
					{
						if ((Object)(object)componentsInChildren[j] != (Object)null)
						{
							componentsInChildren[j].sendDestroy = false;
							componentsInChildren[j].data.removeFromListOnDestroy = false;
							componentsInChildren[j].dontGiveControl = true;
						}
					}
					physical.SecondaryDestroy();
					Object.Destroy((Object)(object)((Component)physical).gameObject);
				}
			}
			else if (instance == GameManager.instance)
			{
				Mod.LogInfo("\t\tWe are/will be in scene/instance of object, instantiating");
				if ((Object)(object)physical == (Object)null && !awaitingInstantiation)
				{
					awaitingInstantiation = true;
					AnvilManager.Run(Instantiate());
				}
			}
			if (send)
			{
				Mod.LogInfo("\t\tSending new scene of " + trackedID);
				if (ThreadManager.host)
				{
					ServerSend.ObjectScene(this);
				}
				else
				{
					ClientSend.ObjectScene(this);
				}
			}
		}

		public void SetInstance(int instance, bool send)
		{
			Mod.LogInfo("Setting instance of object at " + trackedID + " with local waiting index: " + localWaitingIndex + " from " + this.instance + " to " + instance);
			if (children != null)
			{
				for (int i = 0; i < children.Count; i++)
				{
					children[i].SetInstance(instance, send);
				}
			}
			if (trackedID == -1)
			{
				Mod.LogInfo("\tNo tracked ID, adding to unknown");
				if (TrackedObject.unknownInstanceChange.ContainsKey(localWaitingIndex))
				{
					TrackedObject.unknownInstanceChange[localWaitingIndex] = instance;
				}
				else
				{
					TrackedObject.unknownInstanceChange.Add(localWaitingIndex, instance);
				}
				return;
			}
			Mod.LogInfo("\tGot tracked ID");
			if (instance == this.instance)
			{
				return;
			}
			Mod.LogInfo("\t\tScenes different");
			if (GameManager.objectsByInstanceByScene.TryGetValue(scene, out var value))
			{
				if (value.TryGetValue(this.instance, out var value2))
				{
					value2.Remove(trackedID);
					if (value2.Count == 0)
					{
						value.Remove(this.instance);
					}
				}
				else
				{
					Mod.LogError("\t\t\tTracked object " + trackedID + " with local waiting index: " + localWaitingIndex + ": SetInstance: from " + this.instance + " to " + instance + ", current instance missing from dict");
				}
				if (value.Count == 0)
				{
					GameManager.objectsByInstanceByScene.Remove(scene);
				}
			}
			else
			{
				Mod.LogError("\t\t\tTracked object " + trackedID + " with local waiting index: " + localWaitingIndex + ": SetInstance: from " + this.instance + " to " + instance + ", current scene " + scene + " missing from dict");
			}
			if (GameManager.objectsByInstanceByScene.TryGetValue(scene, out var value3))
			{
				if (value3.TryGetValue(instance, out var value4))
				{
					value4.Add(trackedID);
				}
				else
				{
					value3.Add(instance, new List<int> { trackedID });
				}
			}
			else
			{
				Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
				dictionary.Add(instance, new List<int> { trackedID });
				GameManager.objectsByInstanceByScene.Add(scene, dictionary);
			}
			this.instance = instance;
			if (instance != GameManager.instance)
			{
				if ((Object)(object)physical == (Object)null)
				{
					awaitingInstantiation = false;
				}
				else
				{
					removeFromListOnDestroy = false;
					physical.sendDestroy = false;
					physical.dontGiveControl = true;
					TrackedObject[] componentsInChildren = ((Component)physical).GetComponentsInChildren<TrackedObject>();
					for (int j = 0; j < componentsInChildren.Length; j++)
					{
						if ((Object)(object)componentsInChildren[j] != (Object)null)
						{
							componentsInChildren[j].sendDestroy = false;
							componentsInChildren[j].data.removeFromListOnDestroy = false;
							componentsInChildren[j].dontGiveControl = true;
						}
					}
					physical.SecondaryDestroy();
					Object.Destroy((Object)(object)((Component)physical).gameObject);
				}
			}
			else if (scene.Equals(GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene) && (Object)(object)physical == (Object)null && !awaitingInstantiation)
			{
				awaitingInstantiation = true;
				AnvilManager.Run(Instantiate());
			}
			if (send)
			{
				if (ThreadManager.host)
				{
					ServerSend.ObjectInstance(this);
				}
				else
				{
					ClientSend.ObjectInstance(this);
				}
			}
		}

		public virtual void ShouldBring(bool scene, ref ObjectBringType bring)
		{
			if (!scene && GameManager.instanceBringItems)
			{
				bring = ObjectBringType.Yes;
			}
			if (TrackedObjectData.OnBringRequest != null)
			{
				TrackedObjectData.OnBringRequest(this, scene, ref bring);
			}
		}
	}
	public class TrackedPlayerBody : TrackedObject
	{
		public TrackedPlayerBodyData playerBodyData;

		public PlayerBody physicalPlayerBody;

		public PlayerManager playerManager;

		public override void Awake()
		{
			base.Awake();
			GameManager.OnPlayerBodyInit += OnPlayerBodyInit;
			GameManager.OnInstanceJoined += OnInstanceJoined;
		}

		public virtual void Start()
		{
			physicalPlayerBody.handsToFollow = (Transform[])(object)new Transform[2];
			if (playerBodyData.controller == GameManager.ID)
			{
				if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
				{
					physicalPlayerBody.headToFollow = GM.CurrentPlayerBody.Head;
					physicalPlayerBody.handsToFollow[0] = GM.CurrentPlayerBody.LeftHand;
					physicalPlayerBody.handsToFollow[1] = GM.CurrentPlayerBody.RightHand;
					physicalPlayerBody.handScripts = (FVRViveHand[])(object)new FVRViveHand[2]
					{
						((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>(),
						((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>()
					};
					if (physicalPlayerBody.headDisplayMode != PlayerBody.HeadDisplayMode.Physical)
					{
						physicalPlayerBody.SetHeadVisible(visible: false);
					}
					physicalPlayerBody.SetCollidersEnabled(enabled: false);
					physicalPlayerBody.SetCanvasesEnabled(enabled: false);
					physicalPlayerBody.SetEntitiesRegistered(registered: false);
					physicalPlayerBody.Init();
				}
			}
			else
			{
				playerManager = GameManager.players[playerBodyData.controller];
				playerManager.playerBody = this;
				physicalPlayerBody.headToFollow = playerManager.head;
				physicalPlayerBody.handsToFollow[0] = playerManager.leftHand;
				physicalPlayerBody.handsToFollow[1] = playerManager.rightHand;
				if (physicalPlayerBody.headDisplayMode != PlayerBody.HeadDisplayMode.Physical)
				{
					physicalPlayerBody.SetHeadVisible(visible: true);
				}
				physicalPlayerBody.SetCollidersEnabled(enabled: true);
				physicalPlayerBody.SetEntitiesRegistered(registered: true);
				Init();
			}
		}

		private void Init()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			playerManager.SetIFF(playerManager.IFF);
			physicalPlayerBody.SetColor(GameManager.colors[playerManager.colorIndex]);
			if ((Object)(object)physicalPlayerBody.usernameLabel != (Object)null)
			{
				physicalPlayerBody.usernameLabel.text = playerManager.username;
			}
			UpdateHealthLabel();
			if (physicalPlayerBody.hitboxes == null)
			{
				return;
			}
			for (int i = 0; i < physicalPlayerBody.hitboxes.Length; i++)
			{
				if ((Object)(object)physicalPlayerBody.hitboxes[i] != (Object)null)
				{
					physicalPlayerBody.hitboxes[i].manager = playerManager;
				}
			}
		}

		public void UpdateHealthLabel()
		{
			if ((Object)(object)physicalPlayerBody.healthLabel != (Object)null)
			{
				physicalPlayerBody.healthLabel.text = (int)playerManager.health + "/" + playerManager.maxHealth;
			}
		}

		private void OnPlayerBodyInit(FVRPlayerBody playerBody)
		{
			if (playerBodyData.controller == GameManager.ID)
			{
				physicalPlayerBody.headToFollow = playerBody.Head;
				if (physicalPlayerBody.handsToFollow == null)
				{
					physicalPlayerBody.handsToFollow = (Transform[])(object)new Transform[2];
				}
				physicalPlayerBody.handsToFollow[0] = playerBody.LeftHand;
				physicalPlayerBody.handsToFollow[1] = playerBody.RightHand;
				physicalPlayerBody.handScripts = (FVRViveHand[])(object)new FVRViveHand[2]
				{
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>(),
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>()
				};
				if (physicalPlayerBody.headDisplayMode != PlayerBody.HeadDisplayMode.Physical)
				{
					physicalPlayerBody.SetHeadVisible(visible: false);
				}
				physicalPlayerBody.SetCollidersEnabled(enabled: false);
				physicalPlayerBody.SetCanvasesEnabled(enabled: false);
				physicalPlayerBody.SetEntitiesRegistered(registered: false);
				physicalPlayerBody.Init();
			}
			else if ((Object)(object)playerManager != (Object)null)
			{
				playerManager.SetIFF(playerManager.IFF);
			}
		}

		public virtual void Update()
		{
			if (!((Object)(object)physicalPlayerBody.headToFollow == (Object)null))
			{
				return;
			}
			if (playerBodyData.controller == GameManager.ID)
			{
				if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
				{
					physicalPlayerBody.headToFollow = GM.CurrentPlayerBody.Head;
					if (physicalPlayerBody.headDisplayMode != PlayerBody.HeadDisplayMode.Physical)
					{
						physicalPlayerBody.SetHeadVisible(visible: false);
					}
				}
			}
			else
			{
				physicalPlayerBody.headToFollow = GameManager.players[playerBodyData.controller].head;
				if (physicalPlayerBody.headDisplayMode != PlayerBody.HeadDisplayMode.Physical)
				{
					physicalPlayerBody.SetHeadVisible(visible: true);
				}
			}
		}

		protected virtual void OnInstanceJoined(int instance, int source)
		{
			if (data.controller == GameManager.ID)
			{
				data.SetInstance(instance, send: true);
			}
		}

		protected override void OnDestroy()
		{
			GameManager.OnPlayerBodyInit -= OnPlayerBodyInit;
			GameManager.OnInstanceJoined -= OnInstanceJoined;
			for (int i = 0; i < physicalPlayerBody.hitboxes.Length; i++)
			{
				GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalPlayerBody.hitboxes[i]);
			}
			base.OnDestroy();
		}
	}
	public class TrackedPlayerBodyData : TrackedObjectData
	{
		public TrackedPlayerBody physicalPlayerBody;

		public string playerPrefabID;

		public TrackedPlayerBodyData()
		{
		}

		public TrackedPlayerBodyData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			playerPrefabID = packet.ReadString();
		}

		public static bool IsOfType(Transform t)
		{
			PlayerBody component = ((Component)t).GetComponent<PlayerBody>();
			if ((Object)(object)component != (Object)null)
			{
				return component.playerPrefabID != null;
			}
			return false;
		}

		public override bool IsIdentifiable()
		{
			return true;
		}

		public static TrackedPlayerBody MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedPlayerBody trackedPlayerBody = ((Component)root).gameObject.AddComponent<TrackedPlayerBody>();
			TrackedPlayerBodyData trackedPlayerBodyData = (trackedPlayerBody.playerBodyData = (TrackedPlayerBodyData)(trackedPlayerBody.data = new TrackedPlayerBodyData()));
			trackedPlayerBodyData.physical = trackedPlayerBody;
			trackedPlayerBodyData.physicalPlayerBody = trackedPlayerBody;
			trackedPlayerBodyData.physicalPlayerBody.physicalPlayerBody = ((Component)root).GetComponent<PlayerBody>();
			trackedPlayerBodyData.physical.physical = (MonoBehaviour)(object)trackedPlayerBodyData.physicalPlayerBody.physicalPlayerBody;
			trackedPlayerBodyData.playerPrefabID = trackedPlayerBodyData.physicalPlayerBody.physicalPlayerBody.playerPrefabID;
			trackedPlayerBodyData.typeIdentifier = "TrackedPlayerBodyData";
			trackedPlayerBodyData.active = ((Component)trackedPlayerBody).gameObject.activeInHierarchy;
			trackedPlayerBodyData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedPlayerBodyData.instance = GameManager.instance;
			trackedPlayerBodyData.initTracker = GameManager.ID;
			trackedPlayerBodyData.controller = GameManager.ID;
			trackedPlayerBodyData.sceneInit = GameManager.InSceneInit();
			GameManager.currentTrackedPlayerBody = trackedPlayerBody;
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedPlayerBodyData.physicalPlayerBody.physicalPlayerBody, trackedPlayerBody);
			for (int i = 0; i < trackedPlayerBodyData.physicalPlayerBody.physicalPlayerBody.hitboxes.Length; i++)
			{
				GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)trackedPlayerBodyData.physicalPlayerBody.physicalPlayerBody.hitboxes[i], trackedPlayerBody);
			}
			trackedPlayerBodyData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedPlayerBodyData);
			return trackedPlayerBody;
		}

		public override IEnumerator Instantiate()
		{
			GameObject playerPrefab = null;
			if (GameManager.playerPrefabs.TryGetValue(playerPrefabID, out var prefabObject))
			{
				if (prefabObject == (Object)null)
				{
					if (IM.OD.TryGetValue(playerPrefabID, out var fvrObject))
					{
						yield return ((AnvilAsset)fvrObject).GetGameObjectAsync();
						playerPrefab = ((AnvilAsset)fvrObject).GetGameObject();
					}
					else
					{
						Mod.LogWarning($"Attempted to instantiate player body \"{playerPrefabID}\" sent from {base.controller} but failed to get prefab. Using H3MP default player body instead");
						playerPrefab = Mod.playerPrefab;
					}
				}
				else if (prefabObject is FVRObject)
				{
					FVRObject fvrObject2 = (FVRObject)(object)((prefabObject is FVRObject) ? prefabObject : null);
					yield return ((AnvilAsset)fvrObject2).GetGameObjectAsync();
					playerPrefab = ((AnvilAsset)fvrObject2).GetGameObject();
				}
				else if (prefabObject is GameObject)
				{
					playerPrefab = (GameObject)(object)((prefabObject is GameObject) ? prefabObject : null);
				}
			}
			if ((Object)(object)playerPrefab == (Object)null)
			{
				Mod.LogWarning($"Attempted to instantiate player body \"{playerPrefabID}\" sent from {base.controller} but failed to get prefab. Using H3MP default player body instead");
				playerPrefab = Mod.playerPrefab;
			}
			if (!awaitingInstantiation)
			{
				yield break;
			}
			try
			{
				Mod.skipAllInstantiates++;
				GameObject playerBodyObject = Object.Instantiate<GameObject>(playerPrefab);
				Mod.skipAllInstantiates--;
				awaitingInstantiation = false;
				physicalPlayerBody = playerBodyObject.AddComponent<TrackedPlayerBody>();
				physical = physicalPlayerBody;
				physicalPlayerBody.playerBodyData = this;
				physical.data = this;
				physicalPlayerBody.physicalPlayerBody = playerBodyObject.GetComponent<PlayerBody>();
				physical.physical = (MonoBehaviour)(object)physicalPlayerBody.physicalPlayerBody;
				GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalPlayerBody.physicalPlayerBody, physicalPlayerBody);
				int i = 0;
				while (i < physicalPlayerBody.physicalPlayerBody.hitboxes.Length)
				{
					GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)physicalPlayerBody.physicalPlayerBody.hitboxes[i], physicalPlayerBody);
					int num = i + 1;
					i = num;
				}
				UpdateFromData(this);
			}
			catch (Exception ex)
			{
				Mod.LogError("Error while trying to instantiate playerBody: " + playerPrefabID + ":\n" + ex.Message + "\n" + ex.StackTrace);
			}
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			base.WriteToPacket(packet, incrementOrder, full);
			if (full)
			{
				packet.Write(playerPrefabID);
			}
		}

		public override void OnControlChanged(int newController)
		{
			base.OnControlChanged(newController);
			if (newController == initTracker)
			{
				return;
			}
			if ((Object)(object)physical == (Object)null)
			{
				ServerSend.DestroyObject(trackedID);
				RemoveFromLocal();
				Server.objects[trackedID] = null;
				if (GameManager.objectsByInstanceByScene.TryGetValue(scene, out var value) && value.TryGetValue(instance, out var value2))
				{
					value2.Remove(trackedID);
				}
				awaitingInstantiation = false;
				if (Server.connectedClients.Count > 0)
				{
					if (Server.availableIndexBufferWaitingFor.TryGetValue(trackedID, out var value3))
					{
						for (int i = 0; i < Server.connectedClients.Count; i++)
						{
							if (!value3.Contains(Server.connectedClients[i]))
							{
								value3.Add(Server.connectedClients[i]);
							}
						}
					}
					else
					{
						Server.availableIndexBufferWaitingFor.Add(trackedID, new List<int>(Server.connectedClients));
					}
					for (int j = 0; j < Server.connectedClients.Count; j++)
					{
						if (Server.availableIndexBufferClients.TryGetValue(Server.connectedClients[j], out var value4))
						{
							value4.Add(trackedID);
							continue;
						}
						Server.availableIndexBufferClients.Add(Server.connectedClients[j], new List<int> { trackedID });
					}
					if (Server.IDsToConfirm.TryGetValue(trackedID, out var value5))
					{
						for (int k = 0; k < Server.connectedClients.Count; k++)
						{
							if (!value5.Contains(Server.connectedClients[k]))
							{
								value5.Add(Server.connectedClients[k]);
							}
						}
					}
					else
					{
						Server.IDsToConfirm.Add(trackedID, new List<int>(Server.connectedClients));
					}
					Mod.LogInfo("Added " + trackedID + " to ID buffer");
				}
				else
				{
					Server.availableObjectIndices.Add(trackedID);
				}
			}
			else
			{
				Object.Destroy((Object)(object)((Component)physical).gameObject);
			}
		}

		public static bool IsControlled(Transform root)
		{
			return true;
		}

		public override bool IsControlled(out int interactionID)
		{
			interactionID = 1000;
			return base.controller == GameManager.ID;
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalPlayerBody != (Object)null && (Object)(object)physicalPlayerBody.physicalPlayerBody != (Object)null)
			{
				for (int i = 0; i < physicalPlayerBody.physicalPlayerBody.hitboxes.Length; i++)
				{
					GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalPlayerBody.physicalPlayerBody.hitboxes[i]);
				}
			}
		}
	}
	public class TrackedSentinel : TrackedObject
	{
		public Construct_Sentinel physicalSentinel;

		public TrackedSentinelData sentinelData;

		public static List<uint> unknownInit = new List<uint>();

		public override void Awake()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			base.Awake();
			GameObject val = new GameObject();
			TrackedObjectReference trackedObjectReference = val.AddComponent<TrackedObjectReference>();
			val.SetActive(false);
			CheckReferenceSize();
			int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
			TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
			TrackedObject.trackedReferenceObjects[num] = val;
			TrackedObject.trackedReferences[num] = this;
			((Object)val).name = num.ToString();
			trackedObjectReference.refIndex = num;
			physicalSentinel = ((Component)this).GetComponent<Construct_Sentinel>();
			physicalSentinel.PlatePoints.Add(val.transform);
		}

		public override bool HandleShatter(UberShatterable shatterable, Vector3 point, Vector3 dir, float intensity, bool received, int clientID, byte[] data)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			if (received)
			{
				UberShatterableShatterPatch.skip++;
				physicalSentinel.Plates[data[0]].Shatter(point, dir, intensity);
				UberShatterableShatterPatch.skip--;
				if (ThreadManager.host)
				{
					ServerSend.UberShatterableShatter(sentinelData.trackedID, point, dir, intensity, data, clientID);
				}
			}
			else
			{
				int num = -1;
				for (int i = 0; i < physicalSentinel.Plates.Count; i++)
				{
					if ((Object)(object)physicalSentinel.Plates[i] == (Object)(object)shatterable)
					{
						num = i;
						break;
					}
				}
				if (num > -1)
				{
					data = new byte[1] { (byte)num };
					if (ThreadManager.host)
					{
						ServerSend.UberShatterableShatter(sentinelData.trackedID, point, dir, intensity, data);
					}
					else if (sentinelData.trackedID != -1)
					{
						ClientSend.UberShatterableShatter(sentinelData.trackedID, point, dir, intensity, data);
					}
				}
				else
				{
					Mod.LogError("Sentinel HandleShatter, could not find shatterable in plates");
				}
			}
			return true;
		}

		protected override void OnDestroy()
		{
			if (!skipFullDestroy)
			{
				GameManager.trackedSentinelBySentinel.Remove(physicalSentinel);
				GameManager.trackedObjectByShatterable.Remove(((Component)physicalSentinel).GetComponentInChildren<UberShatterable>());
				for (int i = 0; i < physicalSentinel.Plates.Count; i++)
				{
					GameManager.trackedObjectByShatterable.Remove(physicalSentinel.Plates[i]);
				}
				base.OnDestroy();
			}
		}
	}
	public class TrackedSentinelData : TrackedObjectData
	{
		public TrackedSentinel physicalSentinel;

		public Vector3 previousPos;

		public Vector3 position;

		public Quaternion previousRot;

		public Quaternion rotation;

		public int currentPointIndex;

		public int targetPointIndex;

		public bool isMovingUpIndicies;

		public List<Vector3> patrolPoints;

		public TrackedSentinelData()
		{
		}

		public TrackedSentinelData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			patrolPoints = new List<Vector3>();
			int num = packet.ReadByte();
			for (int i = 0; i < num; i++)
			{
				patrolPoints.Add(packet.ReadVector3());
			}
			currentPointIndex = packet.ReadByte();
			targetPointIndex = packet.ReadByte();
			isMovingUpIndicies = packet.ReadBool();
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<Construct_Sentinel>() != (Object)null;
		}

		private static TrackedSentinel MakeTracked(Transform root, TrackedObjectData parent)
		{
			TrackedSentinel trackedSentinel = ((Component)root).gameObject.AddComponent<TrackedSentinel>();
			TrackedSentinelData trackedSentinelData = (TrackedSentinelData)(trackedSentinel.data = (trackedSentinel.sentinelData = new TrackedSentinelData()));
			trackedSentinelData.physicalSentinel = trackedSentinel;
			trackedSentinelData.physical = trackedSentinel;
			Construct_Sentinel component = ((Component)root).GetComponent<Construct_Sentinel>();
			trackedSentinelData.physicalSentinel.physicalSentinel = component;
			trackedSentinelData.physical.physical = (MonoBehaviour)(object)component;
			trackedSentinelData.typeIdentifier = "TrackedSentinelData";
			trackedSentinelData.active = ((Component)trackedSentinel).gameObject.activeInHierarchy;
			trackedSentinelData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedSentinelData.instance = GameManager.instance;
			trackedSentinelData.controller = GameManager.ID;
			trackedSentinelData.initTracker = GameManager.ID;
			trackedSentinelData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedSentinelBySentinel.Add(trackedSentinel.physicalSentinel, trackedSentinel);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)trackedSentinel.physicalSentinel, trackedSentinel);
			GameManager.trackedObjectByShatterable.Add(((Component)trackedSentinel.physicalSentinel).GetComponentInChildren<UberShatterable>(), trackedSentinel);
			for (int i = 0; i < trackedSentinel.physicalSentinel.Plates.Count; i++)
			{
				GameManager.trackedObjectByShatterable.Add(trackedSentinel.physicalSentinel.Plates[i], trackedSentinel);
			}
			trackedSentinelData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedSentinelData);
			if (trackedSentinel.awoken)
			{
				trackedSentinel.data.Update(full: true);
			}
			Mod.LogInfo("Made sentinel " + ((Object)trackedSentinel).name + " tracked", debug: false);
			return trackedSentinel;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
			if (!full)
			{
				return;
			}
			if (patrolPoints == null || patrolPoints.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)patrolPoints.Count);
				for (int i = 0; i < patrolPoints.Count; i++)
				{
					packet.Write(patrolPoints[i]);
				}
			}
			packet.Write((byte)currentPointIndex);
			packet.Write((byte)targetPointIndex);
			packet.Write(isMovingUpIndicies);
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating sentinel at " + trackedID, debug: false);
			Construct_Sentinel_Path sentinelVolume = Object.FindObjectOfType<Construct_Sentinel_Path>();
			if ((Object)(object)sentinelVolume == (Object)null)
			{
				Mod.LogError("Failed to instantiate sentinel: " + trackedID + ": Could not find suitable sentinel path to get prefab from");
				yield break;
			}
			GameObject prefab = sentinelVolume.SentinelPrefab;
			Mod.skipAllInstantiates++;
			GameObject sentinelInstance = Object.Instantiate<GameObject>(prefab, position, rotation);
			Mod.skipAllInstantiates--;
			physicalSentinel = sentinelInstance.AddComponent<TrackedSentinel>();
			physical = physicalSentinel;
			physicalSentinel.physicalSentinel = sentinelInstance.GetComponent<Construct_Sentinel>();
			physical.physical = (MonoBehaviour)(object)physicalSentinel.physicalSentinel;
			awaitingInstantiation = false;
			physicalSentinel.sentinelData = this;
			physicalSentinel.data = this;
			GameManager.trackedSentinelBySentinel.Add(physicalSentinel.physicalSentinel, physicalSentinel);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalSentinel.physicalSentinel, physicalSentinel);
			GameManager.trackedObjectByShatterable.Add(((Component)physicalSentinel.physicalSentinel).GetComponentInChildren<UberShatterable>(), physicalSentinel);
			int i = 0;
			while (i < physicalSentinel.physicalSentinel.Plates.Count)
			{
				GameManager.trackedObjectByShatterable.Add(physicalSentinel.physicalSentinel.Plates[i], physicalSentinel);
				int num = i + 1;
				i = num;
			}
			UpdateFromData(this, full: true);
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedSentinelData trackedSentinelData = updatedObject as TrackedSentinelData;
			previousPos = position;
			position = trackedSentinelData.position;
			previousRot = rotation;
			rotation = trackedSentinelData.rotation;
			if (full)
			{
				patrolPoints = trackedSentinelData.patrolPoints;
				currentPointIndex = trackedSentinelData.currentPointIndex;
				targetPointIndex = trackedSentinelData.targetPointIndex;
				isMovingUpIndicies = trackedSentinelData.isMovingUpIndicies;
			}
			if (!((Object)(object)physicalSentinel != (Object)null))
			{
				return;
			}
			((Component)physicalSentinel.physicalSentinel).transform.position = position;
			((Component)physicalSentinel.physicalSentinel).transform.rotation = rotation;
			if (!full)
			{
				return;
			}
			if (physicalSentinel.physicalSentinel.PatrolPoints == null)
			{
				physicalSentinel.physicalSentinel.PatrolPoints = new List<Transform>();
			}
			else
			{
				for (int i = 0; i < physicalSentinel.physicalSentinel.PatrolPoints.Count; i++)
				{
					Object.Destroy((Object)(object)((Component)physicalSentinel.physicalSentinel.PatrolPoints[i]).gameObject);
				}
				physicalSentinel.physicalSentinel.PatrolPoints.Clear();
			}
			for (int j = 0; j < patrolPoints.Count; j++)
			{
				GameObject val = new GameObject("Sentinel " + trackedID + " patrol point " + j);
				val.transform.position = patrolPoints[j];
				physicalSentinel.physicalSentinel.PatrolPoints.Add(val.transform);
			}
			physicalSentinel.physicalSentinel.curPointIndex = currentPointIndex;
			physicalSentinel.physicalSentinel.tarPointIndex = targetPointIndex;
			physicalSentinel.physicalSentinel.isMovingUpIndicies = isMovingUpIndicies;
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			previousPos = position;
			position = packet.ReadVector3();
			previousRot = rotation;
			rotation = packet.ReadQuaternion();
			if (full)
			{
				if (patrolPoints == null)
				{
					patrolPoints = new List<Vector3>();
				}
				else
				{
					patrolPoints.Clear();
				}
				int num = packet.ReadByte();
				for (int i = 0; i < num; i++)
				{
					patrolPoints.Add(packet.ReadVector3());
				}
				currentPointIndex = packet.ReadByte();
				targetPointIndex = packet.ReadByte();
				isMovingUpIndicies = packet.ReadBool();
			}
			if (!((Object)(object)physicalSentinel != (Object)null))
			{
				return;
			}
			((Component)physicalSentinel.physicalSentinel).transform.position = position;
			((Component)physicalSentinel.physicalSentinel).transform.rotation = rotation;
			if (!full)
			{
				return;
			}
			if (physicalSentinel.physicalSentinel.PatrolPoints == null)
			{
				physicalSentinel.physicalSentinel.PatrolPoints = new List<Transform>();
			}
			else
			{
				for (int j = 0; j < physicalSentinel.physicalSentinel.PatrolPoints.Count; j++)
				{
					Object.Destroy((Object)(object)((Component)physicalSentinel.physicalSentinel.PatrolPoints[j]).gameObject);
				}
				physicalSentinel.physicalSentinel.PatrolPoints.Clear();
			}
			for (int k = 0; k < patrolPoints.Count; k++)
			{
				GameObject val = new GameObject("Sentinel " + trackedID + " patrol point " + k);
				val.transform.position = patrolPoints[k];
				physicalSentinel.physicalSentinel.PatrolPoints.Add(val.transform);
			}
			physicalSentinel.physicalSentinel.curPointIndex = currentPointIndex;
			physicalSentinel.physicalSentinel.tarPointIndex = targetPointIndex;
			physicalSentinel.physicalSentinel.isMovingUpIndicies = isMovingUpIndicies;
		}

		public override bool Update(bool full = false)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			bool flag = base.Update(full);
			if ((Object)(object)physicalSentinel == (Object)null)
			{
				return false;
			}
			previousPos = position;
			previousRot = rotation;
			position = ((Component)physicalSentinel.physicalSentinel).transform.position;
			rotation = ((Component)physicalSentinel.physicalSentinel).transform.rotation;
			if (full)
			{
				if (patrolPoints == null)
				{
					patrolPoints = new List<Vector3>();
				}
				else
				{
					patrolPoints.Clear();
				}
				if (physicalSentinel.physicalSentinel.PatrolPoints != null)
				{
					for (int i = 0; i < physicalSentinel.physicalSentinel.PatrolPoints.Count; i++)
					{
						patrolPoints.Add(physicalSentinel.physicalSentinel.PatrolPoints[i].position);
					}
				}
				currentPointIndex = physicalSentinel.physicalSentinel.curPointIndex;
				targetPointIndex = physicalSentinel.physicalSentinel.tarPointIndex;
				isMovingUpIndicies = physicalSentinel.physicalSentinel.isMovingUpIndicies;
			}
			int result;
			if (!flag)
			{
				ref Vector3 reference = ref previousPos;
				object obj = position;
				if (((object)Unsafe.As<Vector3, Vector3>(ref reference)/*cast due to .constrained prefix*/).Equals(obj))
				{
					ref Quaternion reference2 = ref previousRot;
					object obj2 = rotation;
					result = ((!((object)Unsafe.As<Quaternion, Quaternion>(ref reference2)/*cast due to .constrained prefix*/).Equals(obj2)) ? 1 : 0);
					goto IL_0199;
				}
			}
			result = 1;
			goto IL_0199;
			IL_0199:
			return (byte)result != 0;
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			base.OnTrackedIDReceived(newData);
			if (localTrackedID != -1 && TrackedSentinel.unknownInit.Contains(localWaitingIndex))
			{
				ClientSend.SentinelInit(trackedID, patrolPoints, currentPointIndex, targetPointIndex, isMovingUpIndicies);
				TrackedSentinel.unknownInit.Remove(localWaitingIndex);
			}
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID == -1 && (Object)(object)physicalSentinel != (Object)null && (Object)(object)physicalSentinel.physicalSentinel != (Object)null)
			{
				GameManager.trackedSentinelBySentinel.Remove(physicalSentinel.physicalSentinel);
				GameManager.trackedObjectByShatterable.Remove(((Component)physicalSentinel.physicalSentinel).GetComponentInChildren<UberShatterable>());
				for (int i = 0; i < physicalSentinel.physicalSentinel.Plates.Count; i++)
				{
					GameManager.trackedObjectByShatterable.Remove(physicalSentinel.physicalSentinel.Plates[i]);
				}
			}
		}
	}
	public class TrackedSosig : TrackedObject
	{
		public static float interpolationSpeed = 12f;

		public Sosig physicalSosig;

		public TrackedSosigData sosigData;

		public static Dictionary<uint, List<KeyValuePair<int, KeyValuePair<TrackedItemData, int>>>> unknownItemInteract = new Dictionary<uint, List<KeyValuePair<int, KeyValuePair<TrackedItemData, int>>>>();

		public static Dictionary<uint, int> unknownSetIFFs = new Dictionary<uint, int>();

		public static Dictionary<uint, int> unknownSetOriginalIFFs = new Dictionary<uint, int>();

		public static Dictionary<uint, SosigBodyState> unknownBodyStates = new Dictionary<uint, SosigBodyState>();

		public static Dictionary<uint, int> unknownTNHKills = new Dictionary<uint, int>();

		public static Dictionary<uint, int> unknownIFFChart = new Dictionary<uint, int>();

		public static Dictionary<uint, SosigOrder> unknownCurrentOrder = new Dictionary<uint, SosigOrder>();

		public static Dictionary<uint, SosigConfigTemplate> unknownConfiguration = new Dictionary<uint, SosigConfigTemplate>();

		public static Dictionary<uint, Dictionary<string, List<int>>> unknownWearable = new Dictionary<uint, Dictionary<string, List<int>>>();

		public override void Awake()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			base.Awake();
			GameManager.OnInstanceJoined += OnInstanceJoined;
			GameObject val = new GameObject();
			TrackedObjectReference trackedObjectReference = val.AddComponent<TrackedObjectReference>();
			val.SetActive(false);
			CheckReferenceSize();
			int num = TrackedObject.availableTrackedRefIndices[TrackedObject.availableTrackedRefIndices.Count - 1];
			TrackedObject.availableTrackedRefIndices.RemoveAt(TrackedObject.availableTrackedRefIndices.Count - 1);
			TrackedObject.trackedReferenceObjects[num] = val;
			TrackedObject.trackedReferences[num] = this;
			((Object)val).name = num.ToString();
			trackedObjectReference.refIndex = num;
			physicalSosig = ((Component)this).GetComponent<Sosig>();
			GameObject[] buffSystems = physicalSosig.BuffSystems;
			physicalSosig.BuffSystems = (GameObject[])(object)new GameObject[buffSystems.Length + 1];
			for (int i = 0; i < buffSystems.Length; i++)
			{
				physicalSosig.BuffSystems[i] = buffSystems[i];
			}
			physicalSosig.BuffSystems[physicalSosig.BuffSystems.Length - 1] = val;
		}

		private void FixedUpdate()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)physicalSosig != (Object)null) || !((Object)(object)physicalSosig.CoreRB != (Object)null) || data.controller == GameManager.ID)
			{
				return;
			}
			_ = sosigData.position;
			_ = sosigData.rotation;
			if (true)
			{
				_ = sosigData.previousPos;
				if (((Vector3)(ref sosigData.velocity)).magnitude < 0.5f)
				{
					Vector3 position = Vector3.Lerp(physicalSosig.CoreRB.position, sosigData.position + sosigData.velocity, interpolationSpeed * Time.deltaTime);
					physicalSosig.CoreRB.position = position;
				}
				else
				{
					physicalSosig.CoreRB.position = sosigData.position;
				}
				physicalSosig.CoreRB.rotation = Quaternion.Lerp(physicalSosig.CoreRB.rotation, sosigData.rotation, interpolationSpeed * Time.deltaTime);
			}
		}

		public override void EnsureUncontrolled()
		{
			for (int i = 0; i < physicalSosig.Links.Count; i++)
			{
				if ((Object)(object)physicalSosig.Links[i] != (Object)null && (Object)(object)((FVRInteractiveObject)physicalSosig.Links[i].O).m_hand != (Object)null)
				{
					((FVRInteractiveObject)physicalSosig.Links[i].O).ForceBreakInteraction();
				}
			}
		}

		protected override void OnDestroy()
		{
			GameManager.OnInstanceJoined -= OnInstanceJoined;
			if (!skipFullDestroy)
			{
				if (!GameManager.sceneLoading)
				{
					SosigPatch.sosigDiesSkip++;
					physicalSosig.SosigDies((DamageClass)0, (SosigDeathType)0);
					SosigPatch.sosigDiesSkip--;
				}
				GameManager.trackedSosigBySosig.Remove(physicalSosig);
				for (int i = 0; i < physicalSosig.Links.Count; i++)
				{
					GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)physicalSosig.Links[i].O);
					GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalSosig.Links[i]);
				}
				EnsureUncontrolled();
				base.OnDestroy();
			}
		}

		public override void SecondaryDestroy()
		{
			foreach (SosigLink link in physicalSosig.Links)
			{
				if ((Object)(object)link != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)link).gameObject);
				}
			}
		}

		public override void BeginInteraction(FVRViveHand hand)
		{
			if (data.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.GiveObjectControl(data.trackedID, GameManager.ID, null);
				}
				else
				{
					ClientSend.GiveObjectControl(data.trackedID, GameManager.ID, null);
				}
				data.controller = GameManager.ID;
				data.localTrackedID = GameManager.objects.Count;
				GameManager.objects.Add(data);
				sosigData.TakeInventoryControl();
			}
		}

		public override void EndInteraction(FVRViveHand hand)
		{
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.controller != GameManager.ID)
			{
				if (ThreadManager.host)
				{
					ServerSend.GiveObjectControl(data.trackedID, Mod.currentTNHInstance.controller, null);
				}
				else
				{
					ClientSend.GiveObjectControl(data.trackedID, Mod.currentTNHInstance.controller, null);
				}
				data.RemoveFromLocal();
			}
		}

		protected virtual void OnInstanceJoined(int instance, int source)
		{
			if (GameManager.sceneLoading)
			{
				return;
			}
			TrackedObjectData.ObjectBringType bring = TrackedObjectData.ObjectBringType.No;
			data.ShouldBring(scene: false, ref bring);
			GameManager.giveControlOfDestroyed++;
			int interactionID2;
			if (bring == TrackedObjectData.ObjectBringType.Yes)
			{
				if (data.IsControlled(out var _))
				{
					data.SetInstance(instance, send: true);
				}
				else
				{
					Object.DestroyImmediate((Object)(object)this);
					GameManager.SyncTrackedObjects(((Component)this).transform, controlEverything: true, null);
				}
			}
			else if (bring == TrackedObjectData.ObjectBringType.OnlyInteracted && data.IsControlled(out interactionID2))
			{
				data.SetInstance(instance, send: true);
			}
			else
			{
				Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
			}
			GameManager.giveControlOfDestroyed--;
		}
	}
	public class TrackedSosigData : TrackedObjectData
	{
		public delegate void OnCollectAdditionalDataDelegate(ref bool collected, TrackedSosigData trackedSosigData);

		public delegate void OnProcessAdditionalDataDelegate(ref bool processed, TrackedSosigData trackedSosigData);

		public TrackedSosig physicalSosig;

		public Vector3 previousPos;

		public Quaternion previousRot;

		public Vector3 position;

		public Quaternion rotation;

		public Vector3 previousAgentPos;

		public Vector3 agentPosition;

		public Vector3 velocity = Vector3.zero;

		public int[] previousAmmoStores;

		public int[] ammoStores;

		public float[] previousLinkIntegrity;

		public float[] linkIntegrity;

		public float previousMustard;

		public float mustard;

		public SosigConfigTemplate configTemplate;

		public List<List<string>> wearables;

		public float[][] linkData;

		public byte IFF;

		public bool[] IFFChart;

		public SosigBodyPose previousBodyPose;

		public SosigBodyPose bodyPose;

		public SosigOrder previousOrder;

		public SosigOrder currentOrder;

		public SosigOrder fallbackOrder;

		public byte[] data;

		public Vector3 guardPoint;

		public Vector3 guardDir;

		public bool hardGuard;

		public Vector3 skirmishPoint;

		public Vector3 pathToPoint;

		public Vector3 assaultPoint;

		public Vector3 faceTowards;

		public Vector3 wanderPoint;

		public SosigMoveSpeed assaultSpeed;

		public Vector3 idleToPoint;

		public Vector3 idleDominantDir;

		public Vector3 pathToLookDir;

		public int[] inventory;

		public float previousJointLimit;

		public float jointLimit;

		public bool previousUnconscious;

		public bool unconscious;

		public bool previousBlinded;

		public bool blinded;

		public bool previousConfused;

		public bool confused;

		public float previousSuppressionLevel;

		public float suppressionLevel;

		public static KeyValuePair<int, SosigPatrolSquad> latestSosigPatrolSquad = new KeyValuePair<int, SosigPatrolSquad>(-1, null);

		public static event OnCollectAdditionalDataDelegate OnCollectAdditionalData;

		public static event OnProcessAdditionalDataDelegate OnProcessAdditionalData;

		public TrackedSosigData()
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)


		public TrackedSosigData(Packet packet, string typeID, int trackedID)
			: base(packet, typeID, trackedID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Expected I4, but got Unknown
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			position = packet.ReadVector3();
			rotation = packet.ReadQuaternion();
			agentPosition = packet.ReadVector3();
			mustard = packet.ReadFloat();
			byte b = packet.ReadByte();
			if (b > 0)
			{
				ammoStores = new int[b];
				for (int i = 0; i < b; i++)
				{
					ammoStores[i] = packet.ReadInt();
				}
			}
			bodyPose = (SosigBodyPose)packet.ReadByte();
			byte b2 = packet.ReadByte();
			if (b2 > 0)
			{
				if (linkIntegrity == null)
				{
					linkIntegrity = new float[b2];
				}
				for (int j = 0; j < b2; j++)
				{
					linkIntegrity[j] = packet.ReadFloat();
				}
			}
			fallbackOrder = (SosigOrder)packet.ReadByte();
			currentOrder = (SosigOrder)packet.ReadByte();
			jointLimit = packet.ReadFloat();
			unconscious = packet.ReadBool();
			blinded = packet.ReadBool();
			confused = packet.ReadBool();
			suppressionLevel = packet.ReadFloat();
			byte b3 = packet.ReadByte();
			if (b3 > 0)
			{
				if (linkData == null)
				{
					linkData = new float[b3][];
				}
				for (int k = 0; k < b3; k++)
				{
					if (linkData[k] == null || linkData[k].Length != 5)
					{
						linkData[k] = new float[5];
					}
					for (int l = 0; l < 5; l++)
					{
						linkData[k][l] = packet.ReadFloat();
					}
				}
			}
			IFF = packet.ReadByte();
			configTemplate = packet.ReadSosigConfig();
			byte b4 = packet.ReadByte();
			wearables = new List<List<string>>();
			for (int m = 0; m < b4; m++)
			{
				wearables.Add(new List<string>());
				byte b5 = packet.ReadByte();
				if (b5 > 0)
				{
					for (int n = 0; n < b5; n++)
					{
						wearables[m].Add(packet.ReadString());
					}
				}
			}
			IFFChart = SosigTargetPrioritySystemPatch.IntToBoolArr(packet.ReadInt());
			int num = packet.ReadInt();
			if (num > 0)
			{
				data = packet.ReadBytes(num);
			}
			SosigOrder val = currentOrder;
			SosigOrder val2 = val;
			switch (val2 - 1)
			{
			case 0:
				guardPoint = packet.ReadVector3();
				guardDir = packet.ReadVector3();
				hardGuard = packet.ReadBool();
				break;
			case 1:
				skirmishPoint = packet.ReadVector3();
				pathToPoint = packet.ReadVector3();
				assaultPoint = packet.ReadVector3();
				faceTowards = packet.ReadVector3();
				break;
			case 2:
				guardPoint = packet.ReadVector3();
				hardGuard = packet.ReadBool();
				faceTowards = packet.ReadVector3();
				break;
			case 3:
			case 5:
				wanderPoint = packet.ReadVector3();
				break;
			case 6:
				assaultPoint = packet.ReadVector3();
				assaultSpeed = (SosigMoveSpeed)packet.ReadByte();
				faceTowards = packet.ReadVector3();
				break;
			case 8:
				idleToPoint = packet.ReadVector3();
				idleDominantDir = packet.ReadVector3();
				break;
			case 9:
				pathToPoint = packet.ReadVector3();
				pathToLookDir = packet.ReadVector3();
				break;
			}
			byte b6 = packet.ReadByte();
			inventory = new int[b6];
			for (int num2 = 0; num2 < b6; num2++)
			{
				inventory[num2] = packet.ReadInt();
			}
		}

		public static bool IsOfType(Transform t)
		{
			return (Object)(object)((Component)t).GetComponent<Sosig>() != (Object)null;
		}

		public static bool IsControlled(Transform root)
		{
			Sosig component = ((Component)root).GetComponent<Sosig>();
			if ((Object)(object)component != (Object)null && component.Links != null)
			{
				for (int i = 0; i < component.Links.Count; i++)
				{
					if ((Object)(object)component.Links[i] != (Object)null && (Object)(object)((FVRInteractiveObject)component.Links[i].O).m_hand != (Object)null)
					{
						return true;
					}
				}
			}
			return false;
		}

		public override bool IsControlled(out int interactionID)
		{
			interactionID = -1;
			if ((Object)(object)physicalSosig.physicalSosig != (Object)null && physicalSosig.physicalSosig.Links != null)
			{
				for (int i = 0; i < physicalSosig.physicalSosig.Links.Count; i++)
				{
					if ((Object)(object)physicalSosig.physicalSosig.Links[i] != (Object)null && (Object)(object)((FVRInteractiveObject)physicalSosig.physicalSosig.Links[i].O).m_hand != (Object)null)
					{
						if (((FVRInteractiveObject)physicalSosig.physicalSosig.Links[i].O).m_hand.IsThisTheRightHand)
						{
							interactionID = 2;
						}
						else
						{
							interactionID = 1;
						}
						return true;
					}
				}
			}
			return false;
		}

		private static TrackedSosig MakeTracked(Transform root, TrackedObjectData parent)
		{
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Unknown result type (might be due to invalid IL or missing references)
			//IL_0684: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d03: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d0a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d0f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d39: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d58: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d70: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d75: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d88: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d8d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d94: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d99: Unknown result type (might be due to invalid IL or missing references)
			//IL_0da0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0da5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dbd: Unknown result type (might be due to invalid IL or missing references)
			TrackedSosig trackedSosig = ((Component)root).gameObject.AddComponent<TrackedSosig>();
			TrackedSosigData trackedSosigData = (TrackedSosigData)(trackedSosig.data = (trackedSosig.sosigData = new TrackedSosigData()));
			trackedSosigData.physicalSosig = trackedSosig;
			trackedSosigData.physical = trackedSosig;
			Sosig component = ((Component)root).GetComponent<Sosig>();
			trackedSosigData.physicalSosig.physicalSosig = component;
			trackedSosigData.physical.physical = (MonoBehaviour)(object)component;
			trackedSosigData.typeIdentifier = "TrackedSosigData";
			trackedSosigData.active = ((Component)trackedSosig).gameObject.activeInHierarchy;
			trackedSosigData.scene = (GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			trackedSosigData.instance = GameManager.instance;
			trackedSosigData.controller = GameManager.ID;
			trackedSosigData.initTracker = GameManager.ID;
			trackedSosigData.sceneInit = GameManager.InSceneInit();
			GameManager.trackedSosigBySosig.Add(component, trackedSosig);
			GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)component, trackedSosig);
			for (int i = 0; i < component.Links.Count; i++)
			{
				GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)component.Links[i].O, trackedSosig);
				GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)component.Links[i], trackedSosig);
			}
			trackedSosigData.configTemplate = ScriptableObject.CreateInstance<SosigConfigTemplate>();
			trackedSosigData.configTemplate.AppliesDamageResistToIntegrityLoss = component.AppliesDamageResistToIntegrityLoss;
			trackedSosigData.configTemplate.DoesDropWeaponsOnBallistic = component.DoesDropWeaponsOnBallistic;
			trackedSosigData.configTemplate.TotalMustard = component.m_maxMustard;
			trackedSosigData.configTemplate.BleedDamageMult = component.BleedDamageMult;
			trackedSosigData.configTemplate.BleedRateMultiplier = component.BleedRateMult;
			trackedSosigData.configTemplate.BleedVFXIntensity = component.BleedVFXIntensity;
			trackedSosigData.configTemplate.SearchExtentsModifier = component.SearchExtentsModifier;
			trackedSosigData.configTemplate.ShudderThreshold = component.ShudderThreshold;
			trackedSosigData.configTemplate.ConfusionThreshold = component.ConfusionThreshold;
			trackedSosigData.configTemplate.ConfusionMultiplier = component.ConfusionMultiplier;
			trackedSosigData.configTemplate.ConfusionTimeMax = component.m_maxConfusedTime;
			trackedSosigData.configTemplate.StunThreshold = component.StunThreshold;
			trackedSosigData.configTemplate.StunMultiplier = component.StunMultiplier;
			trackedSosigData.configTemplate.StunTimeMax = component.m_maxStunTime;
			trackedSosigData.configTemplate.HasABrain = component.HasABrain;
			trackedSosigData.configTemplate.DoesDropWeaponsOnBallistic = component.DoesDropWeaponsOnBallistic;
			trackedSosigData.configTemplate.RegistersPassiveThreats = component.RegistersPassiveThreats;
			trackedSosigData.configTemplate.CanBeKnockedOut = component.CanBeKnockedOut;
			trackedSosigData.configTemplate.MaxUnconsciousTime = component.m_maxUnconsciousTime;
			trackedSosigData.configTemplate.AssaultPointOverridesSkirmishPointWhenFurtherThan = component.m_assaultPointOverridesSkirmishPointWhenFurtherThan;
			trackedSosigData.configTemplate.ViewDistance = component.MaxSightRange;
			trackedSosigData.configTemplate.HearingDistance = component.MaxHearingRange;
			trackedSosigData.configTemplate.MaxFOV = component.MaxFOV;
			trackedSosigData.configTemplate.StateSightRangeMults = component.StateSightRangeMults;
			trackedSosigData.configTemplate.StateHearingRangeMults = component.StateHearingRangeMults;
			trackedSosigData.configTemplate.StateFOVMults = component.StateFOVMults;
			trackedSosigData.configTemplate.CanPickup_Ranged = component.CanPickup_Ranged;
			trackedSosigData.configTemplate.CanPickup_Melee = component.CanPickup_Melee;
			trackedSosigData.configTemplate.CanPickup_Other = component.CanPickup_Other;
			trackedSosigData.configTemplate.DoesJointBreakKill_Head = component.m_doesJointBreakKill_Head;
			trackedSosigData.configTemplate.DoesJointBreakKill_Upper = component.m_doesJointBreakKill_Upper;
			trackedSosigData.configTemplate.DoesJointBreakKill_Lower = component.m_doesJointBreakKill_Lower;
			trackedSosigData.configTemplate.DoesSeverKill_Head = component.m_doesSeverKill_Head;
			trackedSosigData.configTemplate.DoesSeverKill_Upper = component.m_doesSeverKill_Upper;
			trackedSosigData.configTemplate.DoesSeverKill_Lower = component.m_doesSeverKill_Lower;
			trackedSosigData.configTemplate.DoesExplodeKill_Head = component.m_doesExplodeKill_Head;
			trackedSosigData.configTemplate.DoesExplodeKill_Upper = component.m_doesExplodeKill_Upper;
			trackedSosigData.configTemplate.DoesExplodeKill_Lower = component.m_doesExplodeKill_Lower;
			trackedSosigData.configTemplate.CrawlSpeed = component.Speed_Crawl;
			trackedSosigData.configTemplate.SneakSpeed = component.Speed_Sneak;
			trackedSosigData.configTemplate.WalkSpeed = component.Speed_Walk;
			trackedSosigData.configTemplate.RunSpeed = component.Speed_Run;
			trackedSosigData.configTemplate.TurnSpeed = component.Speed_Turning;
			trackedSosigData.configTemplate.MovementRotMagnitude = component.MovementRotMagnitude;
			trackedSosigData.configTemplate.DamMult_Projectile = component.DamMult_Projectile;
			trackedSosigData.configTemplate.DamMult_Explosive = component.DamMult_Explosive;
			trackedSosigData.configTemplate.DamMult_Melee = component.DamMult_Melee;
			trackedSosigData.configTemplate.DamMult_Piercing = component.DamMult_Piercing;
			trackedSosigData.configTemplate.DamMult_Blunt = component.DamMult_Blunt;
			trackedSosigData.configTemplate.DamMult_Cutting = component.DamMult_Cutting;
			trackedSosigData.configTemplate.DamMult_Thermal = component.DamMult_Thermal;
			trackedSosigData.configTemplate.DamMult_Chilling = component.DamMult_Chilling;
			trackedSosigData.configTemplate.DamMult_EMP = component.DamMult_EMP;
			trackedSosigData.configTemplate.CanBeSurpressed = component.CanBeSuppresed;
			trackedSosigData.configTemplate.SuppressionMult = component.SuppressionMult;
			trackedSosigData.configTemplate.CanBeGrabbed = component.CanBeGrabbed;
			trackedSosigData.configTemplate.CanBeSevered = component.CanBeSevered;
			trackedSosigData.configTemplate.CanBeStabbed = component.CanBeStabbed;
			trackedSosigData.configTemplate.MaxJointLimit = component.m_maxJointLimit;
			trackedSosigData.configTemplate.LinkDamageMultipliers = new List<float>();
			trackedSosigData.configTemplate.LinkStaggerMultipliers = new List<float>();
			trackedSosigData.configTemplate.StartingLinkIntegrity = new List<Vector2>();
			trackedSosigData.configTemplate.StartingChanceBrokenJoint = new List<float>();
			for (int j = 0; j < component.Links.Count; j++)
			{
				trackedSosigData.configTemplate.LinkDamageMultipliers.Add(component.Links[j].DamMult);
				trackedSosigData.configTemplate.LinkStaggerMultipliers.Add(component.Links[j].StaggerMagnitude);
				float integrity = component.Links[j].m_integrity;
				trackedSosigData.configTemplate.StartingLinkIntegrity.Add(new Vector2(integrity, integrity));
				trackedSosigData.configTemplate.StartingChanceBrokenJoint.Add(component.Links[j].m_isJointBroken ? 1 : 0);
			}
			if (component.Priority != null)
			{
				trackedSosigData.configTemplate.TargetCapacity = component.Priority.m_eventCapacity;
				trackedSosigData.configTemplate.TargetTrackingTime = component.Priority.m_maxTrackingTime;
				trackedSosigData.configTemplate.NoFreshTargetTime = component.Priority.m_timeToNoFreshTarget;
			}
			trackedSosigData.position = component.CoreRB.position;
			trackedSosigData.velocity = component.CoreRB.velocity;
			trackedSosigData.rotation = component.CoreRB.rotation;
			trackedSosigData.linkData = new float[component.Links.Count][];
			trackedSosigData.linkIntegrity = new float[trackedSosigData.linkData.Length];
			for (int k = 0; k < component.Links.Count; k++)
			{
				trackedSosigData.linkData[k] = new float[5];
				trackedSosigData.linkData[k][0] = component.Links[k].StaggerMagnitude;
				trackedSosigData.linkData[k][1] = component.Links[k].DamMult;
				trackedSosigData.linkData[k][2] = component.Links[k].DamMultAVG;
				trackedSosigData.linkData[k][3] = component.Links[k].CollisionBluntDamageMultiplier;
				if ((Object)(object)component.Links[k] == (Object)null)
				{
					trackedSosigData.linkData[k][4] = 0f;
					trackedSosigData.linkIntegrity[k] = 0f;
				}
				else
				{
					trackedSosigData.linkData[k][4] = component.Links[k].m_integrity;
					trackedSosigData.linkIntegrity[k] = trackedSosigData.linkData[k][4];
				}
			}
			trackedSosigData.wearables = new List<List<string>>();
			for (int l = 0; l < component.Links.Count; l++)
			{
				trackedSosigData.wearables.Add(new List<string>());
				for (int m = 0; m < component.Links[l].m_wearables.Count; m++)
				{
					trackedSosigData.wearables[l].Add(((Object)component.Links[l].m_wearables[m]).name);
					if (trackedSosigData.wearables[l][m].EndsWith("(Clone)"))
					{
						trackedSosigData.wearables[l][m] = trackedSosigData.wearables[l][m].Substring(0, trackedSosigData.wearables[l][m].Length - 7);
					}
					if (Mod.sosigWearableMap.ContainsKey(trackedSosigData.wearables[l][m]))
					{
						trackedSosigData.wearables[l][m] = Mod.sosigWearableMap[trackedSosigData.wearables[l][m]];
					}
					else
					{
						Mod.LogError("SosigWearable: " + trackedSosigData.wearables[l][m] + " not found in map");
					}
				}
			}
			trackedSosigData.ammoStores = component.Inventory.m_ammoStores;
			trackedSosigData.inventory = new int[2 + component.Inventory.Slots.Count];
			if ((Object)(object)component.Hand_Primary.HeldObject == (Object)null)
			{
				trackedSosigData.inventory[0] = -1;
			}
			else
			{
				TrackedItem trackedItem = (GameManager.trackedItemBySosigWeapon.TryGetValue(component.Hand_Primary.HeldObject, out trackedItem) ? trackedItem : ((Component)component.Hand_Primary.HeldObject.O).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem == (Object)null)
				{
					TrackedItem.unknownSosigInventoryObjects.Add(component.Hand_Primary.HeldObject, new KeyValuePair<TrackedSosigData, int>(trackedSosigData, 0));
					trackedSosigData.inventory[0] = -1;
				}
				else if (trackedItem.data.trackedID == -1)
				{
					TrackedItem.unknownSosigInventoryItems.Add(trackedItem.data.localWaitingIndex, new KeyValuePair<TrackedSosigData, int>(trackedSosigData, 0));
					trackedSosigData.inventory[0] = -1;
				}
				else
				{
					trackedSosigData.inventory[0] = trackedItem.data.trackedID;
				}
			}
			if ((Object)(object)component.Hand_Secondary.HeldObject == (Object)null)
			{
				trackedSosigData.inventory[1] = -1;
			}
			else
			{
				TrackedItem trackedItem2 = (GameManager.trackedItemBySosigWeapon.TryGetValue(component.Hand_Secondary.HeldObject, out trackedItem2) ? trackedItem2 : ((Component)component.Hand_Secondary.HeldObject.O).GetComponent<TrackedItem>());
				if ((Object)(object)trackedItem2 == (Object)null)
				{
					TrackedItem.unknownSosigInventoryObjects.Add(component.Hand_Secondary.HeldObject, new KeyValuePair<TrackedSosigData, int>(trackedSosigData, 1));
					trackedSosigData.inventory[1] = -1;
				}
				else if (trackedItem2.data.trackedID == -1)
				{
					TrackedItem.unknownSosigInventoryItems.Add(trackedItem2.data.localWaitingIndex, new KeyValuePair<TrackedSosigData, int>(trackedSosigData, 1));
					trackedSosigData.inventory[1] = -1;
				}
				else
				{
					trackedSosigData.inventory[1] = trackedItem2.data.trackedID;
				}
			}
			for (int n = 0; n < component.Inventory.Slots.Count; n++)
			{
				if ((Object)(object)component.Inventory.Slots[n].HeldObject == (Object)null)
				{
					trackedSosigData.inventory[n + 2] = -1;
					continue;
				}
				TrackedItem value = (GameManager.trackedItemBySosigWeapon.TryGetValue(component.Inventory.Slots[n].HeldObject, out value) ? value : ((Component)component.Inventory.Slots[n].HeldObject.O).GetComponent<TrackedItem>());
				if ((Object)(object)value == (Object)null)
				{
					TrackedItem.unknownSosigInventoryObjects.Add(component.Inventory.Slots[n].HeldObject, new KeyValuePair<TrackedSosigData, int>(trackedSosigData, n + 2));
					trackedSosigData.inventory[n + 2] = -1;
				}
				else if (value.data.trackedID == -1)
				{
					TrackedItem.unknownSosigInventoryItems.Add(value.data.localWaitingIndex, new KeyValuePair<TrackedSosigData, int>(trackedSosigData, n + 2));
					trackedSosigData.inventory[n + 2] = -1;
				}
				else
				{
					trackedSosigData.inventory[n + 2] = value.data.trackedID;
				}
			}
			trackedSosigData.mustard = component.Mustard;
			trackedSosigData.bodyPose = component.BodyPose;
			trackedSosigData.currentOrder = component.CurrentOrder;
			trackedSosigData.fallbackOrder = component.FallbackOrder;
			trackedSosigData.IFF = (byte)component.GetIFF();
			trackedSosigData.IFFChart = component.Priority.IFFChart;
			trackedSosigData.guardPoint = component.GetGuardPoint();
			trackedSosigData.guardDir = component.GetGuardDir();
			trackedSosigData.hardGuard = component.m_hardGuard;
			trackedSosigData.skirmishPoint = component.m_skirmishPoint;
			trackedSosigData.pathToPoint = component.m_pathToPoint;
			trackedSosigData.assaultPoint = component.GetAssaultPoint();
			trackedSosigData.faceTowards = component.m_faceTowards;
			trackedSosigData.wanderPoint = component.m_wanderPoint;
			trackedSosigData.assaultSpeed = component.m_assaultSpeed;
			trackedSosigData.idleToPoint = component.m_idlePoint;
			trackedSosigData.idleDominantDir = component.m_idleDominantDir;
			trackedSosigData.pathToLookDir = component.m_pathToLookDir;
			trackedSosigData.CollectExternalData();
			trackedSosigData.localTrackedID = GameManager.objects.Count;
			GameManager.objects.Add(trackedSosigData);
			if (trackedSosig.awoken)
			{
				trackedSosig.data.Update(full: true);
			}
			Mod.LogInfo("Made sosig " + ((Object)trackedSosig).name + " tracked", debug: false);
			return trackedSosig;
		}

		public override void WriteToPacket(Packet packet, bool incrementOrder, bool full)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Expected I4, but got Unknown
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			base.WriteToPacket(packet, incrementOrder, full);
			packet.Write(position);
			packet.Write(rotation);
			packet.Write(agentPosition);
			packet.Write(mustard);
			if (ammoStores != null && ammoStores.Length != 0)
			{
				packet.Write((byte)ammoStores.Length);
				for (int i = 0; i < ammoStores.Length; i++)
				{
					packet.Write(ammoStores[i]);
				}
			}
			else
			{
				packet.Write((byte)0);
			}
			packet.Write((byte)bodyPose);
			if (linkIntegrity == null || linkIntegrity.Length == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)linkIntegrity.Length);
				for (int j = 0; j < linkIntegrity.Length; j++)
				{
					packet.Write(linkIntegrity[j]);
				}
			}
			packet.Write((byte)fallbackOrder);
			packet.Write((byte)currentOrder);
			packet.Write(jointLimit);
			packet.Write(unconscious);
			packet.Write(blinded);
			packet.Write(confused);
			packet.Write(suppressionLevel);
			if (!full)
			{
				return;
			}
			if (linkData == null || linkData.Length == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)linkData.Length);
				for (int k = 0; k < linkData.Length; k++)
				{
					for (int l = 0; l < 5; l++)
					{
						packet.Write(linkData[k][l]);
					}
				}
			}
			packet.Write(IFF);
			packet.Write(configTemplate);
			packet.Write((byte)wearables.Count);
			for (int m = 0; m < wearables.Count; m++)
			{
				if (wearables[m] == null || wearables[m].Count == 0)
				{
					packet.Write((byte)0);
					continue;
				}
				packet.Write((byte)wearables[m].Count);
				for (int n = 0; n < wearables[m].Count; n++)
				{
					packet.Write(wearables[m][n]);
				}
			}
			packet.Write(SosigTargetPrioritySystemPatch.BoolArrToInt(IFFChart));
			if (data == null || data.Length == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(data.Length);
				packet.Write(data);
			}
			SosigOrder val = currentOrder;
			SosigOrder val2 = val;
			switch (val2 - 1)
			{
			case 0:
				packet.Write(guardPoint);
				packet.Write(guardDir);
				packet.Write(hardGuard);
				break;
			case 1:
				packet.Write(skirmishPoint);
				packet.Write(pathToPoint);
				packet.Write(assaultPoint);
				packet.Write(faceTowards);
				break;
			case 2:
				packet.Write(guardPoint);
				packet.Write(hardGuard);
				packet.Write(faceTowards);
				break;
			case 3:
			case 5:
				packet.Write(wanderPoint);
				break;
			case 6:
				packet.Write(assaultPoint);
				packet.Write((byte)assaultSpeed);
				packet.Write(faceTowards);
				break;
			case 8:
				packet.Write(idleToPoint);
				packet.Write(idleDominantDir);
				break;
			case 9:
				packet.Write(pathToPoint);
				packet.Write(pathToLookDir);
				break;
			}
			if (inventory == null)
			{
				packet.Write((byte)0);
				return;
			}
			packet.Write((byte)inventory.Length);
			for (int num = 0; num < inventory.Length; num++)
			{
				packet.Write(inventory[num]);
			}
		}

		private void CollectExternalData()
		{
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			bool collected = false;
			if (TrackedSosigData.OnCollectAdditionalData != null)
			{
				TrackedSosigData.OnCollectAdditionalData(ref collected, this);
			}
			if (collected)
			{
				return;
			}
			data = new byte[10 + 12 * ((TNH_ManagerPatch.inGenerateSentryPatrol || TNH_ManagerPatch.inGeneratePatrol) ? ((TNH_ManagerPatch.patrolPoints != null) ? TNH_ManagerPatch.patrolPoints.Count : 0) : 0)];
			data[0] = (byte)(TNH_HoldPointPatch.inSpawnEnemyGroup ? 1 : 0);
			if (TNH_HoldPointPatch.inSpawnEnemyGroup && (Object)(object)Mod.managerObject != (Object)null && Mod.currentTNHInstance != null && (Object)(object)Mod.currentTNHInstance.manager.m_curHoldPoint != (Object)null)
			{
				data[1] = (byte)(((Object)(object)Mod.currentTNHInstance.manager.m_curHoldPoint.m_holdGroupLeader == (Object)(object)physicalSosig.physicalSosig) ? 1 : 0);
			}
			data[2] = (byte)(TNH_SupplyPointPatch.inSpawnTakeEnemyGroup ? 1 : 0);
			BitConverter.GetBytes((short)TNH_SupplyPointPatch.supplyPointIndex).CopyTo(data, 3);
			Mod.LogInfo("Sosig in supply point spawn take enemy group: " + TNH_SupplyPointPatch.inSpawnTakeEnemyGroup + ", with supply point index: " + TNH_SupplyPointPatch.supplyPointIndex);
			data[5] = (byte)(TNH_ManagerPatch.inGenerateSentryPatrol ? 1 : 0);
			data[6] = (byte)(TNH_ManagerPatch.inGeneratePatrol ? 1 : 0);
			if (!TNH_ManagerPatch.inGenerateSentryPatrol && !TNH_ManagerPatch.inGeneratePatrol)
			{
				return;
			}
			BitConverter.GetBytes((short)TNH_ManagerPatch.patrolIndex).CopyTo(data, 7);
			if (TNH_ManagerPatch.patrolPoints == null || TNH_ManagerPatch.patrolPoints.Count == 0)
			{
				data[9] = 0;
				return;
			}
			data[9] = (byte)TNH_ManagerPatch.patrolPoints.Count;
			for (int i = 0; i < TNH_ManagerPatch.patrolPoints.Count; i++)
			{
				int num = i * 12 + 10;
				BitConverter.GetBytes(TNH_ManagerPatch.patrolPoints[i].x).CopyTo(data, num);
				BitConverter.GetBytes(TNH_ManagerPatch.patrolPoints[i].y).CopyTo(data, num + 4);
				BitConverter.GetBytes(TNH_ManagerPatch.patrolPoints[i].z).CopyTo(data, num + 8);
			}
		}

		public override IEnumerator Instantiate()
		{
			Mod.LogInfo("Instantiating sosig at " + trackedID, debug: false);
			yield return ((AnvilAsset)IM.OD["SosigBody_Default"]).GetGameObjectAsync();
			GameObject sosigPrefab = ((AnvilAsset)IM.OD["SosigBody_Default"]).GetGameObject();
			if ((Object)(object)sosigPrefab == (Object)null)
			{
				Mod.LogError($"Attempted to instantiate sosig sent from {base.controller} but failed to get prefab.");
				awaitingInstantiation = false;
			}
			else
			{
				if (!awaitingInstantiation)
				{
					yield break;
				}
				Mod.skipAllInstantiates++;
				if (Mod.skipAllInstantiates <= 0)
				{
					Mod.LogError("SkipAllInstantiates negative or 0 at sosig instantiation, setting to 1");
					Mod.skipAllInstantiates = 1;
				}
				GameObject sosigInstance = Object.Instantiate<GameObject>(sosigPrefab, position, rotation);
				Mod.skipAllInstantiates--;
				physicalSosig = sosigInstance.AddComponent<TrackedSosig>();
				physical = physicalSosig;
				physicalSosig.physicalSosig = sosigInstance.GetComponent<Sosig>();
				physical.physical = (MonoBehaviour)(object)physicalSosig.physicalSosig;
				awaitingInstantiation = false;
				physicalSosig.sosigData = this;
				physicalSosig.data = this;
				SosigConfigurePatch.skipConfigure = true;
				physicalSosig.physicalSosig.Configure(configTemplate);
				if ((Object)(object)physicalSosig.physicalSosig.Speech == (Object)null)
				{
					physicalSosig.physicalSosig.Speech = Mod.defaultSosigSpeechSet;
				}
				GameManager.trackedSosigBySosig.Add(physicalSosig.physicalSosig, physicalSosig);
				GameManager.trackedObjectByObject.Add((MonoBehaviour)(object)physicalSosig.physicalSosig, physicalSosig);
				int i = 0;
				while (i < physicalSosig.physicalSosig.Links.Count)
				{
					GameManager.trackedObjectByInteractive.Add((FVRInteractiveObject)(object)physicalSosig.physicalSosig.Links[i].O, physicalSosig);
					GameManager.trackedObjectByDamageable.Add((IFVRDamageable)(object)physicalSosig.physicalSosig.Links[i], physicalSosig);
					int num = i + 1;
					i = num;
				}
				AnvilManager.Run(EquipWearables());
				if (base.controller != GameManager.ID)
				{
					if ((Object)(object)GM.CurrentAIManager != (Object)null)
					{
						GM.CurrentAIManager.DeRegisterAIEntity(physicalSosig.physicalSosig.E);
					}
					physicalSosig.physicalSosig.CoreRB.isKinematic = true;
				}
				SosigIFFPatch.skip++;
				physicalSosig.physicalSosig.SetIFF((int)IFF);
				SosigIFFPatch.skip--;
				physicalSosig.physicalSosig.Priority.IFFChart = IFFChart;
				SosigPatch.sosigSetCurrentOrderSkip++;
				SosigOrder val = currentOrder;
				SosigOrder val2 = val;
				switch (val2 - 1)
				{
				case 0:
					physicalSosig.physicalSosig.CommandGuardPoint(guardPoint, hardGuard);
					physicalSosig.physicalSosig.m_guardDominantDirection = guardDir;
					break;
				case 1:
					physicalSosig.physicalSosig.SetCurrentOrder(currentOrder);
					physicalSosig.physicalSosig.m_skirmishPoint = skirmishPoint;
					physicalSosig.physicalSosig.m_pathToPoint = pathToPoint;
					physicalSosig.physicalSosig.m_assaultPoint = assaultPoint;
					physicalSosig.physicalSosig.m_faceTowards = faceTowards;
					break;
				case 2:
					physicalSosig.physicalSosig.SetCurrentOrder(currentOrder);
					physicalSosig.physicalSosig.UpdateGuardPoint(guardPoint);
					physicalSosig.physicalSosig.m_hardGuard = hardGuard;
					physicalSosig.physicalSosig.m_faceTowards = faceTowards;
					break;
				case 3:
				case 5:
					physicalSosig.physicalSosig.SetCurrentOrder(currentOrder);
					physicalSosig.physicalSosig.m_wanderPoint = wanderPoint;
					break;
				case 6:
					physicalSosig.physicalSosig.CommandAssaultPoint(assaultPoint);
					physicalSosig.physicalSosig.m_faceTowards = faceTowards;
					physicalSosig.physicalSosig.SetAssaultSpeed(assaultSpeed);
					break;
				case 8:
					physicalSosig.physicalSosig.CommandIdle(idleToPoint, idleDominantDir);
					break;
				case 9:
					physicalSosig.physicalSosig.SetCurrentOrder(currentOrder);
					physicalSosig.physicalSosig.m_pathToPoint = pathToPoint;
					physicalSosig.physicalSosig.m_pathToLookDir = pathToLookDir;
					break;
				default:
					physicalSosig.physicalSosig.SetCurrentOrder(currentOrder);
					break;
				}
				physicalSosig.physicalSosig.FallbackOrder = fallbackOrder;
				SosigPatch.sosigSetCurrentOrderSkip--;
				physicalSosig.physicalSosig.InitHands();
				physicalSosig.physicalSosig.Inventory.Init();
				TrackedObjectData[] arrToUse = (ThreadManager.host ? Server.objects : Client.objects);
				SosigPickUpPatch.skip++;
				SosigPlaceObjectInPatch.skip++;
				int i2 = 0;
				while (i2 < inventory.Length)
				{
					if (inventory[i2] != -1)
					{
						if (!(arrToUse[inventory[i2]] is TrackedItemData asTrackedItem))
						{
							if (ThreadManager.host)
							{
								Mod.LogError("Sosig instantiation: inventory[" + i2 + "] = " + inventory[i2] + " is missing item data!");
							}
							else
							{
								Mod.LogWarning("Sosig instantiation: inventory[" + i2 + "] = " + inventory[i2] + " is missing item data!");
							}
						}
						else if ((Object)(object)asTrackedItem.physicalItem == (Object)null)
						{
							asTrackedItem.toPutInSosigInventory = new int[2] { trackedID, i2 };
						}
						else
						{
							switch (i2)
							{
							case 0:
								physicalSosig.physicalSosig.Hand_Primary.PickUp(((SosigWeaponPlayerInterface)asTrackedItem.physicalItem.physicalItem).W);
								break;
							case 1:
								physicalSosig.physicalSosig.Hand_Secondary.PickUp(((SosigWeaponPlayerInterface)asTrackedItem.physicalItem.physicalItem).W);
								break;
							default:
								physicalSosig.physicalSosig.Inventory.Slots[i2 - 2].PlaceObjectIn(((SosigWeaponPlayerInterface)asTrackedItem.physicalItem.physicalItem).W);
								break;
							}
						}
					}
					int num = i2 + 1;
					i2 = num;
				}
				SosigPickUpPatch.skip--;
				SosigPlaceObjectInPatch.skip--;
				ProcessData();
				UpdateFromData(this);
			}
		}

		private void ProcessData()
		{
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			bool processed = false;
			if (TrackedSosigData.OnProcessAdditionalData != null)
			{
				TrackedSosigData.OnProcessAdditionalData(ref processed, this);
			}
			if (processed || !((Object)(object)GM.TNH_Manager != (Object)null) || Mod.currentTNHInstance == null)
			{
				return;
			}
			if (data[0] == 1)
			{
				GM.TNH_Manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_activeSosigs.Add(physicalSosig.physicalSosig);
				if (data[1] == 1)
				{
					GM.TNH_Manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_holdGroupLeader = physicalSosig.physicalSosig;
				}
			}
			else if (data[2] == 1)
			{
				GM.TNH_Manager.SupplyPoints[BitConverter.ToInt16(data, 3)].m_activeSosigs.Add(physicalSosig.physicalSosig);
				GM.TNH_Manager.RegisterGuard(physicalSosig.physicalSosig);
			}
			else
			{
				if (data[5] != 1 && data[6] != 1)
				{
					return;
				}
				physicalSosig.physicalSosig.SetAssaultSpeed((SosigMoveSpeed)3);
				int num = BitConverter.ToInt16(data, 7);
				if (latestSosigPatrolSquad.Key == num)
				{
					latestSosigPatrolSquad.Value.Squad.Add(physicalSosig.physicalSosig);
					return;
				}
				latestSosigPatrolSquad = new KeyValuePair<int, SosigPatrolSquad>(num, new SosigPatrolSquad());
				latestSosigPatrolSquad.Value.PatrolPoints = new List<Vector3>();
				int num2 = data[9];
				for (int i = 0; i < num2; i++)
				{
					int num3 = i * 12 + 10;
					latestSosigPatrolSquad.Value.PatrolPoints.Add(new Vector3(BitConverter.ToSingle(data, num3), BitConverter.ToSingle(data, num3 + 4), BitConverter.ToSingle(data, num3 + 8)));
				}
				latestSosigPatrolSquad.Value.Squad.Add(physicalSosig.physicalSosig);
				GM.TNH_Manager.m_patrolSquads.Add(latestSosigPatrolSquad.Value);
			}
		}

		private IEnumerator EquipWearables()
		{
			if (wearables == null)
			{
				yield break;
			}
			int i = 0;
			while (i < wearables.Count)
			{
				int num;
				for (int j = 0; j < wearables[i].Count; j = num)
				{
					if (IM.OD.ContainsKey(wearables[i][j]))
					{
						yield return ((AnvilAsset)IM.OD[wearables[i][j]]).GetGameObjectAsync();
						Mod.skipAllInstantiates++;
						if (Mod.skipAllInstantiates <= 0)
						{
							Mod.LogError("SkipAllInstantiates negative or 0 at equipwearbles, setting to 1");
							Mod.skipAllInstantiates = 1;
						}
						GameObject outfitItemObject = Object.Instantiate<GameObject>(((AnvilAsset)IM.OD[wearables[i][j]]).GetGameObject(), ((Component)physicalSosig.physicalSosig.Links[i]).transform.position, ((Component)physicalSosig.physicalSosig.Links[i]).transform.rotation, ((Component)physicalSosig.physicalSosig.Links[i]).transform);
						Mod.skipAllInstantiates--;
						SosigWearable wearableScript = outfitItemObject.GetComponent<SosigWearable>();
						SosigLinkActionPatch.skipRegisterWearable++;
						wearableScript.RegisterWearable(physicalSosig.physicalSosig.Links[i]);
						SosigLinkActionPatch.skipRegisterWearable--;
					}
					else
					{
						Mod.LogWarning("TrackedSosigData.EquipWearables: Wearable " + wearables[i][j] + " not found in OD");
					}
					num = j + 1;
				}
				num = i + 1;
				i = num;
			}
		}

		public IEnumerator EquipWearable(int linkIndex, string ID, bool skip = false)
		{
			if (IM.OD.ContainsKey(ID))
			{
				yield return ((AnvilAsset)IM.OD[ID]).GetGameObjectAsync();
				if (!((Object)(object)physicalSosig == (Object)null) && !((Object)(object)physicalSosig.physicalSosig.Links[linkIndex] == (Object)null))
				{
					Mod.skipAllInstantiates++;
					if (Mod.skipAllInstantiates <= 0)
					{
						Mod.LogError("SkipAllInstantiates negative or 0 at equipwearable, setting to 1");
						Mod.skipAllInstantiates = 1;
					}
					GameObject outfitItemObject = Object.Instantiate<GameObject>(((AnvilAsset)IM.OD[ID]).GetGameObject(), ((Component)physicalSosig.physicalSosig.Links[linkIndex]).transform.position, ((Component)physicalSosig.physicalSosig.Links[linkIndex]).transform.rotation, ((Component)physicalSosig.physicalSosig.Links[linkIndex]).transform);
					Mod.skipAllInstantiates--;
					SosigWearable wearableScript = outfitItemObject.GetComponent<SosigWearable>();
					if (skip)
					{
						SosigLinkActionPatch.skipRegisterWearable++;
					}
					wearableScript.RegisterWearable(physicalSosig.physicalSosig.Links[linkIndex]);
					if (skip)
					{
						SosigLinkActionPatch.skipRegisterWearable--;
					}
				}
			}
			else
			{
				Mod.LogWarning("TrackedSosigData.EquipWearables: Wearable " + ID + " not found in OD");
			}
		}

		public override void UpdateFromData(TrackedObjectData updatedObject, bool full = false)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromData(updatedObject, full);
			TrackedSosigData trackedSosigData = updatedObject as TrackedSosigData;
			if (full)
			{
				linkData = trackedSosigData.linkData;
				IFF = trackedSosigData.IFF;
				configTemplate = trackedSosigData.configTemplate;
				wearables = trackedSosigData.wearables;
				IFFChart = trackedSosigData.IFFChart;
				data = trackedSosigData.data;
				guardPoint = trackedSosigData.guardPoint;
				guardDir = trackedSosigData.guardDir;
				hardGuard = trackedSosigData.hardGuard;
				skirmishPoint = trackedSosigData.skirmishPoint;
				pathToPoint = trackedSosigData.pathToPoint;
				assaultPoint = trackedSosigData.assaultPoint;
				faceTowards = trackedSosigData.faceTowards;
				wanderPoint = trackedSosigData.wanderPoint;
				assaultSpeed = trackedSosigData.assaultSpeed;
				idleToPoint = trackedSosigData.idleToPoint;
				idleDominantDir = trackedSosigData.idleDominantDir;
				pathToLookDir = trackedSosigData.pathToLookDir;
				inventory = trackedSosigData.inventory;
			}
			previousPos = position;
			previousRot = rotation;
			position = trackedSosigData.position;
			_ = previousPos;
			velocity = position - previousPos;
			rotation = trackedSosigData.rotation;
			previousAgentPos = agentPosition;
			agentPosition = trackedSosigData.agentPosition;
			previousAmmoStores = ammoStores;
			ammoStores = trackedSosigData.ammoStores;
			previousMustard = mustard;
			mustard = trackedSosigData.mustard;
			previousLinkIntegrity = linkIntegrity;
			linkIntegrity = trackedSosigData.linkIntegrity;
			previousBodyPose = bodyPose;
			bodyPose = trackedSosigData.bodyPose;
			fallbackOrder = trackedSosigData.fallbackOrder;
			previousOrder = currentOrder;
			currentOrder = trackedSosigData.currentOrder;
			previousJointLimit = jointLimit;
			jointLimit = trackedSosigData.jointLimit;
			previousUnconscious = unconscious;
			unconscious = trackedSosigData.unconscious;
			previousBlinded = blinded;
			blinded = trackedSosigData.blinded;
			previousConfused = confused;
			confused = trackedSosigData.confused;
			previousSuppressionLevel = suppressionLevel;
			suppressionLevel = trackedSosigData.suppressionLevel;
			if (!((Object)(object)physicalSosig != (Object)null))
			{
				return;
			}
			((Component)physicalSosig.physicalSosig.Agent).transform.position = agentPosition;
			physicalSosig.physicalSosig.FallbackOrder = fallbackOrder;
			physicalSosig.physicalSosig.Mustard = mustard;
			physicalSosig.physicalSosig.SetBodyPose(bodyPose);
			physicalSosig.physicalSosig.Inventory.m_ammoStores = ammoStores;
			for (int i = 0; i < physicalSosig.physicalSosig.Links.Count; i++)
			{
				if ((Object)(object)physicalSosig.physicalSosig.Links[i] != (Object)null && previousLinkIntegrity[i] != linkIntegrity[i])
				{
					physicalSosig.physicalSosig.Links[i].m_integrity = linkIntegrity[i];
					physicalSosig.physicalSosig.UpdateRendererOnLink(i);
				}
			}
			if (previousJointLimit != jointLimit)
			{
				physicalSosig.physicalSosig.UpdateJoints(Mathf.InverseLerp(60f, physicalSosig.physicalSosig.m_maxJointLimit, jointLimit));
			}
			physicalSosig.physicalSosig.m_isUnconscious = unconscious;
			physicalSosig.physicalSosig.m_isBlinded = blinded;
			physicalSosig.physicalSosig.m_isConfused = confused;
			physicalSosig.physicalSosig.m_suppressionLevel = suppressionLevel;
		}

		public override void UpdateFromPacket(Packet packet, bool full = false)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0622: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Unknown result type (might be due to invalid IL or missing references)
			//IL_064e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Expected I4, but got Unknown
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			base.UpdateFromPacket(packet, full);
			int num = 0;
			try
			{
				previousPos = position;
				previousRot = rotation;
				position = packet.ReadVector3();
				_ = previousPos;
				velocity = position - previousPos;
				rotation = packet.ReadQuaternion();
				previousAgentPos = agentPosition;
				agentPosition = packet.ReadVector3();
				previousMustard = mustard;
				mustard = packet.ReadFloat();
				previousAmmoStores = ammoStores;
				byte b = packet.ReadByte();
				if (b > 0)
				{
					ammoStores = new int[b];
					for (int i = 0; i < b; i++)
					{
						ammoStores[i] = packet.ReadInt();
					}
				}
				num++;
				previousBodyPose = bodyPose;
				bodyPose = (SosigBodyPose)packet.ReadByte();
				byte b2 = packet.ReadByte();
				previousLinkIntegrity = linkIntegrity;
				if (b2 > 0)
				{
					if (linkIntegrity == null)
					{
						linkIntegrity = new float[b2];
					}
					for (int j = 0; j < b2; j++)
					{
						linkIntegrity[j] = packet.ReadFloat();
					}
				}
				fallbackOrder = (SosigOrder)packet.ReadByte();
				previousOrder = currentOrder;
				currentOrder = (SosigOrder)packet.ReadByte();
				previousJointLimit = jointLimit;
				jointLimit = packet.ReadFloat();
				num++;
				previousUnconscious = unconscious;
				unconscious = packet.ReadBool();
				previousBlinded = blinded;
				blinded = packet.ReadBool();
				previousConfused = confused;
				confused = packet.ReadBool();
				previousSuppressionLevel = suppressionLevel;
				suppressionLevel = packet.ReadFloat();
				if (full)
				{
					num++;
					byte b3 = packet.ReadByte();
					if (b3 > 0)
					{
						if (linkData == null)
						{
							linkData = new float[b3][];
						}
						for (int k = 0; k < b3; k++)
						{
							if (linkData[k] == null || linkData[k].Length != 5)
							{
								linkData[k] = new float[5];
							}
							for (int l = 0; l < 5; l++)
							{
								linkData[k][l] = packet.ReadFloat();
							}
						}
					}
					num++;
					IFF = packet.ReadByte();
					configTemplate = packet.ReadSosigConfig();
					byte b4 = packet.ReadByte();
					wearables = new List<List<string>>();
					for (int m = 0; m < b4; m++)
					{
						wearables.Add(new List<string>());
						byte b5 = packet.ReadByte();
						if (b5 > 0)
						{
							for (int n = 0; n < b5; n++)
							{
								wearables[m].Add(packet.ReadString());
							}
						}
					}
					num++;
					IFFChart = SosigTargetPrioritySystemPatch.IntToBoolArr(packet.ReadInt());
					num++;
					int num2 = packet.ReadInt();
					if (num2 > 0)
					{
						data = packet.ReadBytes(num2);
					}
					num++;
					SosigOrder val = currentOrder;
					SosigOrder val2 = val;
					switch (val2 - 1)
					{
					case 0:
						guardPoint = packet.ReadVector3();
						guardDir = packet.ReadVector3();
						hardGuard = packet.ReadBool();
						break;
					case 1:
						skirmishPoint = packet.ReadVector3();
						pathToPoint = packet.ReadVector3();
						assaultPoint = packet.ReadVector3();
						faceTowards = packet.ReadVector3();
						break;
					case 2:
						guardPoint = packet.ReadVector3();
						hardGuard = packet.ReadBool();
						faceTowards = packet.ReadVector3();
						break;
					case 3:
					case 5:
						wanderPoint = packet.ReadVector3();
						break;
					case 6:
						assaultPoint = packet.ReadVector3();
						assaultSpeed = (SosigMoveSpeed)packet.ReadByte();
						faceTowards = packet.ReadVector3();
						break;
					case 8:
						idleToPoint = packet.ReadVector3();
						idleDominantDir = packet.ReadVector3();
						break;
					case 9:
						pathToPoint = packet.ReadVector3();
						pathToLookDir = packet.ReadVector3();
						break;
					}
					num++;
					byte b6 = packet.ReadByte();
					inventory = new int[b6];
					for (int num3 = 0; num3 < b6; num3++)
					{
						inventory[num3] = packet.ReadInt();
					}
					num++;
				}
			}
			catch (Exception ex)
			{
				Mod.LogError("Sosig " + trackedID + " with local index " + localWaitingIndex + ", update from packet with size: " + packet.buffer.Count + " error at step: " + num + ": " + ex.Message + ":\n" + ex.StackTrace);
			}
			if (!((Object)(object)physicalSosig != (Object)null))
			{
				return;
			}
			((Component)physicalSosig.physicalSosig.Agent).transform.position = agentPosition;
			physicalSosig.physicalSosig.FallbackOrder = fallbackOrder;
			physicalSosig.physicalSosig.Mustard = mustard;
			physicalSosig.physicalSosig.SetBodyPose(bodyPose);
			physicalSosig.physicalSosig.Inventory.m_ammoStores = ammoStores;
			for (int num4 = 0; num4 < physicalSosig.physicalSosig.Links.Count; num4++)
			{
				if ((Object)(object)physicalSosig.physicalSosig.Links[num4] != (Object)null && previousLinkIntegrity[num4] != linkIntegrity[num4])
				{
					physicalSosig.physicalSosig.Links[num4].m_integrity = linkIntegrity[num4];
					physicalSosig.physicalSosig.UpdateRendererOnLink(num4);
				}
			}
			if (previousJointLimit != jointLimit)
			{
				physicalSosig.physicalSosig.UpdateJoints(Mathf.InverseLerp(60f, physicalSosig.physicalSosig.m_maxJointLimit, jointLimit));
			}
			physicalSosig.physicalSosig.m_isUnconscious = unconscious;
			physicalSosig.physicalSosig.m_isBlinded = blinded;
			physicalSosig.physicalSosig.m_isConfused = confused;
			physicalSosig.physicalSosig.m_suppressionLevel = suppressionLevel;
		}

		public override bool Update(bool full = false)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			bool flag = base.Update(full);
			if ((Object)(object)physicalSosig == (Object)null)
			{
				return false;
			}
			position = (((Object)(object)physicalSosig.physicalSosig.CoreRB == (Object)null) ? previousPos : physicalSosig.physicalSosig.CoreRB.position);
			bool flag2 = false;
			if (Vector3.Distance(previousPos, position) > 0.02f)
			{
				previousPos = position;
				flag2 = true;
			}
			_ = previousPos;
			velocity = position - previousPos;
			rotation = (((Object)(object)physicalSosig.physicalSosig.CoreRB == (Object)null) ? previousRot : physicalSosig.physicalSosig.CoreRB.rotation);
			bool flag3 = false;
			if (Quaternion.Angle(previousRot, rotation) > 5f)
			{
				previousRot = rotation;
				flag3 = true;
			}
			previousAgentPos = agentPosition;
			agentPosition = ((Component)physicalSosig.physicalSosig.Agent).transform.position;
			previousBodyPose = bodyPose;
			bodyPose = physicalSosig.physicalSosig.BodyPose;
			ammoStores = physicalSosig.physicalSosig.Inventory.m_ammoStores;
			if (ammoStores != null && previousAmmoStores == null)
			{
				previousAmmoStores = new int[ammoStores.Length];
			}
			bool flag4 = false;
			for (int i = 0; i < ammoStores.Length; i++)
			{
				if (ammoStores[i] != previousAmmoStores[i])
				{
					flag4 = true;
				}
				previousAmmoStores[i] = ammoStores[i];
			}
			previousAmmoStores = ammoStores;
			previousMustard = mustard;
			mustard = physicalSosig.physicalSosig.Mustard;
			previousLinkIntegrity = linkIntegrity;
			if (linkIntegrity == null || linkIntegrity.Length < physicalSosig.physicalSosig.Links.Count)
			{
				linkIntegrity = new float[physicalSosig.physicalSosig.Links.Count];
				previousLinkIntegrity = new float[physicalSosig.physicalSosig.Links.Count];
			}
			bool flag5 = false;
			for (int j = 0; j < physicalSosig.physicalSosig.Links.Count; j++)
			{
				linkIntegrity[j] = physicalSosig.physicalSosig.Links[j].m_integrity;
				if (linkIntegrity[j] != previousLinkIntegrity[j])
				{
					flag5 = true;
				}
			}
			fallbackOrder = physicalSosig.physicalSosig.FallbackOrder;
			previousOrder = currentOrder;
			currentOrder = physicalSosig.physicalSosig.CurrentOrder;
			if (previousOrder != currentOrder)
			{
				if (ThreadManager.host)
				{
					if (trackedID != -1)
					{
						ServerSend.SosigSetCurrentOrder(this, currentOrder);
					}
				}
				else if (trackedID != -1)
				{
					ClientSend.SosigSetCurrentOrder(this, currentOrder);
				}
				else if (TrackedSosig.unknownCurrentOrder.ContainsKey(localWaitingIndex))
				{
					TrackedSosig.unknownCurrentOrder[localWaitingIndex] = currentOrder;
				}
				else
				{
					TrackedSosig.unknownCurrentOrder.Add(localWaitingIndex, currentOrder);
				}
			}
			previousJointLimit = jointLimit;
			for (int k = 0; k < physicalSosig.physicalSosig.m_joints.Count; k++)
			{
				if ((Object)(object)physicalSosig.physicalSosig.m_joints[k] != (Object)null)
				{
					SoftJointLimit highTwistLimit = physicalSosig.physicalSosig.m_joints[k].highTwistLimit;
					jointLimit = ((SoftJointLimit)(ref highTwistLimit)).limit;
					break;
				}
			}
			previousUnconscious = unconscious;
			unconscious = physicalSosig.physicalSosig.IsUnconscious;
			previousBlinded = blinded;
			blinded = physicalSosig.physicalSosig.IsBlinded;
			previousConfused = confused;
			confused = physicalSosig.physicalSosig.IsConfused;
			previousSuppressionLevel = suppressionLevel;
			suppressionLevel = physicalSosig.physicalSosig.SuppressionLevel;
			return flag || flag4 || flag5 || flag2 || flag3 || NeedsUpdate();
		}

		public override bool NeedsUpdate()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return base.NeedsUpdate() || previousAgentPos != agentPosition || previousMustard != mustard || previousJointLimit != jointLimit || previousUnconscious != unconscious || previousBlinded != blinded || previousConfused != confused || previousSuppressionLevel != suppressionLevel;
		}

		public override void OnTrackedIDReceived(TrackedObjectData newData)
		{
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			base.OnTrackedIDReceived(newData);
			if (TrackedSosig.unknownTNHKills.ContainsKey(localWaitingIndex))
			{
				ClientSend.TNHSosigKill(TrackedSosig.unknownTNHKills[localWaitingIndex], trackedID);
				TrackedSosig.unknownTNHKills.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedSosig.unknownItemInteract.ContainsKey(localWaitingIndex))
			{
				List<KeyValuePair<int, KeyValuePair<TrackedItemData, int>>> list = TrackedSosig.unknownItemInteract[localWaitingIndex];
				for (int i = 0; i < list.Count; i++)
				{
					switch (list[i].Key)
					{
					case 0:
						if (list[i].Value.Key.trackedID != -1)
						{
							ClientSend.SosigPickUpItem(physicalSosig, list[i].Value.Key.trackedID, list[i].Value.Value == 0);
							inventory[list[i].Value.Value] = list[i].Value.Key.trackedID;
						}
						break;
					case 1:
						if (list[i].Value.Key.trackedID != -1)
						{
							ClientSend.SosigPlaceItemIn(trackedID, list[i].Value.Value, list[i].Value.Key.trackedID);
							inventory[list[i].Value.Value + 2] = list[i].Value.Key.trackedID;
						}
						break;
					case 2:
						ClientSend.SosigDropSlot(trackedID, list[i].Value.Value);
						inventory[list[i].Value.Value + 2] = -1;
						break;
					case 3:
						ClientSend.SosigHandDrop(trackedID, list[i].Value.Value == 0);
						inventory[list[i].Value.Value] = -1;
						break;
					}
				}
				TrackedSosig.unknownItemInteract.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedSosig.unknownSetIFFs.ContainsKey(localWaitingIndex))
			{
				int iFF = TrackedSosig.unknownSetIFFs[localWaitingIndex];
				ClientSend.SosigSetIFF(trackedID, iFF);
				TrackedSosig.unknownSetIFFs.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedSosig.unknownSetOriginalIFFs.ContainsKey(localWaitingIndex))
			{
				int iFF2 = TrackedSosig.unknownSetOriginalIFFs[localWaitingIndex];
				ClientSend.SosigSetOriginalIFF(trackedID, iFF2);
				TrackedSosig.unknownSetOriginalIFFs.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedSosig.unknownBodyStates.ContainsKey(localWaitingIndex))
			{
				SosigBodyState s = TrackedSosig.unknownBodyStates[localWaitingIndex];
				ClientSend.SosigSetBodyState(trackedID, s);
				TrackedSosig.unknownBodyStates.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedSosig.unknownIFFChart.ContainsKey(localWaitingIndex))
			{
				ClientSend.SosigPriorityIFFChart(trackedID, TrackedSosig.unknownIFFChart[localWaitingIndex]);
				TrackedSosig.unknownIFFChart.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedSosig.unknownCurrentOrder.ContainsKey(localWaitingIndex))
			{
				ClientSend.SosigSetCurrentOrder(this, TrackedSosig.unknownCurrentOrder[localWaitingIndex]);
				TrackedSosig.unknownCurrentOrder.Remove(localWaitingIndex);
			}
			if (localTrackedID != -1 && TrackedSosig.unknownConfiguration.ContainsKey(localWaitingIndex))
			{
				ClientSend.SosigConfigure(trackedID, TrackedSosig.unknownConfiguration[localWaitingIndex]);
				TrackedSosig.unknownConfiguration.Remove(localWaitingIndex);
			}
			if (localTrackedID == -1 || !TrackedSosig.unknownWearable.TryGetValue(localWaitingIndex, out var value))
			{
				return;
			}
			foreach (KeyValuePair<string, List<int>> item in value)
			{
				for (int j = 0; j < item.Value.Count; j++)
				{
					ClientSend.SosigLinkRegisterWearable(trackedID, item.Value[j], item.Key);
				}
			}
			TrackedSosig.unknownWearable.Remove(localWaitingIndex);
		}

		public override void RemoveFromLocal()
		{
			base.RemoveFromLocal();
			if (trackedID != -1)
			{
				return;
			}
			TrackedSosig.unknownItemInteract.Remove(localWaitingIndex);
			TrackedSosig.unknownSetIFFs.Remove(localWaitingIndex);
			TrackedSosig.unknownSetOriginalIFFs.Remove(localWaitingIndex);
			TrackedSosig.unknownBodyStates.Remove(localWaitingIndex);
			TrackedSosig.unknownTNHKills.Remove(localWaitingIndex);
			TrackedSosig.unknownIFFChart.Remove(localWaitingIndex);
			TrackedSosig.unknownCurrentOrder.Remove(localWaitingIndex);
			TrackedSosig.unknownConfiguration.Remove(localWaitingIndex);
			TrackedSosig.unknownWearable.Remove(localWaitingIndex);
			if ((Object)(object)physicalSosig != (Object)null && (Object)(object)physicalSosig.physicalSosig != (Object)null)
			{
				GameManager.trackedSosigBySosig.Remove(physicalSosig.physicalSosig);
				for (int i = 0; i < physicalSosig.physicalSosig.Links.Count; i++)
				{
					GameManager.trackedObjectByInteractive.Remove((FVRInteractiveObject)(object)physicalSosig.physicalSosig.Links[i].O);
					GameManager.trackedObjectByDamageable.Remove((IFVRDamageable)(object)physicalSosig.physicalSosig.Links[i]);
				}
			}
		}

		public void TakeInventoryControl()
		{
			Mod.LogInfo("Taking sosig " + trackedID + " control");
			for (int i = 0; i < inventory.Length; i++)
			{
				Mod.LogInfo("\tChecking inventory " + i);
				if (inventory[i] == -1)
				{
					continue;
				}
				TrackedObjectData[] array = (ThreadManager.host ? Server.objects : Client.objects);
				if (array[inventory[i]] != null && array[inventory[i]].controller != GameManager.ID)
				{
					TrackedItemData trackedItemData = array[inventory[i]] as TrackedItemData;
					trackedItemData.TakeControlRecursive();
					if ((Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						Mod.SetKinematicRecursive(((Component)trackedItemData.physicalItem).transform, value: false);
					}
				}
			}
		}

		public override void OnControlChanged(int newController)
		{
			base.OnControlChanged(newController);
			if (newController == GameManager.ID)
			{
				if (inventory != null)
				{
					TakeInventoryControl();
				}
				if ((Object)(object)physicalSosig != (Object)null && (Object)(object)physicalSosig.physicalSosig != (Object)null)
				{
					if ((Object)(object)GM.CurrentAIManager != (Object)null)
					{
						GM.CurrentAIManager.RegisterAIEntity(physicalSosig.physicalSosig.E);
					}
					if ((Object)(object)physicalSosig.physicalSosig.CoreRB != (Object)null)
					{
						physicalSosig.physicalSosig.CoreRB.isKinematic = false;
					}
				}
			}
			else if (base.controller == GameManager.ID && (Object)(object)physicalSosig != (Object)null && (Object)(object)physicalSosig.physicalSosig != (Object)null)
			{
				physicalSosig.EnsureUncontrolled();
				if ((Object)(object)GM.CurrentAIManager != (Object)null)
				{
					GM.CurrentAIManager.DeRegisterAIEntity(physicalSosig.physicalSosig.E);
				}
				if ((Object)(object)physicalSosig.physicalSosig.CoreRB != (Object)null)
				{
					physicalSosig.physicalSosig.CoreRB.isKinematic = true;
				}
			}
		}
	}
}
namespace H3MP.Scripts
{
	public class Billboard : MonoBehaviour
	{
		private void Update()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (!GameManager.spectatorHost && (Object)(object)Camera.main != (Object)null)
			{
				Quaternion rotation = ((Component)Camera.main).transform.rotation;
				Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
				eulerAngles.z = 0f;
				((Component)this).transform.rotation = Quaternion.Euler(eulerAngles);
			}
		}
	}
	public class BodyWristMenuSection : FVRWristMenuSection
	{
		private delegate void ButtonClick(Text text);

		public static bool init;

		private Dictionary<int, List<KeyValuePair<FVRPointableButton, Vector3>>> pages;

		private int currentPage = -1;

		public static Text playerBodyText;

		public static Text colorText;

		public static Text visibilityText;

		public static Text handText;

		public static Text selfHideText;

		public override void Enable()
		{
			InitButtons();
			SetPage(0);
		}

		private void InitButtons()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			if (pages == null)
			{
				pages = new Dictionary<int, List<KeyValuePair<FVRPointableButton, Vector3>>>();
				Image val = ((Component)this).gameObject.AddComponent<Image>();
				((Graphic)val).rectTransform.sizeDelta = new Vector2(500f, 350f);
				((Graphic)val).color = new Color(0.1f, 0.1f, 0.1f, 1f);
				Text textOut = null;
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(0f, 150f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnPlayerBodyClicked, "Body: " + GameManager.playerPrefabID, out playerBodyText);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(155f, 150f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnNextPlayerBodyClicked, ">", out textOut);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(-155f, 150f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnPreviousPlayerBodyClicked, "<", out textOut);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(0f, 100f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnColorClicked, "Current color: " + GameManager.colorNames[GameManager.colorIndex], out colorText);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(155f, 100f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnNextColorClicked, ">", out textOut);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(-155f, 100f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnPreviousColorClicked, "<", out textOut);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(0f, 50f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnVisibleClicked, "Visible: " + (((Object)(object)GameManager.currentPlayerBody != (Object)null && GameManager.currentPlayerBody.bodyRenderers != null && GameManager.currentPlayerBody.bodyRenderers.Length != 0 && GameManager.currentPlayerBody.bodyRenderers[0].enabled) ? "True" : "False"), out visibilityText);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(0f, 0f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnHandsClicked, "Hands visible: " + (((Object)(object)GameManager.currentPlayerBody != (Object)null && GameManager.currentPlayerBody.handRenderers != null && GameManager.currentPlayerBody.handRenderers.Length != 0 && GameManager.currentPlayerBody.handRenderers[0].enabled) ? "True" : "False"), out handText);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(0f, -50f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnSelfHideClicked, "Auto-hide self: " + (PlayerBody.optionAutoHideSelf ? "True" : "False"), out selfHideText);
			}
		}

		private void InitButton(List<int> pageIndices, List<Vector3> positions, Vector2 sizeDelta, Vector2 boxSize, ButtonClick clickMethod, string defaultText, out Text textOut)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(base.Menu.BaseButton, ((Component)this).transform);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.sizeDelta = sizeDelta;
			((Component)((Transform)component).GetChild(0)).GetComponent<RectTransform>().sizeDelta = sizeDelta;
			BoxCollider component2 = val.GetComponent<BoxCollider>();
			component2.size = new Vector3(boxSize.x, boxSize.y, component2.size.z);
			val.transform.localPosition = positions[0];
			val.transform.localRotation = Quaternion.identity;
			Object.Destroy((Object)(object)val.GetComponent<FVRWristMenuSectionButton>());
			val.GetComponent<Text>().text = defaultText;
			FVRPointableButton component3 = val.GetComponent<FVRPointableButton>();
			Text buttonText = val.GetComponent<Text>();
			textOut = buttonText;
			((UnityEvent)component3.Button.onClick).AddListener((UnityAction)delegate
			{
				clickMethod(buttonText);
			});
			for (int num = 0; num < pageIndices.Count; num++)
			{
				if (pages.TryGetValue(pageIndices[num], out var value))
				{
					value.Add(new KeyValuePair<FVRPointableButton, Vector3>(component3, positions[num]));
					continue;
				}
				KeyValuePair<FVRPointableButton, Vector3> item = new KeyValuePair<FVRPointableButton, Vector3>(component3, positions[num]);
				pages.Add(pageIndices[num], new List<KeyValuePair<FVRPointableButton, Vector3>> { item });
			}
		}

		private void OnColorClicked(Text textRef)
		{
		}

		private void OnNextColorClicked(Text textRef)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.colorByIFF)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			GameManager.colorIndex++;
			if (GameManager.colorIndex >= GameManager.colors.Length)
			{
				GameManager.colorIndex = 0;
			}
			GameManager.SetPlayerColor(GameManager.ID, GameManager.colorIndex);
		}

		private void OnPreviousColorClicked(Text textRef)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.colorByIFF)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			GameManager.colorIndex--;
			if (GameManager.colorIndex < 0)
			{
				GameManager.colorIndex = GameManager.colors.Length - 1;
			}
			GameManager.SetPlayerColor(GameManager.ID, GameManager.colorIndex);
		}

		private void OnPlayerBodyClicked(Text textRef)
		{
		}

		private void OnNextPlayerBodyClicked(Text textRef)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.playerModelAwaitingInstantiation)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			GameManager.playerPrefabIndex++;
			if (GameManager.playerPrefabIndex >= GameManager.playerPrefabIDs.Count)
			{
				if ((Object)(object)Mod.managerObject == (Object)null)
				{
					GameManager.playerPrefabIndex = -1;
				}
				else
				{
					GameManager.playerPrefabIndex = 0;
				}
			}
			ProcessPlayerPrefabIndex(GameManager.playerPrefabIndex, playerBodyText);
		}

		private void OnPreviousPlayerBodyClicked(Text textRef)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.playerModelAwaitingInstantiation)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			GameManager.playerPrefabIndex--;
			if (((Object)(object)Mod.managerObject != (Object)null && GameManager.playerPrefabIndex < 0) || ((Object)(object)Mod.managerObject == (Object)null && GameManager.playerPrefabIndex < -1))
			{
				GameManager.playerPrefabIndex = GameManager.playerPrefabIDs.Count - 1;
			}
			ProcessPlayerPrefabIndex(GameManager.playerPrefabIndex, playerBodyText);
		}

		private void ProcessPlayerPrefabIndex(int index, Text text)
		{
			if (GameManager.playerPrefabIndex == -1)
			{
				GameManager.playerPrefabID = "None";
				if ((Object)(object)GameManager.currentPlayerBody != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)GameManager.currentPlayerBody).gameObject);
				}
				text.text = "Body: None";
			}
			else
			{
				string text2 = GameManager.playerPrefabIDs[GameManager.playerPrefabIndex];
				if (!GameManager.playerPrefabID.Equals(text2))
				{
					GameManager.SetPlayerPrefab(text2);
				}
			}
		}

		private void OnVisibleClicked(Text textRef)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameManager.currentPlayerBody == (Object)null || GameManager.currentPlayerBody.bodyRenderers == null || GameManager.currentPlayerBody.bodyRenderers.Length == 0)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			GameManager.bodyVisible = !GameManager.bodyVisible;
			GameManager.currentPlayerBody.SetBodyVisible(GameManager.bodyVisible);
			visibilityText.text = "Visible: " + GameManager.bodyVisible;
		}

		private void OnHandsClicked(Text textRef)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameManager.currentPlayerBody == (Object)null || GameManager.currentPlayerBody.handRenderers == null || GameManager.currentPlayerBody.handRenderers.Length == 0)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			GameManager.handsVisible = !GameManager.handsVisible;
			GameManager.currentPlayerBody.SetHandsVisible(GameManager.handsVisible);
			handText.text = "Hands visible: " + GameManager.handsVisible;
		}

		private void OnSelfHideClicked(Text textRef)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameManager.currentPlayerBody == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			GameManager.currentPlayerBody.ToggleSelfHide();
			selfHideText.text = "Auto-hide self: " + (PlayerBody.optionAutoHideSelf ? "True" : "False");
		}

		private void SetPage(int index)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (currentPage != -1 && pages.TryGetValue(currentPage, out var value))
			{
				for (int i = 0; i < value.Count; i++)
				{
					((Component)value[i].Key).gameObject.SetActive(false);
				}
			}
			if (pages.TryGetValue(index, out var value2))
			{
				for (int j = 0; j < value2.Count; j++)
				{
					((Component)value2[j].Key).gameObject.SetActive(true);
					((Transform)((Component)value2[j].Key).GetComponent<RectTransform>()).localPosition = value2[j].Value;
				}
			}
			currentPage = index;
		}
	}
	public class ControllerReference : MonoBehaviour
	{
		public int controller = 0;
	}
	public class H3MPHoverScroll : FVRPointableButton
	{
		public AudioSource hoverSound;

		public Scrollbar scrollbar;

		public H3MPHoverScroll other;

		public bool up;

		public float rate;

		private bool scrolling;

		public override void Update()
		{
			((FVRPointableButton)this).Update();
			if (!scrolling)
			{
				return;
			}
			((Component)other).gameObject.SetActive(true);
			if (up)
			{
				Scrollbar obj = scrollbar;
				obj.value += rate * Time.deltaTime * 1.5f;
				if (scrollbar.value >= 1f)
				{
					scrollbar.value = 1f;
					scrolling = false;
					((Component)this).gameObject.SetActive(false);
				}
			}
			else
			{
				Scrollbar obj2 = scrollbar;
				obj2.value -= rate * Time.deltaTime * 1.5f;
				if (scrollbar.value <= 0f)
				{
					scrollbar.value = 0f;
					scrolling = false;
					((Component)this).gameObject.SetActive(false);
				}
			}
		}

		public override void BeginHoverDisplay()
		{
			((FVRPointable)this).BeginHoverDisplay();
			scrolling = true;
		}

		public override void EndHoverDisplay()
		{
			((FVRPointable)this).EndHoverDisplay();
			scrolling = false;
		}
	}
	public class Keyboard : MonoBehaviour
	{
		private bool shifted;

		public Text[] letterTexts;

		public TextField field;

		public void KeyPressed(string key)
		{
			if ((Object)(object)field == (Object)null)
			{
				return;
			}
			char result2;
			if (int.TryParse(key, out var _))
			{
				Text text = field.text;
				text.text += key;
			}
			else if (key.Equals(",") || key.Equals(".") || key.Equals(" "))
			{
				Text text2 = field.text;
				text2.text += key;
			}
			else if (key.Equals("<"))
			{
				if (field.text.text != "")
				{
					field.text.text = field.text.text.Substring(0, field.text.text.Length - 1);
				}
			}
			else if (char.TryParse(key, out result2))
			{
				if (!field.digitsOnly)
				{
					if (shifted)
					{
						Text text3 = field.text;
						text3.text += key.ToUpper();
					}
					else
					{
						Text text4 = field.text;
						text4.text += key;
					}
				}
			}
			else if (key.Equals("shift"))
			{
				shifted = !shifted;
				if (letterTexts != null)
				{
					if (shifted)
					{
						for (int i = 0; i < letterTexts.Length; i++)
						{
							letterTexts[i].text = letterTexts[i].text.ToUpper();
						}
					}
					else
					{
						for (int j = 0; j < letterTexts.Length; j++)
						{
							letterTexts[j].text = letterTexts[j].text.ToLower();
						}
					}
				}
			}
			else if (key.Equals("exit"))
			{
				Object.Destroy((Object)(object)field.keyboardObject);
				field.keyboard = null;
				field.keyboardObject = null;
			}
			if (field.text.text != "")
			{
				field.clearButton.SetActive(true);
			}
		}
	}
	public class KinematicMarker : MonoBehaviour
	{
	}
	public class OffsetFollower : MonoBehaviour
	{
		public Transform transformToFollow;

		public Vector3 offset;

		public Vector3 rotationAxes;

		public void Update()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = transformToFollow.position;
			Transform transform = ((Component)this).transform;
			transform.localPosition += offset;
			Quaternion rotation = transformToFollow.rotation;
			float num = ((Quaternion)(ref rotation)).eulerAngles.x * rotationAxes.x;
			rotation = transformToFollow.rotation;
			float num2 = ((Quaternion)(ref rotation)).eulerAngles.y * rotationAxes.y;
			rotation = transformToFollow.rotation;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(num, num2, ((Quaternion)(ref rotation)).eulerAngles.z * rotationAxes.z);
			((Component)this).transform.rotation = Quaternion.Euler(val);
		}
	}
	public class OverheadDisplay : MonoBehaviour
	{
		public Transform head;

		public Vector3 offset;

		private void Update()
		{
			//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_0018: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = head.position + offset;
		}
	}
	public class PlayerHitbox : MonoBehaviour, IFVRDamageable
	{
		[NonSerialized]
		public PlayerManager manager;

		public bool isHead;

		public float damageMultiplier = 1f;

		public void Damage(Damage dam)
		{
			if ((Object)(object)manager == (Object)null)
			{
				Mod.LogError("PlayerHitbox " + ((Object)this).name + " was damaged but is missing ref to manager.");
			}
			else
			{
				manager.Damage(damageMultiplier, isHead, dam);
			}
		}
	}
	public class PlayerManager : MonoBehaviour
	{
		public int ID;

		public string username;

		public TrackedPlayerBody playerBody;

		public Transform head;

		public Transform leftHand;

		public Transform rightHand;

		public int IFF;

		public int colorIndex;

		public float health;

		public int maxHealth;

		public TAH_ReticleContact reticleContact;

		public string scene;

		public int instance;

		public bool firstInSceneInstance;

		public bool visible;

		public void Init(int ID, string username, string scene, int instance, int IFF, int colorIndex)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			this.ID = ID;
			this.username = username;
			this.scene = scene;
			this.instance = instance;
			this.IFF = IFF;
			this.colorIndex = colorIndex;
			GameObject val = new GameObject("Head");
			val.transform.parent = ((Component)this).transform;
			head = val.transform;
			GameObject val2 = new GameObject("LeftHand");
			val2.transform.parent = ((Component)this).transform;
			leftHand = val2.transform;
			GameObject val3 = new GameObject("RightHand");
			val3.transform.parent = ((Component)this).transform;
			rightHand = val3.transform;
			GameManager.OnPlayerBodyInit += OnPlayerBodyInit;
		}

		public void Damage(float damageMultiplier, bool head, Damage damage)
		{
			if (ID != -1)
			{
				if (ThreadManager.host)
				{
					ServerSend.PlayerDamage(ID, damageMultiplier, head, damage);
				}
				else
				{
					ClientSend.PlayerDamage(ID, damageMultiplier, head, damage);
				}
			}
			else
			{
				Mod.LogInfo("Dummy player has receive damage with mult: " + damageMultiplier);
			}
		}

		public void SetVisible(bool visible)
		{
			this.visible = visible;
			if ((Object)(object)playerBody != (Object)null)
			{
				((Component)playerBody).gameObject.SetActive(visible);
			}
			if (visible && (Object)(object)reticleContact == (Object)null && Mod.currentTNHInstance != null && (Object)(object)Mod.currentTNHInstance.manager != (Object)null && (Object)(object)Mod.currentTNHInstance.manager.TAHReticle != (Object)null)
			{
				reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(head, (ContactType)((!GameManager.radarColor) ? (colorIndex - 4) : ((IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
			}
			else
			{
				if (visible || !((Object)(object)reticleContact != (Object)null))
				{
					return;
				}
				for (int num = GM.TNH_Manager.TAHReticle.Contacts.Count - 1; num >= 0; num--)
				{
					if ((Object)(object)GM.TNH_Manager.TAHReticle.Contacts[num] == (Object)(object)reticleContact)
					{
						GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[num].TrackedTransform);
						Object.Destroy((Object)(object)((Component)GM.TNH_Manager.TAHReticle.Contacts[num]).gameObject);
						GM.TNH_Manager.TAHReticle.Contacts.RemoveAt(num);
						reticleContact = null;
						break;
					}
				}
			}
		}

		public void SetIFF(int IFF, bool spawned = true)
		{
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			int iFF = this.IFF;
			this.IFF = IFF;
			if ((Object)(object)GM.CurrentPlayerBody == (Object)null || (Object)(object)playerBody == (Object)null)
			{
				return;
			}
			playerBody.physicalPlayerBody.SetIFF(IFF);
			if (GameManager.colorByIFF && spawned)
			{
				SetColor(IFF);
			}
			playerBody.physicalPlayerBody.SetCanvasesEnabled(GameManager.nameplateMode == 0 || (GameManager.nameplateMode == 1 && GM.CurrentPlayerBody.GetPlayerIFF() == IFF));
			if (GameManager.radarMode == 1)
			{
				if (visible && Mod.currentTNHInstance != null && (Object)(object)Mod.currentTNHInstance.manager != (Object)null && Mod.currentTNHInstance.currentlyPlaying.Contains(ID) && (Object)(object)reticleContact == (Object)null)
				{
					reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(head, (ContactType)((!GameManager.radarColor) ? (colorIndex - 4) : ((IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
				}
				else if (!visible || Mod.currentTNHInstance == null || (Object)(object)Mod.currentTNHInstance.manager == (Object)null || !Mod.currentTNHInstance.currentlyPlaying.Contains(ID) || (Object)(object)reticleContact != (Object)null)
				{
					for (int num = GM.TNH_Manager.TAHReticle.Contacts.Count - 1; num >= 0; num--)
					{
						if ((Object)(object)GM.TNH_Manager.TAHReticle.Contacts[num] == (Object)(object)reticleContact)
						{
							GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[num].TrackedTransform);
							Object.Destroy((Object)(object)((Component)GM.TNH_Manager.TAHReticle.Contacts[num]).gameObject);
							GM.TNH_Manager.TAHReticle.Contacts.RemoveAt(num);
							reticleContact = null;
							break;
						}
					}
				}
			}
			if (GameManager.radarColor && (Object)(object)reticleContact != (Object)null)
			{
				reticleContact.R_Arrow.material.color = ((IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? Color.green : Color.red);
				reticleContact.R_Icon.material.color = ((IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? Color.green : Color.red);
			}
		}

		public void SetColor(int colorIndex)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (this.colorIndex != colorIndex)
			{
				this.colorIndex = Mathf.Abs(colorIndex % GameManager.colors.Length);
				if ((Object)(object)playerBody != (Object)null)
				{
					playerBody.physicalPlayerBody.SetColor(GameManager.colors[colorIndex]);
				}
			}
			if (!GameManager.radarColor && (Object)(object)reticleContact != (Object)null)
			{
				reticleContact.R_Arrow.material.color = GameManager.colors[colorIndex];
				reticleContact.R_Icon.material.color = GameManager.colors[colorIndex];
			}
		}

		private void OnPlayerBodyInit(FVRPlayerBody playerBody)
		{
			SetIFF(IFF);
		}

		private void OnDestroy()
		{
			GameManager.OnPlayerBodyInit -= OnPlayerBodyInit;
		}
	}
	public class PlayerBody : MonoBehaviour
	{
		public enum HeadDisplayMode
		{
			RendererToggle,
			LayerToggle,
			Physical
		}

		public string playerPrefabID;

		[Header("Head settings")]
		public Transform headTransform;

		[Tooltip("RendererToggle: Head renderers will be toggled depending on whether the player body is yours or another player's.\nLayerToggle: Head renderers' layers will be toggled between ExternalCamOnly and default depending on whether the player body is yours or another player's.\nPhysical: Will assume that head will be out of view of VR camera.")]
		public HeadDisplayMode headDisplayMode;

		[Tooltip("If headDisplayMode is set to Physical, headRenderers will not be used.")]
		public Renderer[] headRenderers;

		[NonSerialized]
		public Transform headToFollow;

		[Header("Hand settings")]
		[Tooltip("0: Left, 1: Right.")]
		public Transform[] handTransforms;

		[NonSerialized]
		public Transform[] handsToFollow;

		[Header("Other")]
		[Tooltip("All colliders. These will be disabled if the body is yours, since the vanilla colliders and hitboxes should be used instead.")]
		public Collider[] colliders;

		[Tooltip("See colliders tooltip above. Put in this array colliders you want to have enabled when the body is yours, and disabled when it isn't. For example, a trigger collider that acts as a toggle for some custom functionality with your body. You would want that enabled when the body is the player's because you want them to be able to toggle that functionality on their own body. On the other hand, you want it disabled when the body is another player's because you don't want other players to be able to toggle the functionality on everyone else's bodies.")]
		public Collider[] negativeColliders;

		[Tooltip("All colliders you want to have ignored. See colliders tooltip above. Put in this array any collider that you want to have ignored.")]
		public Collider[] ignoredColliders;

		[Tooltip("All AIEntities. These will be de/registered as necessary so remote players' bodies can be detected by AI.")]
		public AIEntity[] entities;

		[Tooltip("All UI canvases. These will be disabled if the body is yours, since vanilla health UI for example should be used instead.")]
		public Canvas[] canvases;

		[Tooltip("All hitboxes. These will have their manager intialized if this is another player's body.")]
		public PlayerHitbox[] hitboxes;

		[Header("Optionals")]
		[Tooltip("If set, will enable wristmenu option to toggle body.")]
		public Renderer[] bodyRenderers;

		[NonSerialized]
		public int[] bodyRendererLayers;

		[Tooltip("If set, will enable wristmenu option to toggle hands.")]
		public Renderer[] handRenderers;

		[NonSerialized]
		public int[] handRendererLayers;

		[Tooltip("All parts that you want to have change color with the color the player has set.")]
		public Renderer[] coloredParts;

		public Text usernameLabel;

		public Text healthLabel;

		public static bool optionAutoHideSelf = true;

		private const float SELF_HIDE_PITCH = 54f;

		private const float SELF_UNHIDE_PITCH = 50f;

		private const float SELF_UNHIDE_DELAY = 0.5f;

		private bool selfIsHidden = false;

		private bool selfIsUnhiding = false;

		public FVRViveHand[] handScripts;

		public virtual void Awake()
		{
			GameManager.OnPlayerBodyInit += OnPlayerBodyInit;
			Verify();
			if (bodyRenderers != null)
			{
				bodyRendererLayers = new int[bodyRenderers.Length];
				for (int i = 0; i < bodyRenderers.Length; i++)
				{
					if ((Object)(object)bodyRenderers[i] != (Object)null)
					{
						bodyRendererLayers[i] = ((Component)bodyRenderers[i]).gameObject.layer;
					}
				}
			}
			if (handRenderers != null)
			{
				handRendererLayers = new int[handRenderers.Length];
				for (int j = 0; j < handRenderers.Length; j++)
				{
					if ((Object)(object)handRenderers[j] != (Object)null)
					{
						handRendererLayers[j] = ((Component)handRenderers[j]).gameObject.layer;
					}
				}
			}
			if ((Object)(object)Mod.managerObject == (Object)null && (Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				headToFollow = ((Component)GM.CurrentPlayerBody.Head).transform;
				handsToFollow = (Transform[])(object)new Transform[2];
				handsToFollow[0] = GM.CurrentPlayerBody.LeftHand;
				handsToFollow[1] = GM.CurrentPlayerBody.RightHand;
				handScripts = (FVRViveHand[])(object)new FVRViveHand[2]
				{
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>(),
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>()
				};
				if (headDisplayMode != HeadDisplayMode.Physical)
				{
					SetHeadVisible(visible: false);
				}
				SetCollidersEnabled(enabled: false);
				SetCanvasesEnabled(enabled: false);
				SetEntitiesRegistered(registered: false);
				Init();
			}
		}

		public virtual void Verify()
		{
			bool flag = true;
			if ((Object)(object)headTransform == (Object)null)
			{
				Debug.LogError((object)("PlayerBody " + playerPrefabID + ": missing head transform"));
				flag = false;
			}
			if (handTransforms == null || handTransforms.Length < 2 || (Object)(object)handTransforms[0] == (Object)null || (Object)(object)handTransforms[1] == (Object)null)
			{
				Debug.LogError((object)("PlayerBody " + playerPrefabID + ": missing hand transforms"));
				flag = false;
			}
			Collider[] componentsInChildren = ((Component)this).GetComponentsInChildren<Collider>();
			if (colliders != null && colliders.Length != 0)
			{
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (!componentsInChildren[i].enabled)
					{
						continue;
					}
					bool[] array = new bool[3];
					int num = 0;
					for (int j = 0; j < colliders.Length; j++)
					{
						if ((Object)(object)componentsInChildren[i] == (Object)(object)colliders[j])
						{
							array[0] = true;
							num++;
							break;
						}
					}
					for (int k = 0; k < negativeColliders.Length; k++)
					{
						if ((Object)(object)componentsInChildren[i] == (Object)(object)negativeColliders[k])
						{
							array[1] = true;
							num++;
							break;
						}
					}
					for (int l = 0; l < ignoredColliders.Length; l++)
					{
						if ((Object)(object)componentsInChildren[i] == (Object)(object)ignoredColliders[l])
						{
							array[3] = true;
							num++;
							break;
						}
					}
					if (num > 1)
					{
						string text = "";
						if (array[0])
						{
							text += "colliders, ";
						}
						if (array[1])
						{
							text += "negativeColliders, ";
						}
						if (array[2])
						{
							text += "ignoredColliders";
						}
						Debug.LogError((object)("PlayerBody " + playerPrefabID + ": Collider " + ((Object)componentsInChildren[i]).name + " was found in multiple colliders arrays: " + text));
						flag = false;
					}
					else if (num == 0)
					{
						Debug.LogError((object)("PlayerBody " + playerPrefabID + ": Collider " + ((Object)componentsInChildren[i]).name + " was not added to any colliders array"));
						flag = false;
					}
				}
			}
			AIEntity[] componentsInChildren2 = ((Component)this).GetComponentsInChildren<AIEntity>();
			if (entities != null && entities.Length != 0)
			{
				for (int m = 0; m < componentsInChildren2.Length; m++)
				{
					if (!((Behaviour)componentsInChildren2[m]).enabled)
					{
						continue;
					}
					bool flag2 = false;
					for (int n = 0; n < entities.Length; n++)
					{
						if ((Object)(object)componentsInChildren2[m] == (Object)(object)entities[n])
						{
							flag2 = true;
							break;
						}
					}
					if (!flag2)
					{
						Debug.LogError((object)("PlayerBody " + playerPrefabID + ": AIEntity " + ((Object)componentsInChildren2[m]).name + " was not added to entities array"));
						flag = false;
					}
				}
			}
			else
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": Entities array set automatically"));
				entities = componentsInChildren2;
				flag = false;
			}
			Canvas[] componentsInChildren3 = ((Component)this).GetComponentsInChildren<Canvas>();
			if (canvases != null && canvases.Length != 0)
			{
				for (int num2 = 0; num2 < componentsInChildren3.Length; num2++)
				{
					if (!((Behaviour)componentsInChildren3[num2]).enabled)
					{
						continue;
					}
					bool flag3 = false;
					for (int num3 = 0; num3 < canvases.Length; num3++)
					{
						if ((Object)(object)componentsInChildren3[num2] == (Object)(object)canvases[num3])
						{
							flag3 = true;
							break;
						}
					}
					if (!flag3)
					{
						Debug.LogError((object)("PlayerBody " + playerPrefabID + ": Canvas " + ((Object)componentsInChildren3[num2]).name + " was not added to canvases array"));
						flag = false;
					}
				}
			}
			else
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": Canvases array set automatically"));
				canvases = componentsInChildren3;
				flag = false;
			}
			PlayerHitbox[] componentsInChildren4 = ((Component)this).GetComponentsInChildren<PlayerHitbox>();
			if (hitboxes != null && hitboxes.Length != 0)
			{
				for (int num4 = 0; num4 < componentsInChildren4.Length; num4++)
				{
					if (!((Behaviour)componentsInChildren4[num4]).enabled)
					{
						continue;
					}
					bool flag4 = false;
					for (int num5 = 0; num5 < hitboxes.Length; num5++)
					{
						if ((Object)(object)componentsInChildren4[num4] == (Object)(object)hitboxes[num5])
						{
							flag4 = true;
							break;
						}
					}
					if (!flag4)
					{
						Debug.LogError((object)("PlayerBody " + playerPrefabID + ": Hitbox " + ((Object)componentsInChildren4[num4]).name + " was not added to hitboxes array"));
						flag = false;
					}
				}
			}
			else
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": Hitboxes array set automatically"));
				hitboxes = componentsInChildren4;
				flag = false;
			}
			if (bodyRenderers == null || bodyRenderers.Length == 0)
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": BodyRenderers array was not set. Player will not be able to toggle body visibility."));
				flag = false;
			}
			if (handRenderers == null || handRenderers.Length == 0)
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": HandRenderers array was not set. Player will not be able to toggle hand visibility."));
				flag = false;
			}
			if (coloredParts == null || coloredParts.Length == 0)
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": ColoredParts array was not set. Player will not be able to set their color."));
				flag = false;
			}
			if ((Object)(object)usernameLabel == (Object)null)
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": UsernameLabel was not set. Other players will not be able to see this player's name."));
				flag = false;
			}
			if ((Object)(object)healthLabel == (Object)null)
			{
				Debug.LogWarning((object)("PlayerBody " + playerPrefabID + ": HealthLabel was not set. Other players will not be able to see this player's health."));
				flag = false;
			}
			if (flag)
			{
				Debug.Log((object)("PlayerBody " + playerPrefabID + " verified and is setup properly."));
			}
		}

		public virtual void OnPlayerBodyInit(FVRPlayerBody playerBody)
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				headToFollow = ((Component)playerBody.Head).transform;
				handsToFollow = (Transform[])(object)new Transform[2];
				handsToFollow[0] = playerBody.LeftHand;
				handsToFollow[1] = playerBody.RightHand;
				handScripts = (FVRViveHand[])(object)new FVRViveHand[2]
				{
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>(),
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>()
				};
				if (headDisplayMode != HeadDisplayMode.Physical)
				{
					SetHeadVisible(visible: false);
				}
				SetCollidersEnabled(enabled: false);
				SetCanvasesEnabled(enabled: false);
				SetEntitiesRegistered(registered: false);
				Init();
			}
		}

		public virtual void Init()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			SetColor(GameManager.colors[GameManager.colorIndex]);
			SetBodyVisible(GameManager.bodyVisible);
			SetHandsVisible(GameManager.handsVisible);
		}

		public virtual void Update()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)headToFollow != (Object)null)
			{
				headTransform.position = headToFollow.position;
				headTransform.rotation = headToFollow.rotation;
			}
			if (handsToFollow == null)
			{
				return;
			}
			for (int i = 0; i < handsToFollow.Length; i++)
			{
				if ((Object)(object)handsToFollow[i] != (Object)null)
				{
					handTransforms[i].position = handsToFollow[i].position;
					handTransforms[i].rotation = handsToFollow[i].rotation;
				}
			}
			if (!((Object)(object)GameManager.currentPlayerBody == (Object)(object)this) || !optionAutoHideSelf)
			{
				return;
			}
			bool flag = IsUsingQuickbelt();
			Quaternion rotation = headToFollow.rotation;
			float x = ((Quaternion)(ref rotation)).eulerAngles.x;
			if (!selfIsHidden)
			{
				if (flag)
				{
					SetPOVBodyVisible(visible: false);
					SetPOVHandsVisible(visible: false);
					selfIsHidden = true;
				}
			}
			else if (!selfIsUnhiding && (x < 50f || (180f < x && x < 360f)))
			{
				AnvilManager.Run(SelfUnhideCoroutine());
			}
		}

		public void ToggleSelfHide()
		{
			optionAutoHideSelf = !optionAutoHideSelf;
			if (!optionAutoHideSelf)
			{
				selfIsHidden = false;
				selfIsUnhiding = false;
				SetPOVBodyVisible(visible: true);
				SetPOVHandsVisible(visible: true);
			}
		}

		private bool IsUsingQuickbelt()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = headToFollow.rotation;
			float x = ((Quaternion)(ref rotation)).eulerAngles.x;
			if (54f < x && x < 90f)
			{
				for (int i = 0; i < handScripts.Length; i++)
				{
					if (!((Object)(object)handScripts[i] == (Object)null) && (((Object)(object)handScripts[i].CurrentInteractable == (Object)null && (Object)(object)handScripts[i].CurrentHoveredQuickbeltSlotDirty != (Object)null) || (Object)(object)handScripts[i].ClosestPossibleInteractable != (Object)null || ((Object)(object)handScripts[i].CurrentInteractable != (Object)null && (Object)(object)handScripts[i].CurrentHoveredQuickbeltSlot != (Object)null)))
					{
						return true;
					}
				}
			}
			return false;
		}

		private IEnumerator SelfUnhideCoroutine()
		{
			if (!selfIsUnhiding)
			{
				selfIsUnhiding = true;
				yield return (object)new WaitForSeconds(0.5f);
				if (!optionAutoHideSelf || !IsUsingQuickbelt())
				{
					SetPOVBodyVisible(visible: true);
					SetPOVHandsVisible(visible: true);
					selfIsHidden = false;
				}
				selfIsUnhiding = false;
			}
		}

		public virtual void SetHeadVisible(bool visible)
		{
			if (headRenderers == null)
			{
				return;
			}
			for (int i = 0; i < headRenderers.Length; i++)
			{
				if ((Object)(object)headRenderers[i] != (Object)null)
				{
					if (headDisplayMode == HeadDisplayMode.RendererToggle)
					{
						headRenderers[i].enabled = visible;
					}
					else
					{
						((Component)headRenderers[i]).gameObject.layer = (visible ? LayerMask.NameToLayer("Default") : LayerMask.NameToLayer("ExternalCamOnly"));
					}
				}
			}
		}

		public virtual void SetColor(Color newColor)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (coloredParts == null)
			{
				return;
			}
			for (int i = 0; i < coloredParts.Length; i++)
			{
				if (!((Object)(object)coloredParts[i] != (Object)null) || coloredParts[i].materials == null)
				{
					continue;
				}
				for (int j = 0; j < coloredParts[i].materials.Length; j++)
				{
					if ((Object)(object)coloredParts[i].materials[j] != (Object)null)
					{
						coloredParts[i].materials[j].color = newColor;
					}
				}
			}
		}

		public virtual void SetBodyVisible(bool visible)
		{
			if (bodyRenderers == null)
			{
				return;
			}
			for (int i = 0; i < bodyRenderers.Length; i++)
			{
				if ((Object)(object)bodyRenderers[i] != (Object)null)
				{
					bodyRenderers[i].enabled = visible;
				}
			}
		}

		public virtual void SetHandsVisible(bool visible)
		{
			if (handRenderers == null)
			{
				return;
			}
			for (int i = 0; i < handRenderers.Length; i++)
			{
				if ((Object)(object)handRenderers[i] != (Object)null)
				{
					handRenderers[i].enabled = visible;
				}
			}
		}

		private void SetPOVBodyVisible(bool visible)
		{
			if (bodyRenderers == null)
			{
				return;
			}
			for (int i = 0; i < bodyRenderers.Length; i++)
			{
				if ((Object)(object)bodyRenderers[i] != (Object)null)
				{
					((Component)bodyRenderers[i]).gameObject.layer = (visible ? bodyRendererLayers[i] : LayerMask.NameToLayer("ExternalCamOnly"));
				}
			}
		}

		private void SetPOVHandsVisible(bool visible)
		{
			if (handRenderers == null)
			{
				return;
			}
			for (int i = 0; i < handRenderers.Length; i++)
			{
				if ((Object)(object)handRenderers[i] != (Object)null)
				{
					((Component)handRenderers[i]).gameObject.layer = (visible ? handRendererLayers[i] : LayerMask.NameToLayer("ExternalCamOnly"));
				}
			}
		}

		public virtual void SetCollidersEnabled(bool enabled)
		{
			if (colliders != null)
			{
				for (int i = 0; i < colliders.Length; i++)
				{
					if ((Object)(object)colliders[i] != (Object)null)
					{
						colliders[i].enabled = enabled;
					}
				}
			}
			if (negativeColliders == null)
			{
				return;
			}
			for (int j = 0; j < negativeColliders.Length; j++)
			{
				if ((Object)(object)negativeColliders[j] != (Object)null)
				{
					negativeColliders[j].enabled = !enabled;
				}
			}
		}

		public virtual void SetCanvasesEnabled(bool enabled)
		{
			if (canvases == null)
			{
				return;
			}
			for (int i = 0; i < canvases.Length; i++)
			{
				if ((Object)(object)canvases[i] != (Object)null)
				{
					((Behaviour)canvases[i]).enabled = enabled;
				}
			}
		}

		public virtual void SetEntitiesRegistered(bool registered)
		{
			if (!((Object)(object)GM.CurrentAIManager != (Object)null) || entities == null)
			{
				return;
			}
			if (registered)
			{
				for (int i = 0; i < entities.Length; i++)
				{
					if ((Object)(object)entities[i] != (Object)null)
					{
						GM.CurrentAIManager.RegisterAIEntity(entities[i]);
					}
				}
				return;
			}
			for (int j = 0; j < entities.Length; j++)
			{
				if ((Object)(object)entities[j] != (Object)null)
				{
					GM.CurrentAIManager.DeRegisterAIEntity(entities[j]);
				}
			}
		}

		public virtual void SetIFF(int IFF)
		{
			if (entities == null)
			{
				return;
			}
			for (int i = 0; i < entities.Length; i++)
			{
				if ((Object)(object)entities[i] != (Object)null)
				{
					entities[i].IFFCode = IFF;
				}
			}
		}

		public virtual void OnDestroy()
		{
			GameManager.OnPlayerBodyInit -= OnPlayerBodyInit;
		}
	}
	public class ServerListController : MonoBehaviour
	{
		public enum State
		{
			ISSelect,
			MainWaiting,
			Main,
			Host,
			HostingWaiting,
			Hosting,
			Join,
			ClientWaiting,
			Client,
			Modlist
		}

		public static ServerListController instance;

		public static Dictionary<int, List<string>> modlists = new Dictionary<int, List<string>>();

		public static string minimumVersion = null;

		public static string failedConnectionReason = null;

		private bool awakened;

		private bool skipCloseClicked;

		private bool skipDisconnectClicked;

		private bool directConnection;

		public State state = State.Main;

		public GameObject ISSelect;

		public GameObject ISAdd;

		public GameObject main;

		public GameObject host;

		public GameObject hosting;

		public GameObject join;

		public GameObject client;

		public GameObject modlistPage;

		public Transform ISSelectListParent;

		public int ISSelectListPage;

		public GameObject ISSelectPagePrefab;

		public GameObject ISSelectEntryPrefab;

		public GameObject ISSelectPreviousButton;

		public GameObject ISSelectNextButton;

		public Text ISAddServerNameLabel;

		public Text ISAddServerNameText;

		public TextField ISAddServerNameField;

		public Text ISAddIPLabel;

		public Text ISAddIPText;

		public TextField ISAddIPField;

		public Text ISAddPortLabel;

		public Text ISAddPortText;

		public TextField ISAddPortField;

		public GameObject mainLoadingAnimation;

		public Transform mainListParent;

		public int mainListPage;

		public GameObject mainPagePrefab;

		public GameObject mainEntryPrefab;

		public GameObject mainHostButton;

		public GameObject mainPrevButton;

		public GameObject mainNextButton;

		public GameObject mainRefreshButton;

		public float mainRefreshTimer;

		public Text mainInfoText;

		public GameObject hostPage0;

		public GameObject hostPage1;

		public GameObject hostPreviousButton;

		public GameObject hostNextButton;

		public Text hostServerNameLabel;

		public Text hostServerName;

		public TextField hostServerNameField;

		public GameObject hostListToggle;

		public GameObject hostListToggleCheck;

		public Text hostPassword;

		public Text hostLimitLabel;

		public Text hostLimit;

		public TextField hostLimitField;

		public Text hostUsernameLabel;

		public Text hostUsername;

		public TextField hostUsernameField;

		public GameObject hostPortFieldObject;

		public Text hostPortLabel;

		public Text hostPort;

		public TextField hostPortField;

		public GameObject hostPortForwardedToggleCheck;

		public GameObject hostModlistEnforcedToggleCheck;

		public GameObject hostModlistMinimumToggleCheck;

		public GameObject hostModlistUnenforcedToggleCheck;

		public GameObject hostingLoadingAnimation;

		public GameObject hostingInfoTextObject;

		public Text hostingInfoText;

		public int hostingListPage;

		public Transform hostingListParent;

		public GameObject hostingPagePrefab;

		public GameObject hostingEntryPrefab;

		public GameObject hostingPrevButton;

		public GameObject hostingNextButton;

		public GameObject hostingListButtonObject;

		public Button hostingListButton;

		public Text hostingListButtonText;

		public Text joinUsernameLabel;

		public Text joinUsername;

		public TextField joinUsernameField;

		public int joiningEntry;

		public int entryModlistEnforcement;

		public List<string> modlist;

		public bool gotEndPoint;

		public GameObject joinPasswordFieldObject;

		public Text joinPassword;

		public GameObject joinIPFieldObject;

		public Text joinIPLabel;

		public Text joinIP;

		public TextField joinIPField;

		public GameObject joinPortFieldObject;

		public Text joinPortLabel;

		public Text joinPort;

		public TextField joinPortField;

		public Text joinServerName;

		public GameObject clientLoadingAnimation;

		public GameObject clientInfoTextObject;

		public Text clientInfoText;

		public int clientListPage;

		public Transform clientListParent;

		public GameObject clientPagePrefab;

		public GameObject clientEntryPrefab;

		public GameObject clientPrevButton;

		public GameObject clientNextButton;

		public GameObject clientDisconnectButton;

		public int modlistPageIndex;

		public Transform modlistParent;

		public GameObject modlistPagePrefab;

		public GameObject modlistEntryPrefab;

		public GameObject modlistPrevButton;

		public GameObject modlistNextButton;

		private void Awake()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)instance != (Object)null)
			{
				((Component)instance).transform.position = ((Component)this).transform.position;
				((Component)instance).transform.rotation = ((Component)this).transform.rotation;
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			instance = this;
			awakened = true;
			ISClient.OnReceiveHostEntries += HostEntriesReceived;
			ISClient.OnDisconnect += ISClientDisconnected;
			ISClient.OnListed += Listed;
			Mod.OnConnection += Connected;
			GameManager.OnPlayerAdded += PlayerAdded;
			Mod.OnPlayerRemoved += PlayerRemoved;
			Server.OnServerClose += OnHostingCloseClicked;
			Client.OnDisconnect += OnClientDisconnectClicked;
			Init();
		}

		public void Update()
		{
			if (mainRefreshTimer > 0f)
			{
				mainRefreshTimer -= Time.deltaTime;
				if (mainRefreshTimer <= 0f)
				{
					mainRefreshButton.SetActive(true);
				}
			}
		}

		public void Init()
		{
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				if (ISClient.isConnected)
				{
					SetMainPage(null);
				}
				else
				{
					SetISSelectPage();
				}
				return;
			}
			ISSelect.SetActive(false);
			if (ThreadManager.host)
			{
				hosting.SetActive(true);
				SetHostingPage(ISClient.isConnected && ISClient.gotWelcome && ISClient.wantListed && !ISClient.listed);
			}
			else
			{
				client.SetActive(true);
				SetClientPage(waiting: false);
			}
		}

		public void SetISSelectPage()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			if (ISClient.isConnected)
			{
				Mod.LogError("ServerListController.SetISSelectPage called but we were connected to IS:\n" + Environment.StackTrace);
				ISClient.Disconnect(sendToServer: true, 0);
			}
			state = State.ISSelect;
			((Component)ISSelectListParent).gameObject.SetActive(true);
			ISSelectPreviousButton.SetActive(false);
			ISSelectNextButton.SetActive(false);
			JArray val = null;
			if (Mod.config["ISList"] == null)
			{
				val = new JArray();
				Mod.config["ISList"] = (JToken)(object)val;
				JObject val2 = new JObject();
				val2["Name"] = JToken.op_Implicit("Official");
				val2["IP"] = JToken.op_Implicit("h3mp.tommysoucy.vip");
				val2["Port"] = JToken.op_Implicit(7862);
				val.Add((JToken)(object)val2);
				Mod.WriteConfig();
			}
			else
			{
				JToken obj = Mod.config["ISList"];
				val = (JArray)(object)((obj is JArray) ? obj : null);
			}
			while (ISSelectListParent.childCount > 1)
			{
				Transform child = ISSelectListParent.GetChild(1);
				child.SetParent((Transform)null);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			Transform transform = Object.Instantiate<GameObject>(ISSelectPagePrefab, ISSelectListParent).transform;
			for (int i = 0; i < ((JContainer)val).Count; i++)
			{
				GameObject val3 = Object.Instantiate<GameObject>(ISSelectEntryPrefab, transform);
				val3.SetActive(true);
				((Component)val3.transform.GetChild(0)).GetComponent<Text>().text = ((object)val[i][(object)"Name"]).ToString();
				string IP = ((object)val[i][(object)"IP"]).ToString();
				ushort port = (ushort)val[i][(object)"Port"];
				((UnityEvent)val3.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					ISClient.Connect(IP, port);
					ISSelect.SetActive(false);
					if ((Object)(object)Mod.managerObject == (Object)null)
					{
						main.SetActive(true);
						SetMainPage(null);
					}
					else if (ThreadManager.host)
					{
						hosting.SetActive(true);
						SetHostingPage(ISClient.isConnected && ISClient.gotWelcome && ISClient.wantListed && !ISClient.listed);
					}
					else
					{
						client.SetActive(true);
						SetClientPage(waiting: false);
					}
				});
				int index = i;
				((UnityEvent)((Component)val3.transform.GetChild(1)).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					JToken obj2 = Mod.config["ISList"];
					JArray val4 = (JArray)(object)((obj2 is JArray) ? obj2 : null);
					val4.RemoveAt(index);
					SetISSelectPage();
				});
				if (i + 1 == 0 && i != ((JContainer)val).Count - 1)
				{
					transform = Object.Instantiate<GameObject>(ISSelectPagePrefab, ISSelectListParent).transform;
					ISSelectNextButton.SetActive(true);
				}
			}
			ISSelectListPage = Mathf.Min(ISSelectListPage, ISSelectListParent.childCount - 2);
			((Component)ISSelectListParent.GetChild(ISSelectListPage + 1)).gameObject.SetActive(true);
		}

		public void SetMainPage(List<ISEntry> entries)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Expected O, but got Unknown
			if (entries == null)
			{
				state = State.MainWaiting;
				mainLoadingAnimation.SetActive(true);
				((Component)mainListParent).gameObject.SetActive(false);
				mainHostButton.SetActive(false);
				mainPrevButton.SetActive(false);
				mainNextButton.SetActive(false);
				mainRefreshButton.SetActive(false);
				((Component)mainInfoText).gameObject.SetActive(true);
				((Graphic)mainInfoText).color = Color.white;
				mainInfoText.text = "Waiting for index server";
				if (ISClient.gotWelcome)
				{
					ISClientSend.RequestHostEntries();
				}
				return;
			}
			state = State.Main;
			mainLoadingAnimation.SetActive(false);
			((Component)mainListParent).gameObject.SetActive(true);
			mainHostButton.SetActive(true);
			mainPrevButton.SetActive(false);
			mainNextButton.SetActive(false);
			mainRefreshButton.SetActive(false);
			mainRefreshTimer = 10f;
			if (entries.Count == 0)
			{
				((Component)mainInfoText).gameObject.SetActive(true);
				mainInfoText.text = "No servers found";
			}
			else
			{
				((Component)mainInfoText).gameObject.SetActive(false);
			}
			while (mainListParent.childCount > 1)
			{
				Transform child = mainListParent.GetChild(1);
				child.SetParent((Transform)null);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			Transform transform = Object.Instantiate<GameObject>(mainPagePrefab, mainListParent).transform;
			for (int i = 0; i < entries.Count; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(mainEntryPrefab, transform);
				val.SetActive(true);
				((Component)val.transform.GetChild(0)).GetComponent<Text>().text = entries[i].name;
				((Component)val.transform.GetChild(1)).GetComponent<Text>().text = entries[i].playerCount + "/" + entries[i].limit;
				((Component)val.transform.GetChild(2)).gameObject.SetActive(entries[i].locked);
				int entryID = entries[i].ID;
				bool hasPassword = entries[i].locked;
				int modlistEnforcement = entries[i].modlistEnforcement;
				string serverName = entries[i].name;
				((UnityEvent)val.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					Join(direct: false, entryID, hasPassword, modlistEnforcement, serverName);
				});
				if (i + 1 == 0 && i != entries.Count - 1)
				{
					transform = Object.Instantiate<GameObject>(mainPagePrefab, mainListParent).transform;
					mainNextButton.SetActive(true);
				}
			}
			mainListPage = Mathf.Min(mainListPage, mainListParent.childCount - 2);
			((Component)mainListParent.GetChild(mainListPage + 1)).gameObject.SetActive(true);
		}

		public void OnHostClicked()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			state = State.Host;
			ISSelect.SetActive(false);
			main.SetActive(false);
			host.SetActive(true);
			((Graphic)hostServerNameLabel).color = Color.white;
			if (Mod.config["ServerName"] != null)
			{
				hostServerName.text = ((object)Mod.config["ServerName"]).ToString();
				hostServerNameField.clearButton.SetActive(true);
			}
			((Graphic)hostLimitLabel).color = Color.white;
			if (Mod.config["MaxClientCount"] != null)
			{
				hostLimit.text = ((object)Mod.config["MaxClientCount"]).ToString();
				hostLimitField.clearButton.SetActive(true);
			}
			((Graphic)hostUsernameLabel).color = Color.white;
			if (Mod.config["Username"] != null)
			{
				hostUsername.text = ((object)Mod.config["Username"]).ToString();
				hostUsernameField.clearButton.SetActive(true);
			}
			((Graphic)hostPortLabel).color = Color.white;
			if (Mod.config["Port"] != null)
			{
				hostPort.text = ((object)Mod.config["Port"]).ToString();
				hostPortField.clearButton.SetActive(true);
			}
			if (ISClient.isConnected)
			{
				hostListToggle.SetActive(true);
				if (Mod.config["Public"] != null)
				{
					hostListToggleCheck.SetActive((bool)Mod.config["Public"]);
				}
			}
			else
			{
				hostListToggle.SetActive(false);
				hostListToggleCheck.SetActive(false);
			}
			if (Mod.config["UPnP"] != null)
			{
				hostPortForwardedToggleCheck.SetActive((bool)Mod.config["UPnP"]);
			}
			if (Mod.config["ModlistEnforcement"] != null)
			{
				int num = (int)Mod.config["ModlistEnforcement"];
				hostModlistEnforcedToggleCheck.SetActive(num == 0);
				hostModlistMinimumToggleCheck.SetActive(num == 1);
				hostModlistUnenforcedToggleCheck.SetActive(num == 2);
			}
		}

		public void OnJoinClicked()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			Join(direct: true, -1, hasPassword: true, 2, "Direct connection");
			state = State.Join;
			if (Mod.config["IP"] != null)
			{
				joinIP.text = ((object)Mod.config["IP"]).ToString();
				joinIPField.clearButton.SetActive(true);
			}
			((Graphic)joinUsernameLabel).color = Color.white;
			if (Mod.config["Username"] != null)
			{
				joinUsername.text = ((object)Mod.config["Username"]).ToString();
				joinUsernameField.clearButton.SetActive(true);
			}
			if (Mod.config["Port"] != null)
			{
				joinPort.text = ((object)Mod.config["Port"]).ToString();
				joinPortField.clearButton.SetActive(true);
			}
		}

		public void OnHostConfirmClicked()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (hostServerName.text == "")
			{
				flag = true;
				((Graphic)hostServerNameLabel).color = Color.red;
			}
			if (hostLimit.text == "" || !uint.TryParse(hostLimit.text, out var _))
			{
				flag = true;
				((Graphic)hostLimitLabel).color = Color.red;
			}
			if (hostPort.text == "" || !ushort.TryParse(hostPort.text, out var _))
			{
				flag = true;
				((Graphic)hostPortLabel).color = Color.red;
			}
			if (hostUsername.text == "")
			{
				flag = true;
				((Graphic)hostUsernameLabel).color = Color.red;
			}
			if (!flag)
			{
				Mod.config["ServerName"] = JToken.op_Implicit(hostServerName.text);
				Mod.config["MaxClientCount"] = JToken.op_Implicit(uint.Parse(hostLimit.text));
				Mod.config["Username"] = JToken.op_Implicit(hostUsername.text);
				Mod.config["Port"] = JToken.op_Implicit(ushort.Parse(hostPort.text));
				Mod.config["Public"] = JToken.op_Implicit(hostListToggleCheck.activeSelf);
				Mod.config["UPnP"] = JToken.op_Implicit(hostPortForwardedToggleCheck.activeSelf);
				int modlistEnforcement = 2;
				if (hostModlistEnforcedToggleCheck.activeSelf)
				{
					Mod.config["ModlistEnforcement"] = JToken.op_Implicit(0);
					modlistEnforcement = 0;
				}
				else if (hostModlistMinimumToggleCheck.activeSelf)
				{
					Mod.config["ModlistEnforcement"] = JToken.op_Implicit(1);
					modlistEnforcement = 1;
				}
				else if (hostModlistUnenforcedToggleCheck.activeSelf)
				{
					Mod.config["ModlistEnforcement"] = JToken.op_Implicit(2);
					modlistEnforcement = 2;
				}
				Mod.WriteConfig();
				host.SetActive(false);
				hosting.SetActive(true);
				directConnection = !hostListToggleCheck.activeSelf;
				SetHostingPage((Object)(object)Mod.managerObject == (Object)null);
				if (!directConnection)
				{
					ISClientSend.List(hostServerName.text, int.Parse(hostLimit.text), hostPassword.text, ushort.Parse(hostPort.text), modlistEnforcement);
					ISClient.wantListed = true;
				}
				ISClient.listed = false;
			}
		}

		public void OnHostingCloseClicked()
		{
			if (!skipCloseClicked)
			{
				if (ISClient.isConnected && (ISClient.listed || ISClient.wantListed))
				{
					ISClient.wantListed = false;
					ISClient.listed = false;
					ISClientSend.Unlist();
				}
				if ((Object)(object)Mod.managerObject != (Object)null && ThreadManager.host)
				{
					skipCloseClicked = true;
					Server.Close();
					skipCloseClicked = false;
				}
				hosting.SetActive(false);
				if (ISClient.isConnected)
				{
					main.SetActive(true);
					SetMainPage(null);
				}
				else
				{
					ISSelect.SetActive(true);
					SetISSelectPage();
				}
			}
		}

		public void OnHostingListClicked()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			if (ISClient.isConnected)
			{
				if (!ISClient.listed && !ISClient.wantListed)
				{
					state = State.Host;
					hosting.SetActive(false);
					host.SetActive(true);
					directConnection = false;
					hostListToggleCheck.SetActive(true);
					((Graphic)hostServerNameLabel).color = Color.white;
					if (Mod.config["ServerName"] != null)
					{
						hostServerName.text = ((object)Mod.config["ServerName"]).ToString();
						hostServerNameField.clearButton.SetActive(true);
					}
					((Graphic)hostLimitLabel).color = Color.white;
					if (Mod.config["MaxClientCount"] != null)
					{
						hostLimit.text = ((object)Mod.config["MaxClientCount"]).ToString();
						hostLimitField.clearButton.SetActive(true);
					}
					((Graphic)hostUsernameLabel).color = Color.white;
					if (Mod.config["Username"] != null)
					{
						hostUsername.text = ((object)Mod.config["Username"]).ToString();
						hostUsernameField.clearButton.SetActive(true);
					}
					((Graphic)hostPortLabel).color = Color.white;
					if (Mod.config["Port"] != null)
					{
						hostPort.text = ((object)Mod.config["Port"]).ToString();
						hostPortField.clearButton.SetActive(true);
					}
				}
				else if (ISClient.listed)
				{
					ISClientSend.Unlist();
					ISClient.wantListed = false;
				}
			}
			else
			{
				hosting.SetActive(false);
				ISSelect.SetActive(true);
				SetISSelectPage();
			}
		}

		public void OnHostPortForwardedClicked()
		{
			hostPortForwardedToggleCheck.SetActive(!hostPortForwardedToggleCheck.activeSelf);
		}

		public void OnHostModlistEnforcedClicked()
		{
			hostModlistEnforcedToggleCheck.SetActive(true);
			hostModlistMinimumToggleCheck.SetActive(false);
			hostModlistUnenforcedToggleCheck.SetActive(false);
		}

		public void OnHostModlistMinimumClicked()
		{
			hostModlistEnforcedToggleCheck.SetActive(false);
			hostModlistMinimumToggleCheck.SetActive(true);
			hostModlistUnenforcedToggleCheck.SetActive(false);
		}

		public void OnHostModlistUnenforcedClicked()
		{
			hostModlistEnforcedToggleCheck.SetActive(false);
			hostModlistMinimumToggleCheck.SetActive(false);
			hostModlistUnenforcedToggleCheck.SetActive(true);
		}

		public void OnHostListClicked()
		{
			hostListToggleCheck.SetActive(!hostListToggleCheck.activeSelf);
		}

		private void HostEntriesReceived(List<ISEntry> entries)
		{
			if (state == State.Main || state == State.MainWaiting)
			{
				SetMainPage(entries);
			}
		}

		private void Listed(int ID)
		{
			if (state == State.HostingWaiting || state == State.Hosting)
			{
				ISClient.listed = true;
				SetHostingPage(waiting: false);
			}
			else
			{
				ISClient.wantListed = false;
				ISClient.listed = false;
			}
			if (!ISClient.wantListed)
			{
				ISClientSend.Unlist();
			}
		}

		private void ISClientDisconnected()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (state == State.Hosting)
			{
				ISClient.wantListed = false;
				ISClient.listed = false;
				((Graphic)hostingListButtonText).color = Color.yellow;
				hostingListButtonText.text = "Select IS";
				((Selectable)hostingListButton).interactable = true;
			}
			else if (state != State.Client && state != State.ISSelect)
			{
				main.SetActive(true);
				host.SetActive(false);
				hosting.SetActive(false);
				join.SetActive(false);
				client.SetActive(false);
				SetMainPage(null);
				mainLoadingAnimation.SetActive(false);
				((Graphic)mainInfoText).color = Color.red;
				if (failedConnectionReason == null)
				{
					mainInfoText.text = "Connection to index server failed";
					return;
				}
				mainInfoText.text = failedConnectionReason;
				failedConnectionReason = null;
			}
		}

		private void Connected()
		{
			main.SetActive(false);
			host.SetActive(false);
			join.SetActive(false);
			if (ThreadManager.host)
			{
				hosting.SetActive(true);
				client.SetActive(false);
				SetHostingPage(waiting: false);
			}
			else
			{
				hosting.SetActive(false);
				client.SetActive(true);
				SetClientPage(waiting: false);
			}
		}

		private void Join(bool direct, int entryID, bool hasPassword, int modlistEnforcement, string name)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			directConnection = direct;
			joiningEntry = entryID;
			entryModlistEnforcement = modlistEnforcement;
			gotEndPoint = false;
			ISSelect.SetActive(false);
			main.SetActive(false);
			join.SetActive(true);
			joinPasswordFieldObject.SetActive(hasPassword);
			joinServerName.text = "Server:\n" + name;
			if (direct)
			{
				((Graphic)joinIPLabel).color = Color.white;
				joinIPFieldObject.SetActive(true);
				((Graphic)joinPortLabel).color = Color.white;
				joinPortFieldObject.SetActive(true);
			}
			else
			{
				joinIPFieldObject.SetActive(false);
				joinPortFieldObject.SetActive(false);
			}
		}

		private void SetHostingPage(bool waiting)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Expected O, but got Unknown
			if (waiting && !directConnection)
			{
				state = State.HostingWaiting;
				hostingLoadingAnimation.SetActive(true);
				hostingInfoTextObject.SetActive(true);
				((Component)hostingListParent).gameObject.SetActive(false);
				hostingListButtonObject.SetActive(false);
				hostingInfoText.text = "Awaiting server confirm";
				return;
			}
			state = State.Hosting;
			hostingLoadingAnimation.SetActive(false);
			hostingInfoTextObject.SetActive(false);
			((Component)hostingListParent).gameObject.SetActive(true);
			hostingListButtonObject.SetActive(true);
			if (ISClient.listed)
			{
				((Graphic)hostingListButtonText).color = Color.green;
				hostingListButtonText.text = "Public";
				((Selectable)hostingListButton).interactable = true;
			}
			else if (ISClient.wantListed)
			{
				((Graphic)hostingListButtonText).color = Color.cyan;
				hostingListButtonText.text = "Listing";
				((Selectable)hostingListButton).interactable = false;
			}
			else
			{
				((Graphic)hostingListButtonText).color = Color.yellow;
				hostingListButtonText.text = "Private";
				((Selectable)hostingListButton).interactable = true;
			}
			while (hostingListParent.childCount > 1)
			{
				Transform child = hostingListParent.GetChild(1);
				child.SetParent((Transform)null);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			Transform transform = Object.Instantiate<GameObject>(hostingPagePrefab, hostingListParent).transform;
			GameObject val = Object.Instantiate<GameObject>(hostingEntryPrefab, transform);
			val.SetActive(true);
			hostingListPage = 0;
			((Component)transform).gameObject.SetActive(true);
			((Component)val.transform.GetChild(0)).GetComponent<Text>().text = ((object)Mod.config["Username"]).ToString();
			for (int i = 0; i < Server.connectedClients.Count; i++)
			{
				val = Object.Instantiate<GameObject>(hostingEntryPrefab, transform);
				val.SetActive(true);
				Player player = Server.clients[Server.connectedClients[i]].player;
				((Component)val.transform.GetChild(0)).GetComponent<Text>().text = player.username;
				GameObject gameObject = ((Component)val.transform.GetChild(1)).gameObject;
				gameObject.SetActive(true);
				int playerID = player.ID;
				((UnityEvent)gameObject.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					KickPlayer(playerID);
				});
				if (i + 2 == 0 && i != Server.connectedClients.Count - 1)
				{
					transform = Object.Instantiate<GameObject>(hostingPagePrefab, hostingListParent).transform;
					hostingNextButton.SetActive(true);
				}
			}
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				return;
			}
			if (hostPortForwardedToggleCheck.activeSelf)
			{
				try
				{
					CreateMappings();
				}
				catch (Exception ex)
				{
					Mod.LogError("Failed to create UPnP mappings. Ensure UPnP is supported and enabled in your router: " + ex.Message + "\n" + ex.StackTrace);
				}
			}
			Mod.OnHostClicked();
		}

		private void CreateMappings()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			int num = int.Parse(((object)Mod.config["Port"]).ToString());
			Mod.LogInfo("Creating UPnP mappings for " + num);
			NatDiscoverer val = new NatDiscoverer();
			CancellationTokenSource val2 = new CancellationTokenSource();
			CancellationTokenSourceExtension.CancelAfter(val2, 10000);
			Mod.LogInfo("Discovering UPnP devices...");
			Task<NatDevice> val3 = val.DiscoverDeviceAsync((PortMapper)2, val2);
			((Task)val3).Wait();
			NatDevice result = val3.Result;
			Mod.LogInfo("Device found: " + ((result == null) ? "null" : ((object)result).ToString()));
			Mod.LogInfo("Trying to get device external IP...");
			Task<IPAddress> externalIPAsync = result.GetExternalIPAsync();
			((Task)externalIPAsync).Wait();
			Mod.LogInfo("Creating mappings on device: " + externalIPAsync.Result);
			Mod.LogInfo("Creating TCP mapping...");
			Task val4 = result.CreatePortMapAsync(new Mapping((Protocol)0, num, num, 0, "H3MP - UPnP TCP mapping"));
			val4.Wait();
			Mod.LogInfo("TCP mapping created. Creating UDP mapping...");
			val4 = result.CreatePortMapAsync(new Mapping((Protocol)1, num, num, 0, "H3MP - UPnP UDP mapping"));
			val4.Wait();
			Mod.LogInfo("Mappings created");
		}

		private void PlayerAdded(PlayerManager player)
		{
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			if (state == State.Client)
			{
				Transform val = clientListParent.GetChild(clientListParent.childCount - 1);
				if (val.childCount == 8)
				{
					val = Object.Instantiate<GameObject>(clientPagePrefab, clientListParent).transform;
					((Component)val).gameObject.SetActive(true);
					if (clientListPage == clientListParent.childCount - 2)
					{
						clientNextButton.SetActive(true);
					}
				}
				GameObject val2 = Object.Instantiate<GameObject>(clientEntryPrefab, val);
				val2.SetActive(true);
				((Component)val2.transform.GetChild(0)).GetComponent<Text>().text = player.username;
			}
			else
			{
				if (state != State.Hosting)
				{
					return;
				}
				Transform val3 = hostingListParent.GetChild(hostingListParent.childCount - 1);
				if (val3.childCount == 8)
				{
					val3 = Object.Instantiate<GameObject>(hostingPagePrefab, hostingListParent).transform;
					((Component)val3).gameObject.SetActive(true);
					if (hostingListPage == hostingListParent.childCount - 2)
					{
						hostingNextButton.SetActive(true);
					}
				}
				GameObject val4 = Object.Instantiate<GameObject>(hostingEntryPrefab, val3);
				val4.SetActive(true);
				((Component)val4.transform.GetChild(0)).GetComponent<Text>().text = player.username;
				GameObject gameObject = ((Component)val4.transform.GetChild(1)).gameObject;
				gameObject.SetActive(true);
				int playerID = player.ID;
				((UnityEvent)gameObject.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					KickPlayer(playerID);
				});
			}
		}

		private void PlayerRemoved(PlayerManager player)
		{
			if (state == State.Client)
			{
				int num = clientListPage;
				SetClientPage(waiting: false);
				if (clientListParent.childCount - 1 <= num)
				{
					num = clientListParent.childCount - 2;
				}
				clientListPage = num;
				((Component)clientListParent.GetChild(1)).gameObject.SetActive(false);
				((Component)clientListParent.GetChild(clientListPage + 1)).gameObject.SetActive(true);
				clientPrevButton.SetActive(clientListPage > 0);
				clientNextButton.SetActive(clientListPage < clientListParent.childCount - 2);
			}
			else if (state == State.Hosting)
			{
				int num2 = hostingListPage;
				SetHostingPage(waiting: false);
				if (hostingListParent.childCount - 1 <= num2)
				{
					num2 = hostingListParent.childCount - 2;
				}
				hostingListPage = num2;
				((Component)hostingListParent.GetChild(1)).gameObject.SetActive(false);
				((Component)hostingListParent.GetChild(hostingListPage + 1)).gameObject.SetActive(true);
				hostingPrevButton.SetActive(hostingListPage > 0);
				hostingNextButton.SetActive(hostingListPage < hostingListParent.childCount - 2);
			}
		}

		public void SetClientPage(bool waiting)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			if (waiting)
			{
				state = State.ClientWaiting;
				clientLoadingAnimation.SetActive(true);
				clientInfoTextObject.SetActive(true);
				((Component)clientListParent).gameObject.SetActive(false);
				if (directConnection)
				{
					((Graphic)clientInfoText).color = Color.cyan;
					clientInfoText.text = "Attempting to join server";
					Mod.OnConnectClicked(null);
				}
				else if (joiningEntry == -1)
				{
					((Graphic)clientInfoText).color = Color.red;
					clientInfoText.text = "Error joining server";
				}
				else if (gotEndPoint)
				{
					((Graphic)clientInfoText).color = Color.cyan;
					clientInfoText.text = "Attempting to join server";
				}
				else if (entryModlistEnforcement != 2)
				{
					if (modlist == null)
					{
						((Graphic)clientInfoText).color = Color.white;
						clientInfoText.text = "Getting mod list";
						ISClientSend.RequestModlist(joiningEntry, Mod.GetSHA256Hash(joinPassword.text));
						return;
					}
					List<string> list = new List<string>();
					List<string> list2 = new List<string>(Chainloader.PluginInfos.Keys);
					for (int i = 0; i < modlist.Count; i++)
					{
						if (Chainloader.PluginInfos.ContainsKey(modlist[i]))
						{
							list2.Remove(modlist[i]);
						}
						else
						{
							list.Add(modlist[i]);
						}
					}
					if (list.Count != 0 || (entryModlistEnforcement == 0 && list2.Count != 0))
					{
						joiningEntry = -1;
						client.SetActive(false);
						modlistPage.SetActive(true);
						SetModlistPage(list, list2);
					}
					else
					{
						((Graphic)clientInfoText).color = Color.white;
						clientInfoText.text = "Awaiting server confirm";
						ISClientSend.Join(joiningEntry, Mod.GetSHA256Hash(joinPassword.text));
					}
				}
				else
				{
					((Graphic)clientInfoText).color = Color.white;
					clientInfoText.text = "Awaiting server confirm";
					ISClientSend.Join(joiningEntry, Mod.GetSHA256Hash(joinPassword.text));
				}
				return;
			}
			state = State.Client;
			clientLoadingAnimation.SetActive(false);
			clientInfoTextObject.SetActive(false);
			((Component)clientListParent).gameObject.SetActive(true);
			while (clientListParent.childCount > 1)
			{
				Transform child = clientListParent.GetChild(1);
				child.SetParent((Transform)null);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			Transform transform = Object.Instantiate<GameObject>(clientPagePrefab, clientListParent).transform;
			clientListPage = 0;
			GameObject val = Object.Instantiate<GameObject>(clientEntryPrefab, transform);
			val.SetActive(true);
			((Component)transform).gameObject.SetActive(true);
			((Component)val.transform.GetChild(0)).GetComponent<Text>().text = ((object)Mod.config["Username"]).ToString();
			int num = 1;
			foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
			{
				val = Object.Instantiate<GameObject>(clientEntryPrefab, transform);
				val.SetActive(true);
				((Component)val.transform.GetChild(0)).GetComponent<Text>().text = player.Value.username + ((player.Key == 0) ? " (Host)" : "");
				if (num % 7 == 0 && num != GameManager.players.Count)
				{
					transform = Object.Instantiate<GameObject>(clientPagePrefab, clientListParent).transform;
					clientNextButton.SetActive(true);
				}
				num++;
			}
		}

		public void SetModlistPage(List<string> missing, List<string> surplus)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			state = State.Modlist;
			while (modlistParent.childCount > 1)
			{
				Transform child = modlistParent.GetChild(1);
				child.SetParent((Transform)null);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			Transform transform = Object.Instantiate<GameObject>(modlistPagePrefab, modlistParent).transform;
			((Component)transform).gameObject.SetActive(true);
			modlistPageIndex = 0;
			for (int i = 0; i < missing.Count; i++)
			{
				if (transform.childCount == 8)
				{
					transform = Object.Instantiate<GameObject>(modlistPagePrefab, modlistParent).transform;
					clientNextButton.SetActive(true);
				}
				GameObject val = Object.Instantiate<GameObject>(modlistEntryPrefab, transform);
				val.SetActive(true);
				Text component = ((Component)val.transform.GetChild(0)).GetComponent<Text>();
				component.text = missing[i];
				((Graphic)component).color = Color.red;
			}
			if (entryModlistEnforcement != 1)
			{
				return;
			}
			for (int j = 0; j < surplus.Count; j++)
			{
				if (transform.childCount == 8)
				{
					transform = Object.Instantiate<GameObject>(modlistPagePrefab, modlistParent).transform;
					clientNextButton.SetActive(true);
				}
				GameObject val2 = Object.Instantiate<GameObject>(modlistEntryPrefab, transform);
				val2.SetActive(true);
				Text component2 = ((Component)val2.transform.GetChild(0)).GetComponent<Text>();
				component2.text = surplus[j];
				((Graphic)component2).color = Color.yellow;
			}
		}

		private void KickPlayer(int ID)
		{
			if (ThreadManager.host)
			{
				Server.clients[ID].Disconnect(2);
			}
		}

		public void OnExitClicked()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public void OnISSelectAddClicked()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			ISSelect.SetActive(false);
			ISAdd.SetActive(true);
			((Graphic)ISAddIPLabel).color = Color.white;
			ISAddIPText.text = "";
			ISAddIPField.clearButton.SetActive(false);
			((Graphic)ISAddPortLabel).color = Color.white;
			ISAddPortText.text = "";
			ISAddPortField.clearButton.SetActive(false);
			((Graphic)ISAddServerNameLabel).color = Color.white;
			ISAddServerNameText.text = "";
			ISAddServerNameField.clearButton.SetActive(false);
		}

		public void OnISSelectPreviousClicked()
		{
			((Component)ISSelectListParent.GetChild(ISSelectListPage + 1)).gameObject.SetActive(false);
			ISSelectListPage--;
			((Component)ISSelectListParent.GetChild(ISSelectListPage + 1)).gameObject.SetActive(true);
			if (ISSelectListPage == 0)
			{
				ISSelectPreviousButton.SetActive(false);
			}
			ISSelectNextButton.SetActive(true);
		}

		public void OnISSelectNextClicked()
		{
			((Component)ISSelectListParent.GetChild(ISSelectListPage + 1)).gameObject.SetActive(false);
			ISSelectListPage++;
			((Component)ISSelectListParent.GetChild(ISSelectListPage + 1)).gameObject.SetActive(true);
			if (ISSelectListPage == ISSelectListParent.childCount - 2)
			{
				ISSelectNextButton.SetActive(false);
			}
			ISSelectPreviousButton.SetActive(true);
		}

		public void OnISAddBackClicked()
		{
			ISSelect.SetActive(true);
			ISAdd.SetActive(false);
			SetISSelectPage();
		}

		public void OnISAddConfirmClicked()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			bool flag = false;
			if (ISAddServerNameText.text == "")
			{
				flag = true;
				((Graphic)ISAddServerNameLabel).color = Color.red;
			}
			if (ISAddIPText.text == "")
			{
				flag = true;
				((Graphic)ISAddIPLabel).color = Color.red;
			}
			else
			{
				try
				{
					Dns.GetHostAddresses(ISAddIPText.text);
				}
				catch (Exception)
				{
					flag = true;
					((Graphic)ISAddIPLabel).color = Color.red;
				}
			}
			ushort result = 0;
			if (ISAddPortText.text == "" || !ushort.TryParse(ISAddPortText.text, out result))
			{
				flag = true;
				((Graphic)ISAddPortLabel).color = Color.red;
			}
			if (!flag)
			{
				JObject val = new JObject();
				val["Name"] = JToken.op_Implicit(ISAddServerNameText.text);
				val["IP"] = JToken.op_Implicit(ISAddIPText.text);
				val["Port"] = JToken.op_Implicit(result);
				JToken obj = Mod.config["ISList"];
				((JArray)((obj is JArray) ? obj : null)).Add((JToken)(object)val);
				Mod.WriteConfig();
				ISSelect.SetActive(true);
				ISAdd.SetActive(false);
				SetISSelectPage();
			}
		}

		public void OnMainPrevClicked()
		{
			((Component)mainListParent.GetChild(mainListPage + 1)).gameObject.SetActive(false);
			mainListPage--;
			((Component)mainListParent.GetChild(mainListPage + 1)).gameObject.SetActive(true);
			if (mainListPage == 0)
			{
				mainPrevButton.SetActive(false);
			}
			mainNextButton.SetActive(true);
		}

		public void OnMainNextClicked()
		{
			((Component)mainListParent.GetChild(mainListPage + 1)).gameObject.SetActive(false);
			mainListPage++;
			((Component)mainListParent.GetChild(mainListPage + 1)).gameObject.SetActive(true);
			if (mainListPage == mainListParent.childCount - 2)
			{
				mainNextButton.SetActive(false);
			}
			mainPrevButton.SetActive(true);
		}

		public void OnMainRefreshClicked()
		{
			ISClientSend.RequestHostEntries();
			mainRefreshButton.SetActive(false);
			mainRefreshTimer = 10f;
		}

		public void OnMainBackClicked()
		{
			ISClient.Disconnect(sendToServer: true, 0);
			main.SetActive(false);
			ISSelect.SetActive(true);
			SetISSelectPage();
		}

		public void OnHostNextClicked()
		{
			hostPage0.SetActive(false);
			hostPage1.SetActive(true);
			hostPreviousButton.SetActive(true);
			hostNextButton.SetActive(false);
		}

		public void OnHostPreviousClicked()
		{
			hostPage0.SetActive(true);
			hostPage1.SetActive(false);
			hostPreviousButton.SetActive(false);
			hostNextButton.SetActive(true);
		}

		public void OnHostCancelClicked()
		{
			host.SetActive(false);
			if (ISClient.isConnected)
			{
				main.SetActive(true);
				SetMainPage(null);
			}
			else
			{
				ISSelect.SetActive(true);
				SetISSelectPage();
			}
		}

		public void OnHostingPrevClicked()
		{
			((Component)hostingListParent.GetChild(hostingListPage + 1)).gameObject.SetActive(false);
			hostingListPage--;
			((Component)hostingListParent.GetChild(hostingListPage + 1)).gameObject.SetActive(true);
			if (hostingListPage == 0)
			{
				hostingPrevButton.SetActive(false);
			}
			hostingNextButton.SetActive(true);
		}

		public void OnHostingNextClicked()
		{
			((Component)hostingListParent.GetChild(hostingListPage + 1)).gameObject.SetActive(false);
			hostingListPage++;
			((Component)hostingListParent.GetChild(hostingListPage + 1)).gameObject.SetActive(true);
			if (hostingListPage == hostingListParent.childCount - 2)
			{
				hostingNextButton.SetActive(false);
			}
			hostingPrevButton.SetActive(true);
		}

		public void OnJoinConfirmClicked()
		{
			//IL_0025: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (joinUsername.text == "")
			{
				flag = true;
				((Graphic)joinUsernameLabel).color = Color.red;
			}
			if (directConnection)
			{
				if (joinIP.text == "")
				{
					flag = true;
					((Graphic)joinIPLabel).color = Color.red;
				}
				if (joinPort.text == "" || !ushort.TryParse(joinPort.text, out var _))
				{
					flag = true;
					((Graphic)joinPortLabel).color = Color.red;
				}
			}
			if (!flag)
			{
				Mod.config["Username"] = JToken.op_Implicit(joinUsername.text);
				if (directConnection)
				{
					Mod.config["IP"] = JToken.op_Implicit(joinIP.text);
					Mod.config["Port"] = JToken.op_Implicit(ushort.Parse(joinPort.text));
				}
				Mod.WriteConfig();
				join.SetActive(false);
				client.SetActive(true);
				modlists.TryGetValue(joiningEntry, out modlist);
				SetClientPage(waiting: true);
			}
		}

		public void OnJoinCancelClicked()
		{
			join.SetActive(false);
			if (ISClient.isConnected)
			{
				main.SetActive(true);
				SetMainPage(null);
			}
			else
			{
				ISSelect.SetActive(true);
				SetISSelectPage();
			}
		}

		public void OnClientDisconnectClicked()
		{
			if (!skipDisconnectClicked)
			{
				if ((Object)(object)Mod.managerObject != (Object)null && !ThreadManager.host && Client.singleton.isConnected)
				{
					skipDisconnectClicked = true;
					Client.singleton.Disconnect(sendToServer: true, 0);
					skipDisconnectClicked = false;
				}
				client.SetActive(false);
				if (ISClient.isConnected)
				{
					main.SetActive(true);
					SetMainPage(null);
				}
				else
				{
					ISSelect.SetActive(true);
					SetISSelectPage();
				}
			}
		}

		public void OnClientPrevClicked()
		{
			((Component)clientListParent.GetChild(clientListPage + 1)).gameObject.SetActive(false);
			clientListPage--;
			((Component)clientListParent.GetChild(clientListPage + 1)).gameObject.SetActive(true);
			if (clientListPage == 0)
			{
				clientPrevButton.SetActive(false);
			}
			clientNextButton.SetActive(true);
		}

		public void OnClientNextClicked()
		{
			((Component)clientListParent.GetChild(clientListPage + 1)).gameObject.SetActive(false);
			clientListPage++;
			((Component)clientListParent.GetChild(clientListPage + 1)).gameObject.SetActive(true);
			if (clientListPage == clientListParent.childCount - 2)
			{
				clientNextButton.SetActive(false);
			}
			clientPrevButton.SetActive(true);
		}

		public void OnModlistPrevClicked()
		{
			((Component)modlistParent.GetChild(modlistPageIndex + 1)).gameObject.SetActive(false);
			modlistPageIndex--;
			((Component)modlistParent.GetChild(modlistPageIndex + 1)).gameObject.SetActive(true);
			if (modlistPageIndex == 0)
			{
				modlistPrevButton.SetActive(false);
			}
			modlistNextButton.SetActive(true);
		}

		public void OnModlistNextClicked()
		{
			((Component)modlistParent.GetChild(modlistPageIndex + 1)).gameObject.SetActive(false);
			modlistPageIndex++;
			((Component)modlistParent.GetChild(modlistPageIndex + 1)).gameObject.SetActive(true);
			if (modlistPageIndex == modlistParent.childCount - 2)
			{
				modlistNextButton.SetActive(false);
			}
			modlistPrevButton.SetActive(true);
		}

		public void OnModlistBackClicked()
		{
			modlistPage.SetActive(false);
			main.SetActive(true);
			SetMainPage(null);
		}

		private void OnDestroy()
		{
			if (!awakened)
			{
				return;
			}
			ISClient.OnReceiveHostEntries -= HostEntriesReceived;
			ISClient.OnDisconnect -= ISClientDisconnected;
			ISClient.OnListed -= Listed;
			Mod.OnConnection -= Connected;
			GameManager.OnPlayerAdded -= PlayerAdded;
			Mod.OnPlayerRemoved -= PlayerRemoved;
			Server.OnServerClose -= OnHostingCloseClicked;
			Client.OnDisconnect -= OnClientDisconnectClicked;
			if (!ISClient.isConnected)
			{
				return;
			}
			if (ISClient.gotWelcome)
			{
				if ((Object)(object)Mod.managerObject == (Object)null)
				{
					ISClient.Disconnect(sendToServer: true, 0);
				}
				else if (ThreadManager.host)
				{
					if (!ISClient.listed)
					{
						ISClient.Disconnect(sendToServer: true, 0);
					}
				}
				else
				{
					ISClient.Disconnect(sendToServer: true, 0);
				}
			}
			else
			{
				ISClient.Disconnect(sendToServer: false, 0);
			}
		}
	}
	public class TextField : MonoBehaviour
	{
		public static TextField selected;

		public bool digitsOnly;

		public Text text;

		public GameObject clearButton;

		public Keyboard keyboard;

		public GameObject keyboardObject;

		public void Activate()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)selected != (Object)null && (Object)(object)selected.keyboard != (Object)null)
			{
				Object.Destroy((Object)(object)selected.keyboardObject);
				selected.keyboard = null;
				selected.keyboardObject = null;
			}
			Vector3 val = GM.CurrentPlayerBody.Head.position + 0.5f * GM.CurrentPlayerBody.Head.forward;
			Vector3 val2 = val - 0.5f * GM.CurrentPlayerBody.Head.up;
			keyboardObject = Object.Instantiate<GameObject>(Mod.keyboardPrefab, val2, Quaternion.LookRotation(val - GM.CurrentPlayerBody.Head.position));
			keyboard = keyboardObject.GetComponentInChildren<Keyboard>();
			keyboard.field = this;
			selected = this;
		}

		public void Clear()
		{
			text.text = "";
			clearButton.SetActive(false);
		}

		private void OnDisable()
		{
			if ((Object)(object)keyboard != (Object)null)
			{
				Object.Destroy((Object)(object)keyboardObject);
				keyboard = null;
				keyboardObject = null;
			}
		}
	}
	public class TimerDestroyer : MonoBehaviour
	{
		public float time = 10f;

		public bool triggered = false;

		private void Update()
		{
			if (triggered)
			{
				time -= Time.deltaTime;
				if (time <= 0f)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
			}
		}
	}
	public class TrackedObjectReference : MonoBehaviour
	{
		public TrackedObject trackedRef;

		public int refIndex = -1;

		private void OnDestroy()
		{
			if (refIndex != -1 && (Object)(object)Mod.managerObject != (Object)null && TrackedObject.trackedReferences.Length > refIndex)
			{
				TrackedObject.trackedReferences[refIndex] = null;
				TrackedObject.trackedReferenceObjects[refIndex] = null;
				TrackedObject.availableTrackedRefIndices.Add(refIndex);
			}
		}
	}
	public class H3MPWristMenuSection : FVRWristMenuSection
	{
		private delegate void ButtonClick(Text text);

		public static bool init;

		private Dictionary<int, List<KeyValuePair<FVRPointableButton, Vector3>>> pages;

		private int currentPage = -1;

		public static Text colorByIFFText;

		public static Text IFFText;

		public static Text nameplateText;

		public static Text radarModeText;

		public static Text radarColorText;

		public static Text maxHealthText;

		public static Text invulnerableText;

		public static bool invulnerable;

		public static bool disabledHoldSosigs;

		public override void Enable()
		{
			InitButtons();
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SetPage(0);
			}
			else if (ThreadManager.host)
			{
				SetPage(2);
			}
			else
			{
				SetPage(3);
			}
		}

		private void InitButtons()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0624: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_069e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0703: Unknown result type (might be due to invalid IL or missing references)
			//IL_0712: Unknown result type (might be due to invalid IL or missing references)
			//IL_076a: Unknown result type (might be due to invalid IL or missing references)
			//IL_077f: Unknown result type (might be due to invalid IL or missing references)
			//IL_078e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0813: Unknown result type (might be due to invalid IL or missing references)
			//IL_0822: Unknown result type (might be due to invalid IL or missing references)
			//IL_0863: Unknown result type (might be due to invalid IL or missing references)
			//IL_0878: Unknown result type (might be due to invalid IL or missing references)
			//IL_0887: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_090c: Unknown result type (might be due to invalid IL or missing references)
			//IL_091b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_0988: Unknown result type (might be due to invalid IL or missing references)
			//IL_0997: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a03: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a18: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a27: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0acd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b32: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b47: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b56: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b97: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bbb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c0e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c23: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c32: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c73: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c88: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c97: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ced: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfc: Unknown result type (might be due to invalid IL or missing references)
			if (pages == null)
			{
				pages = new Dictionary<int, List<KeyValuePair<FVRPointableButton, Vector3>>>();
				Image val = ((Component)this).gameObject.AddComponent<Image>();
				((Graphic)val).rectTransform.sizeDelta = new Vector2(500f, 350f);
				((Graphic)val).color = new Color(0.1f, 0.1f, 0.1f, 1f);
				Text textOut = null;
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(0f, 75f, 0f)
				}, new Vector2(1000f, 150f), new Vector2(140f, 70f), OnServerListClicked, "Server list", out textOut);
				InitButton(new List<int> { 0 }, new List<Vector3>
				{
					new Vector3(0f, 0f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(140f, 70f), OnDirectConnectionClicked, "Direct connection", out textOut);
				InitButton(new List<int> { 1 }, new List<Vector3>
				{
					new Vector3(0f, 75f, 0f)
				}, new Vector2(500f, 240f), new Vector2(140f, 70f), OnHostClicked, "Host", out textOut);
				InitButton(new List<int> { 1 }, new List<Vector3> { Vector3.zero }, new Vector2(500f, 240f), new Vector2(140f, 70f), OnConnectClicked, "Join", out textOut);
				InitButton(new List<int> { 0, 1, 2, 3 }, new List<Vector3>
				{
					new Vector3(0f, -75f, 0f),
					new Vector3(0f, -75f, 0f),
					new Vector3(0f, -75f, 0f),
					new Vector3(0f, -75f, 0f)
				}, new Vector2(500f, 150f), new Vector2(140f, 70f), OnOptionsClicked, "Options", out textOut);
				InitButton(new List<int> { 2 }, new List<Vector3>
				{
					new Vector3(0f, 75f, 0f)
				}, new Vector2(500f, 240f), new Vector2(140f, 70f), OnCloseClicked, "Close\nserver", out textOut);
				InitButton(new List<int> { 3 }, new List<Vector3>
				{
					new Vector3(0f, 75f, 0f)
				}, new Vector2(500f, 240f), new Vector2(140f, 70f), OnDisconnectClicked, "Disconnect", out textOut);
				InitButton(new List<int> { 1, 2, 3, 4 }, new List<Vector3>
				{
					new Vector3(-215f, 140f, 0f),
					new Vector3(-215f, 140f, 0f),
					new Vector3(-215f, 140f, 0f),
					new Vector3(-215f, 140f, 0f)
				}, new Vector2(240f, 240f), new Vector2(70f, 70f), OnBackClicked, "Back", out textOut);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(0f, 150f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnReloadConfigClicked, "Reload config", out textOut);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(0f, 100f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnItemInterpolationClicked, "Item interpolation (ON)", out textOut);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(0f, 50f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnTNHReviveClicked, "TNH revive", out textOut);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(0f, 0f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnIFFClicked, "Current IFF: " + GM.CurrentPlayerBody.GetPlayerIFF(), out IFFText);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(155f, 0f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnNextIFFClicked, ">", out textOut);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(-155f, 0f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnPreviousIFFClicked, "<", out textOut);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(0f, -50f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(270f, 45f), OnColorByIFFClicked, "Color by IFF (" + GameManager.colorByIFF + ")", out colorByIFFText);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(0f, -100f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnNameplatesClicked, "Nameplates (" + ((GameManager.nameplateMode == 0) ? "All" : ((GameManager.nameplateMode == 1) ? "Friendly Only" : "None")) + ")", out nameplateText);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(0f, -150f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnHostStartHoldClicked, "Debug: Host start hold", out textOut);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(0f, 150f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnTNHRadarModeClicked, "Radar mode (" + ((GameManager.radarMode == 0) ? "All" : ((GameManager.radarMode == 1) ? "Friendly Only" : "None")) + ")", out radarModeText);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(0f, 100f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnTNHRadarColorClicked, "Radar color IFF (" + GameManager.radarColor + ")", out radarColorText);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(0f, 50f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnMaxHealthClicked, "Max health: " + ((GameManager.maxHealthIndex == -1) ? "Not set" : GameManager.maxHealths[GameManager.maxHealthIndex].ToString()), out maxHealthText);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(155f, 50f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnNextMaxHealthClicked, ">", out textOut);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(-155f, 50f, 0f)
				}, new Vector2(150f, 150f), new Vector2(45f, 45f), OnPreviousMaxHealthClicked, "<", out textOut);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(0f, 0f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnSetRespawnPointClicked, "Set respawn point", out textOut);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(0f, -50f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnDisableHoldSosigsClicked, "Debug: Disable Hold Sosigs", out textOut);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(0f, -100f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnInvulnerableClicked, "Debug: Invulnerable: " + invulnerable, out invulnerableText);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(0f, -150f, 0f)
				}, new Vector2(1200f, 150f), new Vector2(340f, 45f), OnTPToPlayerClicked, "Debug: TP to player", out textOut);
				InitButton(new List<int> { 4 }, new List<Vector3>
				{
					new Vector3(215f, -140f, 0f)
				}, new Vector2(240f, 240f), new Vector2(70f, 70f), OnNextOptionsClicked, "Next", out textOut);
				InitButton(new List<int> { 5 }, new List<Vector3>
				{
					new Vector3(-215f, -140f, 0f)
				}, new Vector2(240f, 240f), new Vector2(70f, 70f), OnPrevOptionsClicked, "Prev", out textOut);
			}
		}

		private void InitButton(List<int> pageIndices, List<Vector3> positions, Vector2 sizeDelta, Vector2 boxSize, ButtonClick clickMethod, string defaultText, out Text textOut)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(base.Menu.BaseButton, ((Component)this).transform);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.sizeDelta = sizeDelta;
			((Component)((Transform)component).GetChild(0)).GetComponent<RectTransform>().sizeDelta = sizeDelta;
			BoxCollider component2 = val.GetComponent<BoxCollider>();
			component2.size = new Vector3(boxSize.x, boxSize.y, component2.size.z);
			val.transform.localPosition = positions[0];
			val.transform.localRotation = Quaternion.identity;
			Object.Destroy((Object)(object)val.GetComponent<FVRWristMenuSectionButton>());
			val.GetComponent<Text>().text = defaultText;
			FVRPointableButton component3 = val.GetComponent<FVRPointableButton>();
			Text buttonText = val.GetComponent<Text>();
			textOut = buttonText;
			((UnityEvent)component3.Button.onClick).AddListener((UnityAction)delegate
			{
				clickMethod(buttonText);
			});
			for (int num = 0; num < pageIndices.Count; num++)
			{
				if (pages.TryGetValue(pageIndices[num], out var value))
				{
					value.Add(new KeyValuePair<FVRPointableButton, Vector3>(component3, positions[num]));
					continue;
				}
				KeyValuePair<FVRPointableButton, Vector3> item = new KeyValuePair<FVRPointableButton, Vector3>(component3, positions[num]);
				pages.Add(pageIndices[num], new List<KeyValuePair<FVRPointableButton, Vector3>> { item });
			}
		}

		private void OnServerListClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			if ((Object)(object)ServerListController.instance == (Object)null)
			{
				Object.Instantiate<GameObject>(Mod.serverListPrefab);
				Vector3 val = Vector3.ProjectOnPlane(GM.CurrentPlayerBody.Head.forward, Vector3.up);
				((Component)ServerListController.instance).transform.position = GM.CurrentPlayerBody.Head.position + 2f * val;
				((Component)ServerListController.instance).transform.rotation = Quaternion.LookRotation(val);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)ServerListController.instance).gameObject);
			}
		}

		private void OnDirectConnectionClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				if (ThreadManager.host)
				{
					SetPage(2);
				}
				else
				{
					SetPage(3);
				}
			}
			else
			{
				SetPage(1);
			}
		}

		private void OnHostClicked(Text textRef)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			Mod.OnHostClicked();
			SetPage(2);
		}

		private void OnConnectClicked(Text textRef)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject != (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			Mod.OnConnectClicked(null);
			SetPage(3);
		}

		private void OnReloadConfigClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			Mod.modInstance.LoadConfig();
		}

		private void OnCloseClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			Server.Close();
			SetPage(1);
		}

		private void OnDisconnectClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			Client.singleton.Disconnect(sendToServer: true, 0);
			SetPage(1);
		}

		private void OnOptionsClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			SetPage(4);
		}

		private void OnBackClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			switch (currentPage)
			{
			case 1:
			case 2:
			case 3:
				SetPage(0);
				break;
			case 4:
				if ((Object)(object)Mod.managerObject == (Object)null)
				{
					SetPage(1);
				}
				else
				{
					SetPage(ThreadManager.host ? 2 : 3);
				}
				break;
			}
		}

		private void OnItemInterpolationClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			if (TrackedItem.interpolated)
			{
				TrackedItem.interpolated = false;
				textRef.text = "Item interpolation (OFF)";
			}
			else
			{
				TrackedItem.interpolated = true;
				textRef.text = "Item interpolation (ON)";
			}
		}

		private void OnTNHReviveClicked(Text textRef)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GM.TNH_Manager != (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				GM.TNH_Manager.InitPlayerPosition();
				if (Mod.currentTNHInstance != null)
				{
					Mod.currentTNHInstance.RevivePlayer(GameManager.ID);
				}
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		private void OnIFFClicked(Text textRef)
		{
		}

		private void OnNextIFFClicked(Text textRef)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			if (GM.CurrentPlayerBody.GetPlayerIFF() == 31)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(-3);
			}
			else if (GM.CurrentPlayerBody.GetPlayerIFF() == -3)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(0);
			}
			else
			{
				GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentPlayerBody.GetPlayerIFF() + 1);
			}
			foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
			{
				if ((Object)(object)player.Value.playerBody != (Object)null)
				{
					player.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(GameManager.nameplateMode == 0 || (GameManager.nameplateMode == 1 && GM.CurrentPlayerBody.GetPlayerIFF() == player.Value.IFF));
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.PlayerIFF(0, GM.CurrentPlayerBody.GetPlayerIFF());
			}
			else
			{
				ClientSend.PlayerIFF(GM.CurrentPlayerBody.GetPlayerIFF());
			}
			if (GameManager.colorByIFF)
			{
				GameManager.SetPlayerColor(GameManager.ID, GM.CurrentPlayerBody.GetPlayerIFF(), received: false, 0, send: false);
			}
			IFFText.text = "Current IFF: " + GM.CurrentPlayerBody.GetPlayerIFF();
		}

		private void OnPreviousIFFClicked(Text textRef)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			if (GM.CurrentPlayerBody.GetPlayerIFF() == 0)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(-3);
			}
			else if (GM.CurrentPlayerBody.GetPlayerIFF() == -3)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(31);
			}
			else
			{
				GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentPlayerBody.GetPlayerIFF() - 1);
			}
			foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
			{
				if ((Object)(object)player.Value.playerBody != (Object)null)
				{
					player.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(GameManager.nameplateMode == 0 || (GameManager.nameplateMode == 1 && GM.CurrentPlayerBody.GetPlayerIFF() == player.Value.IFF));
				}
			}
			if (ThreadManager.host)
			{
				ServerSend.PlayerIFF(0, GM.CurrentPlayerBody.GetPlayerIFF());
			}
			else
			{
				ClientSend.PlayerIFF(GM.CurrentPlayerBody.GetPlayerIFF());
			}
			if (GameManager.colorByIFF)
			{
				GameManager.SetPlayerColor(GameManager.ID, GM.CurrentPlayerBody.GetPlayerIFF(), received: false, 0, send: false);
			}
			IFFText.text = "Current IFF: " + GM.CurrentPlayerBody.GetPlayerIFF();
		}

		private void OnColorByIFFClicked(Text textRef)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
			else if (ThreadManager.host)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				GameManager.colorByIFF = !GameManager.colorByIFF;
				textRef.text = "Color by IFF (" + GameManager.colorByIFF + ")";
				if (GameManager.colorByIFF)
				{
					GameManager.colorIndex = GM.CurrentPlayerBody.GetPlayerIFF() % GameManager.colors.Length;
					BodyWristMenuSection.colorText.text = "Current color: " + GameManager.colorNames[GameManager.colorIndex];
					foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
					{
						player.Value.SetColor(player.Value.IFF);
					}
				}
				else
				{
					foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
					{
						player2.Value.SetColor(player2.Value.colorIndex);
					}
				}
				ServerSend.ColorByIFF(GameManager.colorByIFF);
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		private void OnNameplatesClicked(Text textRef)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
			else if (ThreadManager.host)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				GameManager.nameplateMode = (GameManager.nameplateMode + 1) % 3;
				switch (GameManager.nameplateMode)
				{
				case 0:
					textRef.text = "Nameplates (All)";
					foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
					{
						if ((Object)(object)player.Value.playerBody != (Object)null)
						{
							player.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(enabled: true);
						}
					}
					break;
				case 1:
					textRef.text = "Nameplates (Friendly only)";
					foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
					{
						if ((Object)(object)player2.Value.playerBody != (Object)null)
						{
							player2.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(GM.CurrentPlayerBody.GetPlayerIFF() == player2.Value.IFF);
						}
					}
					break;
				case 2:
					textRef.text = "Nameplates (None)";
					foreach (KeyValuePair<int, PlayerManager> player3 in GameManager.players)
					{
						if ((Object)(object)player3.Value.playerBody != (Object)null)
						{
							player3.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(enabled: false);
						}
					}
					break;
				}
				ServerSend.NameplateMode(GameManager.nameplateMode);
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		private void OnTNHRadarModeClicked(Text textRef)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
			else if (ThreadManager.host)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				GameManager.radarMode = (GameManager.radarMode + 1) % 3;
				switch (GameManager.radarMode)
				{
				case 0:
					textRef.text = "Radar mode (All)";
					if (Mod.currentTNHInstance == null || !((Object)(object)Mod.currentTNHInstance.manager != (Object)null))
					{
						break;
					}
					foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
					{
						if (player.Value.visible && (Object)(object)player.Value.reticleContact == (Object)null && Mod.currentTNHInstance.currentlyPlaying.Contains(player.Key))
						{
							player.Value.reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(player.Value.head, (ContactType)((!GameManager.radarColor) ? (player.Value.colorIndex - 4) : ((player.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
						}
					}
					break;
				case 1:
					textRef.text = "Radar mode (Friendly only)";
					if (Mod.currentTNHInstance == null || !((Object)(object)Mod.currentTNHInstance.manager != (Object)null))
					{
						break;
					}
					foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
					{
						if (player2.Value.visible && Mod.currentTNHInstance.currentlyPlaying.Contains(player2.Key) && player2.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF() && (Object)(object)player2.Value.reticleContact == (Object)null)
						{
							player2.Value.reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(player2.Value.head, (ContactType)((!GameManager.radarColor) ? (player2.Value.colorIndex - 4) : ((player2.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
						}
						else
						{
							if ((player2.Value.visible && Mod.currentTNHInstance.currentlyPlaying.Contains(player2.Key) && player2.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) || !((Object)(object)player2.Value.reticleContact != (Object)null))
							{
								continue;
							}
							for (int num2 = GM.TNH_Manager.TAHReticle.Contacts.Count - 1; num2 >= 0; num2--)
							{
								if ((Object)(object)GM.TNH_Manager.TAHReticle.Contacts[num2] == (Object)(object)player2.Value.reticleContact)
								{
									GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[num2].TrackedTransform);
									Object.Destroy((Object)(object)((Component)GM.TNH_Manager.TAHReticle.Contacts[num2]).gameObject);
									GM.TNH_Manager.TAHReticle.Contacts.RemoveAt(num2);
									player2.Value.reticleContact = null;
									break;
								}
							}
						}
					}
					break;
				case 2:
					textRef.text = "Radar mode (None)";
					if (Mod.currentTNHInstance == null || !((Object)(object)Mod.currentTNHInstance.manager != (Object)null))
					{
						break;
					}
					foreach (KeyValuePair<int, PlayerManager> player3 in GameManager.players)
					{
						if (!((Object)(object)player3.Value.reticleContact != (Object)null))
						{
							continue;
						}
						for (int num = GM.TNH_Manager.TAHReticle.Contacts.Count - 1; num >= 0; num--)
						{
							if ((Object)(object)GM.TNH_Manager.TAHReticle.Contacts[num] == (Object)(object)player3.Value.reticleContact)
							{
								GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[num].TrackedTransform);
								Object.Destroy((Object)(object)((Component)GM.TNH_Manager.TAHReticle.Contacts[num]).gameObject);
								GM.TNH_Manager.TAHReticle.Contacts.RemoveAt(num);
								player3.Value.reticleContact = null;
								break;
							}
						}
					}
					break;
				}
				ServerSend.RadarMode(GameManager.radarMode);
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		private void OnTNHRadarColorClicked(Text textRef)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
			else if (ThreadManager.host)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				GameManager.radarColor = !GameManager.radarColor;
				textRef.text = "Radar color IFF (" + GameManager.radarColor + ")";
				if (GameManager.radarColor)
				{
					foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
					{
						if ((Object)(object)player.Value.reticleContact == (Object)null)
						{
							player.Value.reticleContact.R_Arrow.material.color = ((player.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? Color.green : Color.red);
							player.Value.reticleContact.R_Icon.material.color = ((player.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? Color.green : Color.red);
						}
					}
				}
				else
				{
					foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
					{
						if ((Object)(object)player2.Value.reticleContact == (Object)null)
						{
							player2.Value.reticleContact.R_Arrow.material.color = GameManager.colors[player2.Value.colorIndex];
							player2.Value.reticleContact.R_Icon.material.color = GameManager.colors[player2.Value.colorIndex];
						}
					}
				}
				ServerSend.RadarColor(GameManager.radarColor);
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		private void OnHostStartHoldClicked(Text textRef)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			if (Mod.currentTNHInstance != null && !Mod.currentTNHInstance.holdOngoing && Mod.currentTNHInstance.controller != -1)
			{
				if (Mod.currentTNHInstance.controller != GameManager.ID)
				{
					if (ThreadManager.host)
					{
						ServerSend.TNHHostStartHold(Mod.currentTNHInstance.instance);
					}
					else
					{
						ClientSend.TNHHostStartHold(Mod.currentTNHInstance.instance);
					}
					return;
				}
				if ((Object)(object)Mod.currentTNHInstance.manager != (Object)null)
				{
					SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
					GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].SpawnPoint_SystemNode.position, true);
					Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasActivated = true;
					Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasInitiatedHold = true;
					Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].BeginHoldChallenge();
					return;
				}
			}
			SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
		}

		private void OnNextOptionsClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			SetPage(currentPage + 1);
		}

		private void OnPrevOptionsClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			SetPage(currentPage - 1);
		}

		private void OnMaxHealthClicked(Text textRef)
		{
		}

		private void OnNextMaxHealthClicked(Text textRef)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
			else if (ThreadManager.host)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				GameManager.maxHealthIndex++;
				if (GameManager.maxHealthIndex >= GameManager.maxHealths.Length)
				{
					GameManager.maxHealthIndex = -1;
				}
				UpdateMaxHealth(GameManager.scene, GameManager.instance, GameManager.maxHealthIndex, GM.CurrentPlayerBody.GetMaxHealthPlayerRaw());
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		private void OnPreviousMaxHealthClicked(Text textRef)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Mod.managerObject == (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
			else if (ThreadManager.host)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				GameManager.maxHealthIndex--;
				if (GameManager.maxHealthIndex < -1)
				{
					GameManager.maxHealthIndex = GameManager.maxHealths.Length;
				}
				UpdateMaxHealth(GameManager.scene, GameManager.instance, GameManager.maxHealthIndex, GM.CurrentPlayerBody.GetMaxHealthPlayerRaw());
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		public static void UpdateMaxHealth(string scene, int instance, int index, float original, int clientID = 0)
		{
			Mod.LogInfo("UpdateMaxHealth: " + scene + "/" + instance + ", to index: " + index + " with original: " + original + " and clientID: " + clientID, debug: false);
			if (index != -2 && ThreadManager.host)
			{
				Mod.LogInfo("\tHost, sending", debug: false);
				ServerSend.MaxHealth(scene, instance, index, original, clientID);
			}
			switch (index)
			{
			case -2:
			{
				Mod.LogInfo("\tIndex -2, setting to value in our current scene/instance", debug: false);
				if (!GameManager.overrideMaxHealthSetting && GameManager.maxHealthByInstanceByScene.TryGetValue(scene, out var value) && value.TryGetValue(instance, out var value2))
				{
					Mod.LogInfo("\t\tFound entry: " + value2.Key + ":" + value2.Value, debug: false);
					GameManager.maxHealthIndex = value2.Value;
					SetHealthThresholdPatch.skip++;
					GM.CurrentPlayerBody.SetHealthThreshold(GameManager.maxHealths[GameManager.maxHealthIndex]);
					SetHealthThresholdPatch.skip--;
					if ((Object)(object)maxHealthText != (Object)null)
					{
						maxHealthText.text = "Max health: " + GameManager.maxHealths[GameManager.maxHealthIndex];
					}
				}
				else
				{
					Mod.LogInfo("\t\tNo entry found", debug: false);
					GameManager.maxHealthIndex = -1;
					if ((Object)(object)maxHealthText != (Object)null)
					{
						maxHealthText.text = "Max health: Not set";
					}
				}
				return;
			}
			case -1:
			{
				Mod.LogInfo("\tIndex -1, unsetting max health entry for given scene/instance", debug: false);
				if (GameManager.scene.Equals(scene) && GameManager.instance == instance)
				{
					Mod.LogInfo("\t\tCurrent scene/instance, setting index and text", debug: false);
					GameManager.maxHealthIndex = -1;
					if ((Object)(object)maxHealthText != (Object)null)
					{
						maxHealthText.text = "Max health: Not set";
					}
				}
				if (GameManager.maxHealthByInstanceByScene.TryGetValue(scene, out var value3) && value3.TryGetValue(instance, out var value4))
				{
					Mod.LogInfo("\t\tHave entry", debug: false);
					if ((Object)(object)GM.CurrentPlayerBody != (Object)null && GameManager.scene.Equals(scene) && GameManager.instance == instance)
					{
						Mod.LogInfo("\t\t\tCurrent scene/instance and we have body, resetting our health to scene default: " + value4.Key, debug: false);
						SetHealthThresholdPatch.skip++;
						GM.CurrentPlayerBody.SetHealthThreshold(value4.Key);
						SetHealthThresholdPatch.skip--;
					}
					value3.Remove(instance);
					if (value3.Count == 0)
					{
						GameManager.maxHealthByInstanceByScene.Remove(scene);
					}
				}
				return;
			}
			}
			Mod.LogInfo("\tIndex > -1, setting max health entry for given scene/instance", debug: false);
			if (GameManager.maxHealthByInstanceByScene.TryGetValue(scene, out var value5))
			{
				if (value5.TryGetValue(instance, out var value6))
				{
					Mod.LogInfo("\t\tReplacing existing entry", debug: false);
					value5[instance] = new KeyValuePair<float, int>(value6.Key, index);
				}
				else
				{
					Mod.LogInfo("\t\tAdding entry in new instance", debug: false);
					value5.Add(instance, new KeyValuePair<float, int>(original, index));
				}
			}
			else
			{
				Mod.LogInfo("\t\tAdding entry in new scene", debug: false);
				Dictionary<int, KeyValuePair<float, int>> dictionary = new Dictionary<int, KeyValuePair<float, int>>();
				GameManager.maxHealthByInstanceByScene.Add(scene, dictionary);
				dictionary.Add(instance, new KeyValuePair<float, int>(original, index));
			}
			if (GameManager.scene.Equals(scene) && GameManager.instance == instance)
			{
				Mod.LogInfo("\t\tCurrent scene/instance, setting index", debug: false);
				GameManager.maxHealthIndex = index;
				if ((Object)(object)maxHealthText != (Object)null)
				{
					maxHealthText.text = "Max health: " + GameManager.maxHealths[GameManager.maxHealthIndex];
				}
				if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
				{
					Mod.LogInfo("\t\t\tWe have a body, setting max health", debug: false);
					SetHealthThresholdPatch.skip++;
					GM.CurrentPlayerBody.SetHealthThreshold(GameManager.maxHealths[GameManager.maxHealthIndex]);
					SetHealthThresholdPatch.skip--;
				}
			}
		}

		private void OnSetRespawnPointClicked(Text textRef)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GM.CurrentSceneSettings != (Object)null && (Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
				Transform val = GM.CurrentSceneSettings.DeathResetPoint;
				if ((Object)(object)val == (Object)null)
				{
					val = new GameObject("DeathResetPoint").transform;
					GM.CurrentSceneSettings.DeathResetPoint = val;
				}
				val.position = ((Component)GM.CurrentPlayerBody).transform.position;
				val.rotation = ((Component)GM.CurrentPlayerBody).transform.rotation;
			}
			else
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
			}
		}

		private void OnDisableHoldSosigsClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			Sosig[] array = Object.FindObjectsOfType<Sosig>();
			if (array != null)
			{
				for (int i = 0; i < array.Length; i++)
				{
					array[i].SetCurrentOrder((SosigOrder)0);
				}
			}
			disabledHoldSosigs = !disabledHoldSosigs;
		}

		private void OnInvulnerableClicked(Text textRef)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			invulnerable = !invulnerable;
			invulnerableText.text = "Debug: Invulnerable: " + invulnerable;
		}

		private void OnTPToPlayerClicked(Text textRef)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.playersPresent.Count == 0)
			{
				SM.PlayGlobalUISound((GlobalUISound)2, ((Component)this).transform.position);
				return;
			}
			SM.PlayGlobalUISound((GlobalUISound)0, ((Component)this).transform.position);
			int key = GameManager.playersPresent[Random.Range(0, GameManager.playersPresent.Count - 1)];
			GM.CurrentMovementManager.TeleportToPoint(GameManager.players[key].head.position, true);
		}

		private void ProcessPlayerPrefabIndex(int index, Text text)
		{
			if (GameManager.playerPrefabIndex == -1)
			{
				GameManager.playerPrefabID = "None";
				if ((Object)(object)GameManager.currentPlayerBody != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)GameManager.currentPlayerBody).gameObject);
				}
				text.text = "Body: None";
			}
			else
			{
				string text2 = GameManager.playerPrefabIDs[GameManager.playerPrefabIndex];
				if (!GameManager.playerPrefabID.Equals(text2))
				{
					GameManager.SetPlayerPrefab(text2);
				}
			}
		}

		private void SetPage(int index)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (currentPage != -1 && pages.TryGetValue(currentPage, out var value))
			{
				for (int i = 0; i < value.Count; i++)
				{
					((Component)value[i].Key).gameObject.SetActive(false);
				}
			}
			if (pages.TryGetValue(index, out var value2))
			{
				for (int j = 0; j < value2.Count; j++)
				{
					((Component)value2[j].Key).gameObject.SetActive(true);
					((Transform)((Component)value2[j].Key).GetComponent<RectTransform>()).localPosition = value2[j].Value;
				}
			}
			currentPage = index;
		}
	}
}
namespace H3MP.Networking
{
	public class ISClient
	{
		public enum Packets
		{
			welcome,
			ping
		}

		private delegate void PacketHandler(Packet packet);

		public delegate void OnReceiveHostEntriesDelegate(List<ISEntry> entries);

		public delegate void OnDisconnectDelegate();

		public delegate void OnListedDelegate(int ID);

		public static GameObject managerObject;

		public static int dataBufferSize = 4096;

		public static int ID = -1;

		public static bool isConnected = false;

		public static bool gotWelcome = false;

		public static int pingAttemptCounter = 0;

		private static PacketHandler[] packetHandlers;

		public static TcpClient socket;

		public static NetworkStream stream;

		public static Packet receivedData;

		public static byte[] receiveBuffer;

		public static bool wantListed;

		public static bool listed;

		public static event OnReceiveHostEntriesDelegate OnReceiveHostEntries;

		public static event OnDisconnectDelegate OnDisconnect;

		public static event OnListedDelegate OnListed;

		public static void Connect(string IP, ushort port)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if ((Object)(object)managerObject == (Object)null)
			{
				managerObject = new GameObject("ISManagerObject");
				ISThreadManager iSThreadManager = managerObject.AddComponent<ISThreadManager>();
				Object.DontDestroyOnLoad((Object)(object)managerObject);
			}
			InitializeClientData();
			isConnected = true;
			gotWelcome = false;
			wantListed = false;
			listed = false;
			socket = new TcpClient
			{
				ReceiveBufferSize = dataBufferSize,
				SendBufferSize = dataBufferSize
			};
			string text = IP;
			IPAddress[] hostAddresses = Dns.GetHostAddresses(IP);
			if (hostAddresses != null && hostAddresses.Length != 0)
			{
				bool flag = false;
				for (int i = 0; i < hostAddresses.Length; i++)
				{
					if (hostAddresses[i].GetAddressBytes()[0] != 192)
					{
						text = hostAddresses[i].ToString();
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					Mod.LogWarning("Did not find an address that does not start with 192 from IS sub domain. Using first IP.");
					text = hostAddresses[0].ToString();
				}
			}
			else
			{
				Mod.LogError("Did not get any address from IS sub domain! Connection to IS will fail.");
			}
			receiveBuffer = new byte[dataBufferSize];
			Mod.LogInfo("Making connection to IS: " + text + ":" + port, debug: false);
			socket.BeginConnect(text, port, ConnectCallback, socket);
		}

		private static void ConnectCallback(IAsyncResult result)
		{
			socket.EndConnect(result);
			if (socket.Connected)
			{
				stream = socket.GetStream();
				receivedData = new Packet();
				stream.BeginRead(receiveBuffer, 0, dataBufferSize, ReceiveCallback, null);
			}
		}

		public static void SendData(Packet packet, bool overrideWelcome = false)
		{
			if (!(gotWelcome || overrideWelcome))
			{
				return;
			}
			try
			{
				if (socket != null)
				{
					stream.BeginWrite(packet.ToArray(), 0, packet.Length(), null, null);
				}
			}
			catch (Exception ex)
			{
				Mod.LogInfo("Error sending data to IS: " + ex.Message, debug: false);
			}
		}

		private static void ReceiveCallback(IAsyncResult result)
		{
			try
			{
				int num = stream.EndRead(result);
				if (num == 0)
				{
					Disconnect(sendToServer: true, 1);
					return;
				}
				byte[] array = new byte[num];
				Array.Copy(receiveBuffer, array, num);
				int num2 = HandleData(array);
				if (num2 > 0)
				{
					receivedData.Reset(num2 == 2);
				}
				stream.BeginRead(receiveBuffer, 0, dataBufferSize, ReceiveCallback, null);
			}
			catch (Exception)
			{
				Disconnect(2);
			}
		}

		private static int HandleData(byte[] data)
		{
			int num = 0;
			bool flag = false;
			receivedData.SetBytes(data);
			if (receivedData.UnreadLength() >= 4)
			{
				num = receivedData.ReadInt();
				flag = true;
				if (num <= 0)
				{
					return 2;
				}
			}
			while (num > 0 && num <= receivedData.UnreadLength())
			{
				flag = false;
				byte[] packetBytes = receivedData.ReadBytes(num);
				ISThreadManager.ExecuteOnMainThread(delegate
				{
					if (isConnected)
					{
						using (Packet packet = new Packet(packetBytes))
						{
							int num2 = packet.ReadInt();
							packetHandlers[num2](packet);
						}
					}
				});
				num = 0;
				if (receivedData.UnreadLength() >= 4)
				{
					num = receivedData.ReadInt();
					flag = true;
					if (num <= 0)
					{
						return 2;
					}
				}
			}
			if (num == 0 && receivedData.UnreadLength() == 0)
			{
				return 2;
			}
			return flag ? 1 : 0;
		}

		private static void Disconnect(int code)
		{
			Disconnect(sendToServer: false, code);
			stream = null;
			receiveBuffer = null;
			receivedData = null;
			socket = null;
		}

		private static void InitializeClientData()
		{
			packetHandlers = new PacketHandler[10]
			{
				ISClientHandle.Welcome,
				ISClientHandle.Ping,
				ISClientHandle.HostEntries,
				ISClientHandle.Listed,
				ISClientHandle.Connect,
				ISClientHandle.ConfirmConnection,
				ISClientHandle.Admin,
				null,
				ISClientHandle.Unlisted,
				ISClientHandle.Modlist
			};
			Mod.LogInfo("Initialized IS client", debug: false);
		}

		public static void Disconnect(bool sendToServer, int code)
		{
			if (isConnected)
			{
				isConnected = false;
				bool flag = false;
				switch (code)
				{
				case -1:
					Mod.LogWarning("Disconnecting from IS due to application quit.");
					break;
				case 0:
					Mod.LogWarning("Disconnecting from IS.");
					break;
				case 1:
					Mod.LogWarning("Connection to IS lost, end of stream. Attempting to reconnect...");
					flag = true;
					break;
				case 2:
					Mod.LogWarning("Connection to IS lost, TCP forced. Attempting to reconnect...");
					flag = true;
					break;
				case 4:
					Mod.LogWarning("Connection to IS failed, timed out.");
					break;
				case 5:
					Mod.LogWarning("Connection to IS failed, wrong H3MP version. Minimum: " + ServerListController.minimumVersion);
					break;
				}
				if (sendToServer)
				{
					ISClientSend.Disconnect();
				}
				if (socket != null)
				{
					socket.Close();
				}
				socket = null;
				if (stream != null)
				{
					stream.Close();
				}
				stream = null;
				receiveBuffer = null;
				receivedData = null;
				Object.Destroy((Object)(object)managerObject);
				ID = -1;
				if (flag)
				{
				}
				if (ISClient.OnDisconnect != null)
				{
					ISClient.OnDisconnect();
				}
			}
		}

		public static void OnReceiveHostEntriesInvoke(List<ISEntry> entries)
		{
			if (ISClient.OnReceiveHostEntries != null)
			{
				ISClient.OnReceiveHostEntries(entries);
			}
		}

		public static void OnListedInvoke(int ID)
		{
			if (ISClient.OnListed != null)
			{
				ISClient.OnListed(ID);
			}
		}
	}
	public class ISClientHandle
	{
		public static void Welcome(Packet packet)
		{
			string text = packet.ReadString();
			int iD = packet.ReadInt();
			ServerListController.minimumVersion = packet.ReadString();
			Mod.LogInfo("Message from server: " + text, debug: false);
			if ("1.14.0".Equals(ServerListController.minimumVersion))
			{
				ISClient.gotWelcome = true;
				ISClient.ID = iD;
				ISClientSend.WelcomeReceived();
				ISClientSend.RequestHostEntries();
				return;
			}
			string[] array = ServerListController.minimumVersion.Split(new char[1] { '.' });
			int num = int.Parse(array[0]);
			int num2 = int.Parse(array[1]);
			int num3 = int.Parse(array[2]);
			array = "1.14.0".Split(new char[1] { '.' });
			int num4 = int.Parse(array[0]);
			int num5 = int.Parse(array[1]);
			int num6 = int.Parse(array[2]);
			if (num4 > num || num5 > num2 || num6 > num3)
			{
				ISClient.gotWelcome = true;
				ISClient.ID = iD;
				ISClientSend.WelcomeReceived();
				ISClientSend.RequestHostEntries();
			}
			else
			{
				ServerListController.failedConnectionReason = "H3MP version required to use server list: " + ServerListController.minimumVersion + "+. You need to update. If version not available yet, it will be released soon.";
				ISClient.Disconnect(sendToServer: true, 5);
			}
		}

		public static void Ping(Packet packet)
		{
			GameManager.ping = Convert.ToInt64((DateTime.Now.ToUniversalTime() - ISThreadManager.epoch).TotalMilliseconds) - packet.ReadLong();
		}

		public static void HostEntries(Packet packet)
		{
			List<ISEntry> list = new List<ISEntry>();
			int num = packet.ReadInt();
			for (int i = 0; i < num; i++)
			{
				ISEntry iSEntry = new ISEntry();
				iSEntry.ID = packet.ReadInt();
				iSEntry.name = packet.ReadString();
				iSEntry.playerCount = packet.ReadInt();
				iSEntry.limit = packet.ReadInt();
				iSEntry.locked = packet.ReadBool();
				iSEntry.modlistEnforcement = packet.ReadByte();
				list.Add(iSEntry);
			}
			ISClient.OnReceiveHostEntriesInvoke(list);
		}

		public static void Listed(Packet packet)
		{
			int iD = packet.ReadInt();
			ISClient.OnListedInvoke(iD);
		}

		public static void Connect(Packet packet)
		{
			if (!((Object)(object)ServerListController.instance != (Object)null))
			{
				return;
			}
			if (packet.ReadBool())
			{
				ServerListController.instance.gotEndPoint = true;
				int length = packet.ReadInt();
				IPAddress address = new IPAddress(packet.ReadBytes(length));
				IPEndPoint endPointOverride = new IPEndPoint(address, packet.ReadInt());
				if (ServerListController.instance.state == ServerListController.State.ClientWaiting)
				{
					ServerListController.instance.SetClientPage(waiting: true);
					Mod.OnConnectClicked(endPointOverride);
					ThreadManager.pingTimer = ThreadManager.pingTime;
				}
			}
			else
			{
				ServerListController.instance.gotEndPoint = false;
				ServerListController.instance.joiningEntry = -1;
				ServerListController.instance.SetClientPage(waiting: true);
			}
		}

		public static void Modlist(Packet packet)
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			bool flag = packet.ReadBool();
			int num = packet.ReadInt();
			List<string> list = new List<string>();
			for (int i = 0; i < num; i++)
			{
				list.Add(packet.ReadString());
			}
			if (ServerListController.modlists.TryGetValue(key, out var _))
			{
				Mod.LogError("Received modlist for entry " + key + " but we already had it? Replacing.");
				ServerListController.modlists[key] = list;
			}
			else
			{
				ServerListController.modlists.Add(key, list);
			}
			if (!((Object)(object)ServerListController.instance != (Object)null))
			{
				return;
			}
			if (flag)
			{
				if (ServerListController.instance.state == ServerListController.State.ClientWaiting)
				{
					ServerListController.instance.modlist = list;
					ServerListController.instance.SetClientPage(waiting: true);
				}
				return;
			}
			ServerListController.instance.gotEndPoint = false;
			ServerListController.instance.joiningEntry = -1;
			if (ServerListController.instance.state == ServerListController.State.ClientWaiting)
			{
				ServerListController.instance.SetClientPage(waiting: true);
				((Graphic)ServerListController.instance.clientInfoText).color = Color.red;
				ServerListController.instance.clientInfoText.text = "Error joining server: Couldn't get modlist";
			}
		}

		public static void ConfirmConnection(Packet packet)
		{
			int forClient = packet.ReadInt();
			ISClientSend.ConfirmConnection((Object)(object)Mod.managerObject != (Object)null && ThreadManager.host && ISClient.isConnected && ISClient.listed && GameManager.players.Count < Server.maxClientCount, forClient);
		}

		public static void Admin(Packet packet)
		{
			switch (packet.ReadInt())
			{
			case 0:
				Mod.LogInfo("Received IS admin 0: Clients: " + packet.ReadInt());
				break;
			case 1:
			{
				int num = packet.ReadInt();
				Mod.LogInfo("Received IS admin 1: Host entries: " + num);
				for (int i = 0; i < num; i++)
				{
					Mod.LogInfo("\n-----------\nEntry: " + packet.ReadInt() + "\nClient: " + packet.ReadInt() + "\nEndPoint: " + packet.ReadString() + "\nName: " + packet.ReadString() + "\nPlayer count: " + packet.ReadInt() + "/" + packet.ReadInt() + "\nHas Password: " + packet.ReadBool());
				}
				break;
			}
			}
		}

		public static void Unlisted(Packet packet)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (ISClient.listed)
			{
				ISClient.listed = false;
				if ((Object)(object)ServerListController.instance != (Object)null && ServerListController.instance.state == ServerListController.State.Hosting)
				{
					((Graphic)ServerListController.instance.hostingListButtonText).color = Color.yellow;
					ServerListController.instance.hostingListButtonText.text = "Private";
					((Selectable)ServerListController.instance.hostingListButton).interactable = true;
				}
			}
		}
	}
	public class ISClientSend
	{
		public enum Packets
		{
			welcomeReceived,
			ping,
			requestHostEntries,
			list,
			unlist,
			disconnect,
			join,
			playerCount,
			confirmConnection,
			admin,
			reserved0,
			reserved1,
			reserved2,
			requestModlist
		}

		public static void SendTCPData(Packet packet, bool custom = false)
		{
			packet.WriteLength();
			ISClient.SendData(packet);
		}

		public static void WelcomeReceived()
		{
			using Packet packet = new Packet(0);
			packet.Write("1.14.0");
			SendTCPData(packet);
		}

		public static void Ping(long time)
		{
			using Packet packet = new Packet(1);
			packet.Write(time);
			SendTCPData(packet);
		}

		public static void RequestHostEntries()
		{
			using Packet packet = new Packet(2);
			SendTCPData(packet);
		}

		public static void List(string name, int limit, string password, ushort port, int modlistEnforcement)
		{
			using Packet packet = new Packet(3);
			packet.Write(name);
			packet.Write(limit);
			if (password != null && !password.Equals(""))
			{
				packet.Write(_value: true);
				packet.Write(Mod.GetSHA256Hash(password));
			}
			else
			{
				packet.Write(_value: false);
			}
			packet.Write(port);
			packet.Write((byte)modlistEnforcement);
			if (modlistEnforcement != 2)
			{
				packet.Write(Chainloader.PluginInfos.Count);
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					packet.Write(pluginInfo.Key);
				}
			}
			SendTCPData(packet);
		}

		public static void Unlist()
		{
			using Packet packet = new Packet(4);
			SendTCPData(packet);
		}

		public static void Disconnect()
		{
			using Packet packet = new Packet(5);
			SendTCPData(packet);
		}

		public static void Join(int ID, string passwordHash)
		{
			using Packet packet = new Packet(6);
			packet.Write(ID);
			packet.Write(passwordHash);
			SendTCPData(packet);
		}

		public static void RequestModlist(int ID, string passwordHash)
		{
			using Packet packet = new Packet(13);
			packet.Write(ID);
			packet.Write(passwordHash);
			SendTCPData(packet);
		}

		public static void PlayerCount(int count)
		{
			using Packet packet = new Packet(7);
			packet.Write(count);
			SendTCPData(packet);
		}

		public static void ConfirmConnection(bool valid, int forClient)
		{
			using Packet packet = new Packet(8);
			packet.Write(valid);
			packet.Write(forClient);
			SendTCPData(packet);
		}

		public static void Admin(int key, string p)
		{
			using Packet packet = new Packet(9);
			packet.Write(key);
			packet.Write(Mod.GetSHA256Hash(p));
			SendTCPData(packet);
		}
	}
	public class ISEntry
	{
		public int ID;

		public string name;

		public int playerCount;

		public int limit;

		public bool locked;

		public int modlistEnforcement;
	}
	public class ISThreadManager : MonoBehaviour
	{
		private static readonly List<Action> executeOnMainThread = new List<Action>();

		private static readonly List<Action> executeCopiedOnMainThread = new List<Action>();

		private static bool actionToExecuteOnMainThread = false;

		public static readonly DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

		private static readonly float pingTime = 1f;

		private static float pingTimer = pingTime;

		private void Update()
		{
			UpdateMain();
		}

		public static void ExecuteOnMainThread(Action _action)
		{
			if (_action == null)
			{
				Mod.LogInfo("ISThreadManager: No action to execute on main thread!", debug: false);
				return;
			}
			lock (executeOnMainThread)
			{
				executeOnMainThread.Add(_action);
				actionToExecuteOnMainThread = true;
			}
		}

		public static void UpdateMain()
		{
			if (actionToExecuteOnMainThread)
			{
				executeCopiedOnMainThread.Clear();
				lock (executeOnMainThread)
				{
					executeCopiedOnMainThread.AddRange(executeOnMainThread);
					executeOnMainThread.Clear();
					actionToExecuteOnMainThread = false;
				}
				for (int i = 0; i < executeCopiedOnMainThread.Count; i++)
				{
					executeCopiedOnMainThread[i]();
				}
			}
			pingTimer -= Time.deltaTime;
			if (!(pingTimer <= 0f))
			{
				return;
			}
			pingTimer = pingTime;
			if (ISClient.gotWelcome)
			{
				ISClientSend.Ping(Convert.ToInt64((DateTime.Now.ToUniversalTime() - epoch).TotalMilliseconds));
				return;
			}
			ISClient.pingAttemptCounter++;
			if (ISClient.pingAttemptCounter >= 5)
			{
				Mod.LogWarning("Have not received IS welcome for " + ISClient.pingAttemptCounter + " seconds, timing out at 10");
			}
			if (ISClient.pingAttemptCounter >= 10)
			{
				ISClient.pingAttemptCounter = 0;
				ISClient.Disconnect(sendToServer: false, 4);
			}
		}
	}
	public class Client : MonoBehaviour
	{
		public delegate void PacketHandler(Packet packet);

		public delegate void OnDisconnectDelegate();

		public class TCP
		{
			public TcpClient socket;

			public NetworkStream stream;

			public Packet receivedData;

			public byte[] receiveBuffer;

			public void Connect()
			{
				socket = new TcpClient
				{
					ReceiveBufferSize = dataBufferSize,
					SendBufferSize = dataBufferSize
				};
				receiveBuffer = new byte[dataBufferSize];
				Mod.LogInfo("Attempting connection to " + singleton.IP + ":" + singleton.port, debug: false);
				connectResult = socket.BeginConnect(singleton.IP, singleton.port, ConnectCallback, socket);
			}

			public void ConnectCallback(IAsyncResult result)
			{
				Mod.LogInfo("Got connect callback");
				socket.EndConnect(result);
				if (socket.Connected)
				{
					stream = socket.GetStream();
					receivedData = new Packet();
					stream.BeginRead(receiveBuffer, 0, dataBufferSize, ReceiveCallback, null);
				}
			}

			public void SendData(Packet packet, bool overrideWelcome = false)
			{
				if (!(singleton.gotWelcome || overrideWelcome))
				{
					return;
				}
				try
				{
					if (socket != null)
					{
						stream.BeginWrite(packet.ToArray(), 0, packet.Length(), null, null);
					}
				}
				catch (Exception arg)
				{
					Mod.LogInfo($"Error sending data to server via TCP: {arg}", debug: false);
				}
			}

			private void ReceiveCallback(IAsyncResult result)
			{
				try
				{
					int num = stream.EndRead(result);
					if (num == 0)
					{
						singleton.Disconnect(sendToServer: true, 1);
						return;
					}
					byte[] array = new byte[num];
					Array.Copy(receiveBuffer, array, num);
					int num2 = HandleData(array);
					if (num2 > 0)
					{
						receivedData.Reset(num2 == 2);
					}
					stream.BeginRead(receiveBuffer, 0, dataBufferSize, ReceiveCallback, null);
				}
				catch (Exception)
				{
					Disconnect(2);
				}
			}

			private int HandleData(byte[] data)
			{
				int packetLength = 0;
				bool flag = false;
				receivedData.SetBytes(data);
				if (receivedData.UnreadLength() >= 4)
				{
					packetLength = receivedData.ReadInt();
					flag = true;
					if (packetLength <= 0)
					{
						return 2;
					}
				}
				while (packetLength > 0 && packetLength <= receivedData.UnreadLength())
				{
					flag = false;
					byte[] packetBytes = receivedData.ReadBytes(packetLength);
					ThreadManager.ExecuteOnMainThread(delegate
					{
						if (singleton.isConnected)
						{
							using (Packet packet = new Packet(packetBytes))
							{
								int num = packet.ReadInt();
								try
								{
									if (singleton.ID >= 0 || num == 0)
									{
										if (num < 0)
										{
											if (num == -1)
											{
												Mod.GenericCustomPacketReceivedInvoke(0, packet.ReadString(), packet);
											}
											else
											{
												int num2 = num * -1 - 2;
												if (Mod.customPacketHandlers.Length > num2 && Mod.customPacketHandlers[num2] != null)
												{
													if (Input.GetKey((KeyCode)281))
													{
														Mod.LogInfo("\tHandling custom TCP packet: " + num);
													}
													Mod.customPacketHandlers[num2](0, packet);
												}
												else
												{
													Mod.LogWarning("\tClient received invalid custom TCP packet ID: " + num);
												}
											}
										}
										else
										{
											if (Input.GetKey((KeyCode)281))
											{
												string[] obj = new string[6]
												{
													"\tHandling TCP packet: ",
													num.ToString(),
													" (",
													null,
													null,
													null
												};
												ServerPackets serverPackets = (ServerPackets)num;
												obj[3] = serverPackets.ToString();
												obj[4] = "), length: ";
												obj[5] = packet.buffer.Count.ToString();
												Mod.LogInfo(string.Concat(obj));
											}
											packetHandlers[num](packet);
										}
									}
								}
								catch (IndexOutOfRangeException ex)
								{
									string[] obj2 = new string[8]
									{
										"Client TCP received packet with ID: ",
										num.ToString(),
										" as ServerPackets: ",
										null,
										null,
										null,
										null,
										null
									};
									ServerPackets serverPackets = (ServerPackets)num;
									obj2[3] = serverPackets.ToString();
									obj2[4] = " with packetLength: ";
									obj2[5] = packetLength.ToString();
									obj2[6] = ":\n";
									obj2[7] = ex.StackTrace;
									Mod.LogError(string.Concat(obj2));
								}
							}
						}
					});
					packetLength = 0;
					if (receivedData.UnreadLength() >= 4)
					{
						packetLength = receivedData.ReadInt();
						flag = true;
						if (packetLength <= 0)
						{
							return 2;
						}
					}
				}
				if (packetLength == 0 && receivedData.UnreadLength() == 0)
				{
					return 2;
				}
				return flag ? 1 : 0;
			}

			private void Disconnect(int code)
			{
				singleton.Disconnect(sendToServer: false, code);
				stream = null;
				receiveBuffer = null;
				receivedData = null;
				socket = null;
			}
		}

		public class UDP
		{
			public UdpClient socket;

			public IPEndPoint endPoint;

			public UDP()
			{
				endPoint = new IPEndPoint(IPAddress.Parse(singleton.IP), singleton.port);
			}

			public void Connect(int localPort)
			{
				socket = new UdpClient(localPort);
				socket.Connect(endPoint);
				socket.BeginReceive(ReceiveCallback, null);
				using Packet packet = new Packet();
				SendData(packet);
			}

			public void SendData(Packet packet)
			{
				try
				{
					packet.InsertInt(singleton.ID);
					if (socket != null)
					{
						socket.BeginSend(packet.ToArray(), packet.Length(), null, null);
					}
				}
				catch (Exception arg)
				{
					Mod.LogInfo($"Error sending UDP data {arg}", debug: false);
				}
			}

			private void ReceiveCallback(IAsyncResult result)
			{
				if (!singleton.isConnected)
				{
					return;
				}
				try
				{
					byte[] array = socket.EndReceive(result, ref endPoint);
					socket.BeginReceive(ReceiveCallback, null);
					if (array.Length < 4)
					{
						singleton.Disconnect(sendToServer: true, 1);
					}
					else
					{
						HandleData(array);
					}
				}
				catch (Exception)
				{
					Disconnect(2);
				}
			}

			public void HandleData(byte[] data)
			{
				using (Packet packet = new Packet(data))
				{
					int length = packet.ReadInt();
					data = packet.ReadBytes(length);
				}
				ThreadManager.ExecuteOnMainThread(delegate
				{
					if (singleton.isConnected)
					{
						using (Packet packet2 = new Packet(data))
						{
							int num = packet2.ReadInt();
							if (num < 0)
							{
								if (num == -1)
								{
									Mod.GenericCustomPacketReceivedInvoke(0, packet2.ReadString(), packet2);
								}
								else
								{
									int num2 = num * -1 - 2;
									if (Mod.customPacketHandlers.Length > num2 && Mod.customPacketHandlers[num2] != null)
									{
										if (Input.GetKey((KeyCode)281))
										{
											Mod.LogInfo("\tHandling custom UDP packet: " + num);
										}
										Mod.customPacketHandlers[num2](0, packet2);
									}
									else
									{
										Mod.LogWarning("\tClient received invalid custom UDP packet ID: " + num);
									}
								}
							}
							else
							{
								if (Input.GetKey((KeyCode)281))
								{
									string[] obj = new string[6]
									{
										"\tHandling UDP packet: ",
										num.ToString(),
										" (",
										null,
										null,
										null
									};
									ServerPackets serverPackets = (ServerPackets)num;
									obj[3] = serverPackets.ToString();
									obj[4] = "), length: ";
									obj[5] = packet2.buffer.Count.ToString();
									Mod.LogInfo(string.Concat(obj));
								}
								packetHandlers[num](packet2);
							}
						}
					}
				});
			}

			private void Disconnect(int code)
			{
				singleton.Disconnect(sendToServer: false, code);
				endPoint = null;
				socket = null;
			}
		}

		private static Client _singleton;

		public static int dataBufferSize = 4096;

		public string IP;

		public ushort port;

		public int ID = -1;

		public TCP tcp;

		public UDP udp;

		public bool isConnected = false;

		public static bool isFullyConnected = false;

		public bool gotWelcome = false;

		public bool gotConnectSync = false;

		public int pingAttemptCounter = 0;

		public static PacketHandler[] packetHandlers;

		public static Dictionary<string, int> synchronizedScenes;

		public static TrackedObjectData[] objects;

		public static uint localObjectCounter = 0u;

		public static Dictionary<uint, TrackedObjectData> waitingLocalObjects = new Dictionary<uint, TrackedObjectData>();

		public static IAsyncResult connectResult;

		public System.Timers.Timer tickTimer = new System.Timers.Timer();

		public static Client singleton
		{
			get
			{
				return _singleton;
			}
			private set
			{
				if ((Object)(object)_singleton == (Object)null)
				{
					_singleton = value;
				}
				else if ((Object)(object)_singleton != (Object)(object)value)
				{
					Mod.LogInfo("Client instance already exists, destroying duplicate!", debug: false);
					Object.Destroy((Object)(object)value);
				}
			}
		}

		public static event OnDisconnectDelegate OnDisconnect;

		private void Awake()
		{
			singleton = this;
		}

		private void Start()
		{
			if (tcp == null)
			{
				tcp = new TCP();
				udp = new UDP();
			}
		}

		public void ConnectToServer()
		{
			if (tcp == null)
			{
				tcp = new TCP();
				udp = new UDP();
			}
			InitializeClientData();
			isConnected = true;
			tcp.Connect();
		}

		public void SetTickRate(int tickRate)
		{
			tickTimer.Elapsed += Tick;
			tickTimer.Interval = 1000f / (float)tickRate;
			tickTimer.AutoReset = true;
			tickTimer.Start();
		}

		private void Tick(object sender, ElapsedEventArgs e)
		{
			ClientSend.SendBatchedPackets();
		}

		private void InitializeClientData()
		{
			packetHandlers = new PacketHandler[209]
			{
				ClientHandle.Welcome,
				ClientHandle.SpawnPlayer,
				ClientHandle.PlayerState,
				ClientHandle.PlayerScene,
				null,
				ClientHandle.ShatterableCrateSetHoldingHealth,
				ClientHandle.GiveObjectControl,
				ClientHandle.ObjectParent,
				ClientHandle.ConnectSync,
				ClientHandle.WeaponFire,
				ClientHandle.PlayerDamage,
				ClientHandle.SosigPickUpItem,
				ClientHandle.SosigPlaceItemIn,
				ClientHandle.SosigDropSlot,
				ClientHandle.SosigHandDrop,
				ClientHandle.SosigConfigure,
				ClientHandle.SosigLinkRegisterWearable,
				ClientHandle.SosigLinkDeRegisterWearable,
				ClientHandle.SosigSetIFF,
				ClientHandle.SosigSetOriginalIFF,
				ClientHandle.SosigLinkDamage,
				ClientHandle.SosigDamageData,
				ClientHandle.SosigWearableDamage,
				ClientHandle.SosigLinkExplodes,
				ClientHandle.SosigDies,
				ClientHandle.SosigClear,
				ClientHandle.SosigSetBodyState,
				ClientHandle.PlaySosigFootStepSound,
				ClientHandle.SosigSpeakState,
				ClientHandle.SosigSetCurrentOrder,
				ClientHandle.SosigVaporize,
				ClientHandle.SosigRequestHitDecal,
				ClientHandle.SosigLinkBreak,
				ClientHandle.SosigLinkSever,
				ClientHandle.RequestUpToDateObjects,
				ClientHandle.PlayerInstance,
				ClientHandle.AddTNHInstance,
				ClientHandle.AddTNHCurrentlyPlaying,
				ClientHandle.RemoveTNHCurrentlyPlaying,
				ClientHandle.SetTNHProgression,
				ClientHandle.SetTNHEquipment,
				ClientHandle.SetTNHHealthMode,
				ClientHandle.SetTNHTargetMode,
				ClientHandle.SetTNHAIDifficulty,
				ClientHandle.SetTNHRadarMode,
				ClientHandle.SetTNHItemSpawnerMode,
				ClientHandle.SetTNHBackpackMode,
				ClientHandle.SetTNHHealthMult,
				ClientHandle.SetTNHSosigGunReload,
				ClientHandle.SetTNHSeed,
				ClientHandle.SetTNHLevelID,
				ClientHandle.AddInstance,
				ClientHandle.SetTNHController,
				ClientHandle.SpectatorHost,
				ClientHandle.TNHPlayerDied,
				ClientHandle.TNHAddTokens,
				ClientHandle.TNHSetLevel,
				ClientHandle.AutoMeaterSetState,
				ClientHandle.AutoMeaterSetBladesActive,
				ClientHandle.AutoMeaterDamage,
				ClientHandle.AutoMeaterFirearmFireShot,
				ClientHandle.AutoMeaterFirearmFireAtWill,
				ClientHandle.AutoMeaterHitZoneDamage,
				ClientHandle.AutoMeaterHitZoneDamageData,
				ClientHandle.TNHSosigKill,
				ClientHandle.TNHHoldPointSystemNode,
				ClientHandle.TNHHoldBeginChallenge,
				ClientHandle.TNHSetPhaseTake,
				ClientHandle.TNHHoldCompletePhase,
				ClientHandle.TNHHoldPointFailOut,
				ClientHandle.TNHSetPhaseComplete,
				ClientHandle.TNHSetPhase,
				ClientHandle.EncryptionDamage,
				ClientHandle.EncryptionDamageData,
				ClientHandle.EncryptionRespawnSubTarg,
				ClientHandle.EncryptionSpawnGrowth,
				ClientHandle.EncryptionInit,
				ClientHandle.EncryptionResetGrowth,
				ClientHandle.EncryptionDisableSubtarg,
				ClientHandle.EncryptionSubDamage,
				ClientHandle.ShatterableCrateDamage,
				ClientHandle.ShatterableCrateDestroy,
				ClientHandle.InitTNHInstances,
				ClientHandle.SosigWeaponFire,
				ClientHandle.SosigWeaponShatter,
				ClientHandle.SosigWeaponDamage,
				ClientHandle.LAPD2019Fire,
				ClientHandle.LAPD2019LoadBattery,
				ClientHandle.LAPD2019ExtractBattery,
				null,
				ClientHandle.AttachableFirearmFire,
				ClientHandle.BreakActionWeaponFire,
				ClientHandle.PlayerIFF,
				ClientHandle.UberShatterableShatter,
				ClientHandle.TNHHoldPointBeginAnalyzing,
				ClientHandle.TNHHoldPointRaiseBarriers,
				ClientHandle.TNHHoldIdentifyEncryption,
				ClientHandle.TNHHoldPointBeginPhase,
				ClientHandle.TNHHoldPointCompleteHold,
				ClientHandle.SosigPriorityIFFChart,
				ClientHandle.LeverActionFirearmFire,
				ClientHandle.RevolvingShotgunFire,
				ClientHandle.DerringerFire,
				ClientHandle.FlintlockWeaponBurnOffOuter,
				ClientHandle.FlintlockWeaponFire,
				ClientHandle.GrappleGunFire,
				ClientHandle.HCBReleaseSled,
				ClientHandle.RemoteMissileDetonate,
				ClientHandle.RemoteMissileDamage,
				ClientHandle.RevolverFire,
				ClientHandle.SingleActionRevolverFire,
				ClientHandle.StingerLauncherFire,
				ClientHandle.StingerMissileDamage,
				ClientHandle.StingerMissileExplode,
				ClientHandle.PinnedGrenadeExplode,
				ClientHandle.FVRGrenadeExplode,
				ClientHandle.ClientDisconnect,
				ClientHandle.ServerClosed,
				null,
				ClientHandle.BangSnapSplode,
				ClientHandle.C4Detonate,
				ClientHandle.ClaymoreMineDetonate,
				ClientHandle.SLAMDetonate,
				ClientHandle.Ping,
				ClientHandle.TNHSetPhaseHold,
				ClientHandle.ShatterableCrateSetHoldingToken,
				ClientHandle.ResetTNH,
				ClientHandle.ReviveTNHPlayer,
				ClientHandle.PlayerColor,
				ClientHandle.ColorByIFF,
				ClientHandle.NameplateMode,
				ClientHandle.RadarMode,
				ClientHandle.RadarColor,
				ClientHandle.TNHInitializer,
				ClientHandle.MaxHealth,
				ClientHandle.FuseIgnite,
				ClientHandle.FuseBoom,
				ClientHandle.MolotovShatter,
				ClientHandle.MolotovDamage,
				ClientHandle.PinnedGrenadePullPin,
				ClientHandle.MagazineAddRound,
				ClientHandle.ClipAddRound,
				ClientHandle.SpeedloaderChamberLoad,
				ClientHandle.RemoteGunChamber,
				ClientHandle.ChamberRound,
				ClientHandle.MagazineLoad,
				ClientHandle.MagazineLoadAttachable,
				ClientHandle.ClipLoad,
				ClientHandle.RevolverCylinderLoad,
				ClientHandle.RevolvingShotgunLoad,
				ClientHandle.GrappleGunLoad,
				ClientHandle.CarlGustafLatchSate,
				ClientHandle.CarlGustafShellSlideSate,
				ClientHandle.TNHHostStartHold,
				ClientHandle.IntegratedFirearmFire,
				ClientHandle.GrappleAttached,
				ClientHandle.TrackedObject,
				ClientHandle.TrackedObjects,
				ClientHandle.ObjectUpdate,
				ClientHandle.DestroyObject,
				ClientHandle.RegisterCustomPacketType,
				ClientHandle.BreakableGlassDamage,
				ClientHandle.WindowShatterSound,
				ClientHandle.SpectatorHostAssignment,
				ClientHandle.GiveUpSpectatorHost,
				ClientHandle.SpectatorHostOrderTNHHost,
				ClientHandle.TNHSpectatorHostReady,
				ClientHandle.SpectatorHostStartTNH,
				ClientHandle.UnassignSpectatorHost,
				ClientHandle.ReactiveSteelTargetDamage,
				ClientHandle.MTUTest,
				ClientHandle.IDConfirm,
				ClientHandle.EnforcePlayerModels,
				ClientHandle.ObjectScene,
				ClientHandle.ObjectInstance,
				ClientHandle.UpdateEncryptionDisplay,
				ClientHandle.EncryptionRespawnSubTargGeo,
				ClientHandle.RoundDamage,
				ClientHandle.RoundSplode,
				ClientHandle.ConnectionComplete,
				ClientHandle.SightFlipperState,
				ClientHandle.SightRaiserState,
				ClientHandle.GatlingGunFire,
				null,
				ClientHandle.GasCuboidGout,
				ClientHandle.GasCuboidDamage,
				ClientHandle.GasCuboidHandleDamage,
				ClientHandle.GasCuboidDamageHandle,
				ClientHandle.GasCuboidExplode,
				ClientHandle.GasCuboidShatter,
				ClientHandle.FloaterDamage,
				ClientHandle.FloaterCoreDamage,
				ClientHandle.FloaterBeginExploding,
				ClientHandle.FloaterExplode,
				ClientHandle.IrisShatter,
				ClientHandle.IrisSetState,
				ClientHandle.BrutBlockSystemStart,
				ClientHandle.FloaterBeginDefusing,
				ClientHandle.BatchedPackets,
				ClientHandle.NodeInit,
				ClientHandle.NodeFire,
				ClientHandle.HazeDamage,
				ClientHandle.EncryptionFireGun,
				ClientHandle.EncryptionNextPos,
				ClientHandle.EncryptionShieldRot,
				ClientHandle.SentinelInit,
				ClientHandle.AlertSosigs,
				ClientHandle.SetModulWeaponPart,
				ClientHandle.ShatterableCrateSetUsesLoot
			};
			synchronizedScenes = new Dictionary<string, int>();
			int sceneCountInBuildSettings = SceneManager.sceneCountInBuildSettings;
			for (int i = 0; i < sceneCountInBuildSettings; i++)
			{
				synchronizedScenes.Add(Path.GetFileNameWithoutExtension(SceneUtility.GetScenePathByBuildIndex(i)), 0);
			}
			objects = new TrackedObjectData[100];
			localObjectCounter = 0u;
			waitingLocalObjects.Clear();
			Mod.LogInfo("Initialized client", debug: false);
		}

		public static void AddTrackedObject(TrackedObjectData trackedObject)
		{
			Mod.LogInfo("Client adding new tracked object with waiting local index: " + trackedObject.localWaitingIndex + ", tracked ID: " + trackedObject.trackedID + ", and type ID: " + trackedObject.typeIdentifier, debug: false);
			TrackedObjectData value = null;
			if (trackedObject.trackedID == -2)
			{
				Mod.LogInfo("\tRejected", debug: false);
				value = waitingLocalObjects[trackedObject.localWaitingIndex];
				waitingLocalObjects.Remove(trackedObject.localWaitingIndex);
				if ((Object)(object)value.physical != (Object)null)
				{
					value.physical.skipDestroyProcessing = true;
					value.trackedID = -2;
					value.physical.sendDestroy = false;
					Object.Destroy((Object)(object)((Component)value.physical).gameObject);
				}
				return;
			}
			if (objects.Length <= trackedObject.trackedID)
			{
				IncreaseObjectsSize(trackedObject.trackedID);
			}
			if (trackedObject.controller == GameManager.ID)
			{
				Mod.LogInfo("\tController", debug: false);
				bool flag = true;
				if (waitingLocalObjects.TryGetValue(trackedObject.localWaitingIndex, out value) && trackedObject.initTracker == GameManager.ID)
				{
					waitingLocalObjects.Remove(trackedObject.localWaitingIndex);
					value.trackedID = trackedObject.trackedID;
					objects[value.trackedID] = value;
					Mod.LogInfo("\t\tSet in objects array, was local waiting", debug: false);
					if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObject.scene, out var value2))
					{
						if (value2.TryGetValue(trackedObject.instance, out var value3))
						{
							value3.Add(trackedObject.trackedID);
						}
						else
						{
							value2.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
						}
					}
					else
					{
						Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
						dictionary.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
						GameManager.objectsByInstanceByScene.Add(trackedObject.scene, dictionary);
					}
					value.OnTrackedIDReceived(trackedObject);
					flag = false;
				}
				if (!flag)
				{
					return;
				}
				TrackedObjectData trackedObjectData = objects[trackedObject.trackedID];
				if (trackedObjectData == null)
				{
					objects[trackedObject.trackedID] = trackedObject;
					Mod.LogInfo("\t\tSet in objects array, was not local waiting, didnt have data yet", debug: false);
					trackedObjectData = trackedObject;
					if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObject.scene, out var value4))
					{
						if (value4.TryGetValue(trackedObject.instance, out var value5))
						{
							value5.Add(trackedObject.trackedID);
						}
						else
						{
							value4.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
						}
					}
					else
					{
						Dictionary<int, List<int>> dictionary2 = new Dictionary<int, List<int>>();
						dictionary2.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
						GameManager.objectsByInstanceByScene.Add(trackedObject.scene, dictionary2);
					}
					trackedObject.localTrackedID = GameManager.objects.Count;
					GameManager.objects.Add(trackedObject);
				}
				else
				{
					Mod.LogInfo("\t\tAlready set in objects array", debug: false);
				}
				if ((Object)(object)trackedObjectData.physical == (Object)null && !trackedObjectData.awaitingInstantiation && !GameManager.sceneLoading && trackedObjectData.scene.Equals(GameManager.scene) && trackedObjectData.instance == GameManager.instance)
				{
					trackedObjectData.awaitingInstantiation = true;
					AnvilManager.Run(trackedObjectData.Instantiate());
				}
				return;
			}
			Mod.LogInfo("\tNot controller", debug: false);
			if (objects[trackedObject.trackedID] != null)
			{
				Mod.LogInfo("\t\tAlready set in objects array", debug: false);
				value = objects[trackedObject.trackedID];
				if ((Object)(object)value.physical == (Object)null && !value.awaitingInstantiation && value.scene.Equals(GameManager.scene) && value.instance == GameManager.instance)
				{
					value.awaitingInstantiation = true;
					AnvilManager.Run(value.Instantiate());
				}
				return;
			}
			trackedObject.localTrackedID = -1;
			objects[trackedObject.trackedID] = trackedObject;
			Mod.LogInfo("\t\tSet in objects array, didnt have data yet", debug: false);
			if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObject.scene, out var value6))
			{
				if (value6.TryGetValue(trackedObject.instance, out var value7))
				{
					value7.Add(trackedObject.trackedID);
				}
				else
				{
					value6.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
				}
			}
			else
			{
				Dictionary<int, List<int>> dictionary3 = new Dictionary<int, List<int>>();
				dictionary3.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
				GameManager.objectsByInstanceByScene.Add(trackedObject.scene, dictionary3);
			}
			if (trackedObject.parent != -1 && trackedObject.initTracker != GameManager.ID)
			{
				TrackedObjectData trackedObjectData2 = objects[trackedObject.parent];
				if (trackedObjectData2.children == null)
				{
					trackedObjectData2.children = new List<TrackedObjectData>();
				}
				trackedObject.childIndex = trackedObjectData2.children.Count;
				trackedObjectData2.children.Add(trackedObject);
			}
			if (!trackedObject.awaitingInstantiation && trackedObject.IsIdentifiable() && trackedObject.scene.Equals(GameManager.scene) && trackedObject.instance == GameManager.instance)
			{
				trackedObject.awaitingInstantiation = true;
				AnvilManager.Run(trackedObject.Instantiate());
			}
		}

		private static void IncreaseObjectsSize(int minimum)
		{
			int i;
			for (i = objects.Length; i <= minimum; i += 100)
			{
			}
			TrackedObjectData[] array = objects;
			objects = new TrackedObjectData[i];
			for (int j = 0; j < array.Length; j++)
			{
				objects[j] = array[j];
			}
		}

		private void OnApplicationQuit()
		{
			Disconnect(sendToServer: true, -1);
		}

		public void Disconnect(bool sendToServer, int code)
		{
			if (isConnected)
			{
				isConnected = false;
				bool flag = false;
				GameManager.reconnectionInstance = -1;
				switch (code)
				{
				case -1:
					Mod.LogWarning("Disconnecting from server due to application quit.");
					break;
				case 0:
					Mod.LogWarning("Disconnecting from server.");
					break;
				case 1:
					Mod.LogWarning("Connection to server lost, end of stream. Attempting to reconnect...");
					GameManager.reconnectionInstance = GameManager.instance;
					flag = true;
					break;
				case 2:
					Mod.LogWarning("Connection to server lost, TCP forced. Attempting to reconnect...");
					GameManager.reconnectionInstance = GameManager.instance;
					flag = true;
					break;
				case 3:
					Mod.LogWarning("Connection to server lost, UDP forced. Attempting to reconnect...");
					GameManager.reconnectionInstance = GameManager.instance;
					flag = true;
					break;
				case 4:
					Mod.LogWarning("Connection to server failed, timed out.");
					break;
				}
				if (sendToServer)
				{
					ClientSend.ClientDisconnect();
				}
				GameManager.TakeAllPhysicalControl(destroyTrackedScript: true);
				if (tcp.socket != null)
				{
					tcp.socket.Close();
				}
				tcp.socket = null;
				if (tcp.stream != null)
				{
					tcp.stream.Close();
				}
				tcp.stream = null;
				tcp.receiveBuffer = null;
				tcp.receivedData = null;
				if (udp.socket != null)
				{
					udp.socket.Close();
				}
				udp.socket = null;
				ID = -1;
				GameManager.Reset();
				SpecificDisconnect();
				if (Client.OnDisconnect != null)
				{
					Client.OnDisconnect();
				}
				Mod.Reset();
				isFullyConnected = false;
				if (flag)
				{
					Mod.OnConnectClicked(null);
				}
				tickTimer.Stop();
				tickTimer.Elapsed -= Tick;
			}
		}

		private void SpecificDisconnect()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.currentlyPlayingTNH)
			{
				Mod.currentlyPlayingTNH = false;
				Mod.currentTNHInstance.RemoveCurrentlyPlaying(send: true, GameManager.ID);
			}
			Mod.currentTNHInstance = null;
			Mod.TNHSpectating = false;
			if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
				if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
				{
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
				}
			}
			Mod.currentTNHInstancePlayers = null;
			Mod.joinTNHInstances = null;
			if ((Object)(object)Mod.TNHMenu != (Object)null)
			{
				Object.Destroy((Object)(object)Mod.TNHMenu);
				Mod.TNHMenu = null;
			}
		}
	}
	public class ClientHandle
	{
		public static void Welcome(Packet packet)
		{
			string text = packet.ReadString();
			int iD = packet.ReadInt();
			Client.singleton.SetTickRate(packet.ReadByte());
			GameManager.colorByIFF = packet.ReadBool();
			GameManager.nameplateMode = packet.ReadInt();
			GameManager.radarMode = packet.ReadInt();
			GameManager.radarColor = packet.ReadBool();
			int num = packet.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string key = packet.ReadString();
				int num2 = packet.ReadInt();
				Dictionary<int, KeyValuePair<float, int>> dictionary = new Dictionary<int, KeyValuePair<float, int>>();
				GameManager.maxHealthByInstanceByScene.Add(key, dictionary);
				for (int j = 0; j < num2; j++)
				{
					int key2 = packet.ReadInt();
					float key3 = packet.ReadFloat();
					int value = packet.ReadInt();
					dictionary.Add(key2, new KeyValuePair<float, int>(key3, value));
				}
			}
			int num3 = packet.ReadInt();
			for (int k = 0; k < num3; k++)
			{
				string text2 = packet.ReadString();
				int num4 = packet.ReadInt();
				Mod.registeredCustomPacketIDs.Add(text2, num4);
				Mod.CustomPacketHandlerReceivedInvoke(text2, num4);
			}
			H3MPWristMenuSection.UpdateMaxHealth(GameManager.scene, GameManager.instance, -2, -1f);
			Mod.LogInfo("Message from server: " + text, debug: false);
			Client.singleton.gotWelcome = true;
			Client.singleton.ID = iD;
			GameManager.ID = iD;
			ClientSend.WelcomeReceived();
			try
			{
				Client.singleton.udp.Connect(((IPEndPoint)Client.singleton.tcp.socket.Client.LocalEndPoint).Port);
			}
			catch (SocketException)
			{
				Mod.LogError("SocketException caught trying to make UDP connection to server, disconnecting. A game restart should be enough to fix this.");
				Client.singleton.Disconnect(sendToServer: true, 0);
				return;
			}
			if (GameManager.reconnectionInstance != -1)
			{
				GameManager.SetInstance(GameManager.reconnectionInstance);
				GameManager.reconnectionInstance = -1;
			}
			Mod.ForceDefaultPlayerBody();
		}

		public static void Ping(Packet packet)
		{
			GameManager.ping = Convert.ToInt64((DateTime.Now.ToUniversalTime() - ThreadManager.epoch).TotalMilliseconds) - packet.ReadLong();
		}

		public static void SpawnPlayer(Packet packet)
		{
			int iD = packet.ReadInt();
			string text = packet.ReadString();
			string scene = packet.ReadString();
			int instance = packet.ReadInt();
			int iFF = packet.ReadInt();
			int colorIndex = packet.ReadInt();
			bool flag = packet.ReadBool();
			Mod.LogInfo("ClientHandle SpawnPlayer, ID: " + iD + ", username: " + text, debug: false);
			GameManager.singleton.SpawnPlayer(iD, text, scene, instance, iFF, colorIndex, flag);
		}

		public static void ConnectSync(Packet packet)
		{
			Client.singleton.gotConnectSync = true;
			bool inControl = packet.ReadBool();
			if (!GameManager.nonSynchronizedScenes.ContainsKey(GameManager.scene))
			{
				GameManager.SyncTrackedObjects(init: true, inControl);
			}
		}

		public static void PlayerState(Packet packet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			int iD = packet.ReadInt();
			Vector3 position = packet.ReadVector3();
			Quaternion rotation = packet.ReadQuaternion();
			Vector3 headPos = packet.ReadVector3();
			Quaternion headRot = packet.ReadQuaternion();
			Vector3 torsoPos = packet.ReadVector3();
			Quaternion torsoRot = packet.ReadQuaternion();
			Vector3 leftHandPos = packet.ReadVector3();
			Quaternion leftHandRot = packet.ReadQuaternion();
			Vector3 rightHandPos = packet.ReadVector3();
			Quaternion rightHandRot = packet.ReadQuaternion();
			float health = packet.ReadFloat();
			int maxHealth = packet.ReadInt();
			short num = packet.ReadShort();
			byte[] additionalData = null;
			if (num > 0)
			{
				additionalData = packet.ReadBytes(num);
			}
			GameManager.UpdatePlayerState(iD, position, rotation, headPos, headRot, torsoPos, torsoRot, leftHandPos, leftHandRot, rightHandPos, rightHandRot, health, maxHealth, additionalData);
		}

		public static void PlayerIFF(Packet packet)
		{
			int key = packet.ReadInt();
			int iFF = packet.ReadInt();
			if (GameManager.players.ContainsKey(key))
			{
				GameManager.players[key].SetIFF(iFF);
			}
		}

		public static void PlayerScene(Packet packet)
		{
			int playerID = packet.ReadInt();
			string sceneName = packet.ReadString();
			GameManager.UpdatePlayerScene(playerID, sceneName);
		}

		public static void PlayerInstance(Packet packet)
		{
			int playerID = packet.ReadInt();
			int instance = packet.ReadInt();
			GameManager.UpdatePlayerInstance(playerID, instance);
		}

		public static void TrackedObjects(Packet packet)
		{
			TrackedObjectData.Update(packet);
		}

		public static void ObjectUpdate(Packet packet)
		{
			TrackedObjectData.Update(packet, includesLength: false);
		}

		public static void TrackedObject(Packet packet)
		{
			int num = packet.ReadInt();
			string text = packet.ReadString();
			Mod.LogInfo("Client received tracked object " + num + " with type: " + text, debug: false);
			if (Mod.trackedObjectTypesByName.TryGetValue(text, out var value))
			{
				Mod.LogInfo("\tGot type, adding", debug: false);
				Client.AddTrackedObject((TrackedObjectData)Activator.CreateInstance(value, packet, text, num));
			}
		}

		public static void GiveObjectControl(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			int num3 = packet.ReadInt();
			List<int> list = new List<int>();
			for (int i = 0; i < num3; i++)
			{
				list.Add(packet.ReadInt());
			}
			Mod.LogInfo("Client received GiveObjectControl for " + num + " to controller: " + num2, debug: false);
			if (Client.objects.Length <= num)
			{
				return;
			}
			TrackedObjectData trackedObjectData = Client.objects[num];
			if (trackedObjectData == null)
			{
				return;
			}
			Mod.LogInfo("\tGot object", debug: false);
			bool flag = false;
			if (trackedObjectData.controller == GameManager.ID && num2 != GameManager.ID)
			{
				Mod.LogInfo("\t\tWas controller, removing from local", debug: false);
				trackedObjectData.RemoveFromLocal();
			}
			else if (trackedObjectData.controller != GameManager.ID && num2 == GameManager.ID)
			{
				Mod.LogInfo("\t\tNew controller", debug: false);
				trackedObjectData.localTrackedID = GameManager.objects.Count;
				GameManager.objects.Add(trackedObjectData);
				if ((Object)(object)trackedObjectData.physical == (Object)null)
				{
					Mod.LogInfo("\t\t\tNo phys", debug: false);
					if (!GameManager.sceneLoading)
					{
						Mod.LogInfo("\t\t\t\tNot loading", debug: false);
						if (trackedObjectData.scene.Equals(GameManager.scene) && trackedObjectData.instance == GameManager.instance)
						{
							Mod.LogInfo("\t\t\t\t\tSame scene instance, instantiating", debug: false);
							if (!trackedObjectData.awaitingInstantiation)
							{
								trackedObjectData.awaitingInstantiation = true;
								AnvilManager.Run(trackedObjectData.Instantiate());
							}
						}
						else
						{
							Mod.LogInfo("\t\t\t\t\tDifferent scene instance, can't take control", debug: false);
							if (GameManager.playersByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value) && value.TryGetValue(trackedObjectData.instance, out var value2))
							{
								List<int> list2 = new List<int>(value2);
								for (int j = 0; j < list.Count; j++)
								{
									list2.Remove(list[j]);
								}
								num2 = Mod.GetBestPotentialObjectHost(trackedObjectData.controller, forUs: true, hasWhiteList: true, list2, trackedObjectData.scene, trackedObjectData.instance);
								if (num2 == -1)
								{
									Mod.LogInfo("\t\t\t\t\t\tNo one to bounce to, destroying", debug: false);
									ClientSend.DestroyObject(num);
									trackedObjectData.RemoveFromLocal();
									Client.objects[num] = null;
									if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value3) && value3.TryGetValue(trackedObjectData.instance, out var value4))
									{
										value4.Remove(trackedObjectData.trackedID);
									}
									trackedObjectData.awaitingInstantiation = false;
									flag = true;
								}
								else
								{
									Mod.LogInfo("\t\t\t\t\t\tBouncing to " + num2, debug: false);
									trackedObjectData.RemoveFromLocal();
									list.Add(GameManager.ID);
									ClientSend.GiveObjectControl(num, num2, list);
								}
							}
							else
							{
								Mod.LogInfo("\t\t\t\t\t\tNo one to bounce to, destroying", debug: false);
								ClientSend.DestroyObject(num);
								trackedObjectData.RemoveFromLocal();
								Client.objects[num] = null;
								if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value5) && value5.TryGetValue(trackedObjectData.instance, out var value6))
								{
									value6.Remove(trackedObjectData.trackedID);
								}
								trackedObjectData.awaitingInstantiation = false;
								flag = true;
							}
						}
					}
					else
					{
						Mod.LogInfo("\t\t\t\tLoading", debug: false);
						if (!trackedObjectData.scene.Equals(LoadLevelBeginPatch.loadingLevel) || trackedObjectData.instance != GameManager.instance)
						{
							Mod.LogInfo("\t\t\t\t\tDestination not same scene instance", debug: false);
							if (GameManager.playersByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value7) && value7.TryGetValue(trackedObjectData.instance, out var value8))
							{
								List<int> list3 = new List<int>(value8);
								for (int k = 0; k < list.Count; k++)
								{
									list3.Remove(list[k]);
								}
								num2 = Mod.GetBestPotentialObjectHost(trackedObjectData.controller, forUs: true, hasWhiteList: true, list3, trackedObjectData.scene, trackedObjectData.instance);
								if (num2 == -1)
								{
									Mod.LogInfo("\t\t\t\t\t\tNo one to bounce to, destroying", debug: false);
									ClientSend.DestroyObject(num);
									trackedObjectData.RemoveFromLocal();
									Client.objects[num] = null;
									if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value9) && value9.TryGetValue(trackedObjectData.instance, out var value10))
									{
										value10.Remove(trackedObjectData.trackedID);
									}
									trackedObjectData.awaitingInstantiation = false;
									flag = true;
								}
								else
								{
									Mod.LogInfo("\t\t\t\t\t\tBouncing to " + num2, debug: false);
									trackedObjectData.RemoveFromLocal();
									list.Add(GameManager.ID);
									ClientSend.GiveObjectControl(num, num2, list);
								}
							}
							else
							{
								Mod.LogInfo("\t\t\t\t\t\tNo one to bounce to, destroying", debug: false);
								ClientSend.DestroyObject(num);
								trackedObjectData.RemoveFromLocal();
								Client.objects[num] = null;
								if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value11) && value11.TryGetValue(trackedObjectData.instance, out var value12))
								{
									value12.Remove(trackedObjectData.trackedID);
								}
								trackedObjectData.awaitingInstantiation = false;
								flag = true;
							}
						}
					}
				}
			}
			if (!flag)
			{
				trackedObjectData.SetController(num2);
			}
		}

		public static void DestroyObject(Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Client.objects.Length <= num)
			{
				return;
			}
			TrackedObjectData trackedObjectData = Client.objects[num];
			Mod.LogInfo("Client received object destruction for tracked ID: " + num + ", remove from lists: " + flag, debug: false);
			if (trackedObjectData == null)
			{
				return;
			}
			Mod.LogInfo("\tGot object", debug: false);
			trackedObjectData.awaitingInstantiation = false;
			bool flag2 = false;
			if ((Object)(object)trackedObjectData.physical != (Object)null)
			{
				Mod.LogInfo("\t\tGot phys, destroying", debug: false);
				trackedObjectData.removeFromListOnDestroy = flag;
				trackedObjectData.physical.sendDestroy = false;
				trackedObjectData.physical.dontGiveControl = true;
				TrackedObject[] componentsInChildren = ((Component)trackedObjectData.physical).GetComponentsInChildren<TrackedObject>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] != (Object)null)
					{
						componentsInChildren[i].sendDestroy = false;
						componentsInChildren[i].data.removeFromListOnDestroy = flag;
						componentsInChildren[i].dontGiveControl = true;
					}
				}
				trackedObjectData.physical.SecondaryDestroy();
				Object.Destroy((Object)(object)((Component)trackedObjectData.physical).gameObject);
				flag2 = true;
			}
			if (!flag2 && trackedObjectData.localTrackedID != -1)
			{
				Mod.LogInfo("\t\tNo phys, is local, removing from local", debug: false);
				trackedObjectData.RemoveFromLocal();
			}
			if (flag && !flag2)
			{
				Mod.LogInfo("\t\tNo phys, removing from lists", debug: false);
				trackedObjectData.RemoveFromLists();
			}
		}

		public static void ObjectParent(Packet packet)
		{
			int num = packet.ReadInt();
			int parent = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] != null)
			{
				Client.objects[num].SetParent(parent);
			}
		}

		public static void WeaponFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass roundClass = (FireArmRoundClass)packet.ReadShort();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				int chamberIndex = packet.ReadInt();
				Mod.skipNextFires++;
				trackedItemData.physicalItem.setFirearmUpdateOverride(roundType, roundClass, chamberIndex);
				ProjectileFirePatch.skipBlast++;
				trackedItemData.physicalItem.fireFunc(chamberIndex);
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void FlintlockWeaponBurnOffOuter(Packet packet)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				Object dataObject = trackedItemData.physicalItem.dataObject;
				FlintlockBarrel val = (FlintlockBarrel)(object)((dataObject is FlintlockBarrel) ? dataObject : null);
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				FlintlockWeapon val2 = (FlintlockWeapon)(object)((physicalItem is FlintlockWeapon) ? physicalItem : null);
				int num2 = packet.ReadByte();
				val.LoadedElements = new List<LoadedElement>();
				for (int i = 0; i < num2; i++)
				{
					LoadedElement val3 = new LoadedElement();
					val3.Type = (LoadedElementType)packet.ReadByte();
					val3.Position = packet.ReadFloat();
				}
				val.LoadedElements[val.LoadedElements.Count - 1].PowderAmount = packet.ReadInt();
				if (packet.ReadBool() && (Object)(object)val2.RamRod.GetCurBarrel() != (Object)(object)val)
				{
					val2.RamRod.m_curBarrel = val;
				}
				FireFlintlockWeaponPatch.num2 = packet.ReadFloat();
				FireFlintlockWeaponPatch.positions = new List<Vector3>();
				FireFlintlockWeaponPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int j = 0; j < b; j++)
				{
					FireFlintlockWeaponPatch.positions.Add(packet.ReadVector3());
					FireFlintlockWeaponPatch.directions.Add(packet.ReadVector3());
				}
				FireFlintlockWeaponPatch.overriden = true;
				FireFlintlockWeaponPatch.burnSkip++;
				val.BurnOffOuter();
				FireFlintlockWeaponPatch.burnSkip--;
			}
		}

		public static void FlintlockWeaponFire(Packet packet)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				Object dataObject = trackedItemData.physicalItem.dataObject;
				FlintlockBarrel val = (FlintlockBarrel)(object)((dataObject is FlintlockBarrel) ? dataObject : null);
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				FlintlockWeapon val2 = (FlintlockWeapon)(object)((physicalItem is FlintlockWeapon) ? physicalItem : null);
				int num2 = packet.ReadByte();
				val.LoadedElements = new List<LoadedElement>();
				for (int i = 0; i < num2; i++)
				{
					LoadedElement val3 = new LoadedElement();
					val3.Type = (LoadedElementType)packet.ReadByte();
					val3.Position = packet.ReadFloat();
					val3.PowderAmount = packet.ReadInt();
				}
				if (packet.ReadBool() && (Object)(object)val2.RamRod.GetCurBarrel() != (Object)(object)val)
				{
					val2.RamRod.m_curBarrel = val;
				}
				FireFlintlockWeaponPatch.num5 = packet.ReadFloat();
				FireFlintlockWeaponPatch.positions = new List<Vector3>();
				FireFlintlockWeaponPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int j = 0; j < b; j++)
				{
					FireFlintlockWeaponPatch.positions.Add(packet.ReadVector3());
					FireFlintlockWeaponPatch.directions.Add(packet.ReadVector3());
				}
				FireFlintlockWeaponPatch.overriden = true;
				FireFlintlockWeaponPatch.fireSkip++;
				val.Fire();
				FireFlintlockWeaponPatch.fireSkip--;
			}
		}

		public static void BreakActionWeaponFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				BreakActionWeapon val2 = (BreakActionWeapon)(object)((physicalItem is BreakActionWeapon) ? physicalItem : null);
				if ((Object)(object)val2 != (Object)null)
				{
					FireArmRoundType roundType2 = val2.Barrels[num2].Chamber.RoundType;
					val2.Barrels[num2].Chamber.RoundType = roundType;
					ChamberPatch.chamberSkip++;
					val2.Barrels[num2].Chamber.SetRound(val, ((Component)val2.Barrels[num2].Chamber).transform.position, ((Component)val2.Barrels[num2].Chamber).transform.rotation);
					ChamberPatch.chamberSkip--;
					val2.Barrels[num2].Chamber.RoundType = roundType2;
					ProjectileFirePatch.skipBlast++;
					val2.Fire(num2, false, 0);
					ProjectileFirePatch.skipBlast--;
				}
				else
				{
					Mod.LogError("Received order to fire break action weapon at " + num + " but the item is not a BreakActionWeapon. It is actually: " + ((object)trackedItemData.physicalItem.physicalItem).GetType());
				}
			}
		}

		public static void DerringerFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				Derringer val2 = (Derringer)(object)((physicalItem is Derringer) ? physicalItem : null);
				FireArmRoundType roundType2 = val2.Barrels[num2].Chamber.RoundType;
				val2.Barrels[num2].Chamber.RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Barrels[num2].Chamber.SetRound(val, ((Component)val2.Barrels[num2].Chamber).transform.position, ((Component)val2.Barrels[num2].Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Barrels[num2].Chamber.RoundType = roundType2;
				val2.m_curBarrel = num2;
				ProjectileFirePatch.skipBlast++;
				val2.FireBarrel(num2);
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void RevolvingShotgunFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				RevolvingShotgun val2 = (RevolvingShotgun)(object)((physicalItem is RevolvingShotgun) ? physicalItem : null);
				val2.CurChamber = num2;
				FireArmRoundType roundType2 = val2.Chambers[num2].RoundType;
				val2.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[num2].SetRound(val, ((Component)val2.Chambers[num2]).transform.position, ((Component)val2.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[num2].RoundType = roundType2;
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void RevolverFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				Revolver val2 = (Revolver)(object)((physicalItem is Revolver) ? physicalItem : null);
				bool flag = false;
				int chamberOffset = 0;
				if (val2.ChamberOffset != 0)
				{
					flag = true;
					chamberOffset = val2.ChamberOffset;
					val2.ChamberOffset = 0;
				}
				val2.CurChamber = num2;
				FireArmRoundType roundType2 = val2.Chambers[num2].RoundType;
				val2.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[num2].SetRound(val, ((Component)val2.Chambers[num2]).transform.position, ((Component)val2.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[num2].RoundType = roundType2;
				if (flag)
				{
					val2.ChamberOffset = chamberOffset;
				}
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void SingleActionRevolverFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				SingleActionRevolver val2 = (SingleActionRevolver)(object)((physicalItem is SingleActionRevolver) ? physicalItem : null);
				val2.CurChamber = num2;
				FireArmRoundType roundType2 = val2.Cylinder.Chambers[num2].RoundType;
				val2.Cylinder.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Cylinder.Chambers[num2].SetRound(val, ((Component)val2.Cylinder.Chambers[num2]).transform.position, ((Component)val2.Cylinder.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Cylinder.Chambers[num2].RoundType = roundType2;
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void StingerLauncherFire(Packet packet)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireStingerLauncherPatch.targetPos = packet.ReadVector3();
				FireStingerLauncherPatch.position = packet.ReadVector3();
				FireStingerLauncherPatch.rotation = packet.ReadQuaternion();
				FireStingerLauncherPatch.overriden = true;
				FireStingerLauncherPatch.skip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				StingerLauncher val = (StingerLauncher)(object)((physicalItem is StingerLauncher) ? physicalItem : null);
				val.m_hasMissile = true;
				ProjectileFirePatch.skipBlast++;
				val.Fire();
				ProjectileFirePatch.skipBlast--;
				FireStingerLauncherPatch.skip--;
			}
		}

		public static void GrappleGunFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				GrappleGun val2 = (GrappleGun)(object)((physicalItem is GrappleGun) ? physicalItem : null);
				val2.m_curChamber = num2;
				FireArmRoundType roundType2 = val2.Chambers[num2].RoundType;
				val2.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[num2].SetRound(val, ((Component)val2.Chambers[num2]).transform.position, ((Component)val2.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[num2].RoundType = roundType2;
				val2.Fire();
			}
		}

		public static void HCBReleaseSled(Packet packet)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				float cookedAmount = packet.ReadFloat();
				FireHCBPatch.position = packet.ReadVector3();
				FireHCBPatch.direction = packet.ReadVector3();
				FireHCBPatch.overriden = true;
				FireHCBPatch.releaseSledSkip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				HCB val = (HCB)(object)((physicalItem is HCB) ? physicalItem : null);
				val.m_cookedAmount = cookedAmount;
				if (!val.Chamber.IsFull)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FireArmRoundClass)1, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
					ChamberPatch.chamberSkip--;
				}
				val.ReleaseSled();
				FireHCBPatch.releaseSledSkip--;
			}
		}

		public static void LeverActionFirearmFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData) || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
			FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
			bool flag = packet.ReadBool();
			FirePatch.positions = new List<Vector3>();
			FirePatch.directions = new List<Vector3>();
			byte b = packet.ReadByte();
			for (int i = 0; i < b; i++)
			{
				FirePatch.positions.Add(packet.ReadVector3());
				FirePatch.directions.Add(packet.ReadVector3());
			}
			FirePatch.overriden = true;
			Mod.skipNextFires++;
			Object dataObject = trackedItemData.physicalItem.dataObject;
			LeverActionFirearm val2 = (LeverActionFirearm)(object)((dataObject is LeverActionFirearm) ? dataObject : null);
			if (flag)
			{
				FireArmRoundType roundType2 = val2.Chamber.RoundType;
				val2.Chamber.RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chamber.SetRound(val, ((Component)val2.Chamber).transform.position, ((Component)val2.Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chamber.RoundType = roundType2;
				val2.m_isHammerCocked = true;
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
				return;
			}
			bool flag2 = false;
			if (val2.IsHammerCocked)
			{
				flag2 = true;
				val2.m_isHammerCocked = false;
			}
			bool flag3 = false;
			FireArmRoundClass val3 = (FireArmRoundClass)185;
			if ((Object)(object)val2.Chamber.GetRound() != (Object)null)
			{
				flag3 = true;
				val3 = val2.Chamber.GetRound().RoundClass;
				ChamberPatch.chamberSkip++;
				val2.Chamber.SetRound((FVRFireArmRound)null, false);
				ChamberPatch.chamberSkip--;
			}
			FireArmRoundType roundType3 = val2.Chamber.RoundType;
			val2.Chamber2.RoundType = roundType;
			ChamberPatch.chamberSkip++;
			val2.Chamber2.SetRound(val, ((Component)val2.Chamber2).transform.position, ((Component)val2.Chamber2).transform.rotation);
			ChamberPatch.chamberSkip--;
			val2.Chamber2.RoundType = roundType3;
			val2.m_isHammerCocked2 = true;
			ProjectileFirePatch.skipBlast++;
			val2.Fire();
			ProjectileFirePatch.skipBlast--;
			if (flag2)
			{
				val2.m_isHammerCocked = true;
			}
			if (flag3)
			{
				ChamberPatch.chamberSkip++;
				val2.Chamber.SetRound(val3, ((Component)val2.Chamber).transform.position, ((Component)val2.Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
			}
		}

		public static void SosigWeaponFire(Packet packet)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			float recoilMult = packet.ReadFloat();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireSosigWeaponPatch.positions = new List<Vector3>();
				FireSosigWeaponPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireSosigWeaponPatch.positions.Add(packet.ReadVector3());
					FireSosigWeaponPatch.directions.Add(packet.ReadVector3());
				}
				FireSosigWeaponPatch.overriden = true;
				Mod.skipNextFires++;
				Object dataObject = trackedItemData.physicalItem.dataObject;
				SosigWeaponPlayerInterface val = (SosigWeaponPlayerInterface)(object)((dataObject is SosigWeaponPlayerInterface) ? dataObject : null);
				if (val.W.m_shotsLeft <= 0)
				{
					val.W.m_shotsLeft = 1;
				}
				val.W.MechaState = (SosigWeaponMechaState)0;
				trackedItemData.physicalItem.sosigWeaponfireFunc(recoilMult);
			}
		}

		public static void LAPD2019Fire(Packet packet)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				int curChamber = packet.ReadInt();
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				FireLAPD2019Patch.positions = new List<Vector3>();
				FireLAPD2019Patch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireLAPD2019Patch.positions.Add(packet.ReadVector3());
					FireLAPD2019Patch.directions.Add(packet.ReadVector3());
				}
				FireLAPD2019Patch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				LAPD2019 val2 = (LAPD2019)(object)((physicalItem is LAPD2019) ? physicalItem : null);
				val2.CurChamber = curChamber;
				FireArmRoundType roundType2 = val2.Chambers[val2.CurChamber].RoundType;
				val2.Chambers[val2.CurChamber].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[val2.CurChamber].SetRound(val, ((Component)val2.Chambers[val2.CurChamber]).transform.position, ((Component)val2.Chambers[val2.CurChamber]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[val2.CurChamber].RoundType = roundType2;
				ProjectileFirePatch.skipBlast++;
				((LAPD2019)trackedItemData.physicalItem.physicalItem).Fire();
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void AttachableFirearmFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass roundClass = (FireArmRoundClass)packet.ReadShort();
				bool firedFromInterface = packet.ReadBool();
				FireAttachableFirearmPatch.positions = new List<Vector3>();
				FireAttachableFirearmPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireAttachableFirearmPatch.positions.Add(packet.ReadVector3());
					FireAttachableFirearmPatch.directions.Add(packet.ReadVector3());
				}
				FireAttachableFirearmPatch.overriden = true;
				Mod.skipNextFires++;
				trackedItemData.physicalItem.attachableFirearmChamberRoundFunc(roundType, roundClass);
				ProjectileFirePatch.skipBlast++;
				trackedItemData.physicalItem.attachableFirearmFireFunc(firedFromInterface);
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void IntegratedFirearmFire(Packet packet)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass roundClass = (FireArmRoundClass)packet.ReadShort();
				FireAttachableFirearmPatch.positions = new List<Vector3>();
				FireAttachableFirearmPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireAttachableFirearmPatch.positions.Add(packet.ReadVector3());
					FireAttachableFirearmPatch.directions.Add(packet.ReadVector3());
				}
				FireAttachableFirearmPatch.overriden = true;
				Mod.skipNextFires++;
				trackedItemData.physicalItem.attachableFirearmChamberRoundFunc(roundType, roundClass);
				ProjectileFirePatch.skipBlast++;
				trackedItemData.physicalItem.attachableFirearmFireFunc(firedFromInterface: false);
				ProjectileFirePatch.skipBlast--;
			}
		}

		public static void LAPD2019LoadBattery(Packet packet)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				int num2 = packet.ReadInt();
				if (Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null && (Object)(object)Client.objects[num2].physical != (Object)null)
				{
					LAPD2019ActionPatch.loadBatterySkip++;
					((LAPD2019)trackedItemData.physicalItem.physicalItem).LoadBattery((LAPD2019Battery)Client.objects[num2].physical.physical);
					LAPD2019ActionPatch.loadBatterySkip--;
				}
			}
		}

		public static void LAPD2019ExtractBattery(Packet packet)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				LAPD2019ActionPatch.extractBatterySkip++;
				((LAPD2019)trackedItemData.physicalItem.physicalItem).ExtractBattery((FVRViveHand)null);
				LAPD2019ActionPatch.extractBatterySkip--;
			}
		}

		public static void SosigWeaponShatter(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				SosigWeaponShatterPatch.skip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((SosigWeaponPlayerInterface)((physicalItem is SosigWeaponPlayerInterface) ? physicalItem : null)).W.Shatter();
				SosigWeaponShatterPatch.skip--;
			}
		}

		public static void AutoMeaterFirearmFireShot(Packet packet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			Vector3 muzzleAngles = packet.ReadVector3();
			if (Client.objects.Length > num && Client.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData && (Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
			{
				AutoMeaterFirearmFireShotPatch.muzzleAngles = muzzleAngles;
				AutoMeaterFirearmFireShotPatch.angleOverride = true;
				AutoMeaterFirearmFireShotPatch.skip++;
				trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.FireControl.Firearms[0].FireShot();
				AutoMeaterFirearmFireShotPatch.skip--;
			}
		}

		public static void PlayerDamage(Packet packet)
		{
			float damageMult = packet.ReadFloat();
			bool head = packet.ReadBool();
			Damage damage = packet.ReadDamage();
			Mod.LogInfo("Client received player damage for itself", debug: false);
			GameManager.ProcessPlayerDamage(damageMult, head, damage);
		}

		public static void UberShatterableShatter(Packet packet)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				TrackedObjectData trackedObjectData = Client.objects[num];
				if (trackedObjectData != null && (Object)(object)trackedObjectData.physical != (Object)null)
				{
					trackedObjectData.physical.HandleShatter(null, packet.ReadVector3(), packet.ReadVector3(), packet.ReadFloat(), received: true, 0, packet.ReadBytes(packet.ReadInt()));
				}
			}
		}

		public static void SosigPickUpItem(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Client.objects.Length <= num || Client.objects.Length <= num2)
			{
				return;
			}
			bool flag = packet.ReadBool();
			if (!(Client.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			trackedSosigData.inventory[(!flag) ? 1u : 0u] = num2;
			if (!((Object)(object)trackedSosigData.physicalSosig != (Object)null))
			{
				return;
			}
			if (Client.objects[num2] == null)
			{
				Mod.LogError("SosigPickUpItem: item at " + num2 + " is missing item data!");
				return;
			}
			if ((Object)(object)Client.objects[num2].physical == (Object)null)
			{
				(Client.objects[num2] as TrackedItemData).toPutInSosigInventory = new int[2]
				{
					num,
					(!flag) ? 1 : 0
				};
				return;
			}
			SosigPickUpPatch.skip++;
			if (flag)
			{
				trackedSosigData.physicalSosig.physicalSosig.Hand_Primary.PickUp(((Component)Client.objects[num2].physical).GetComponent<SosigWeapon>());
			}
			else
			{
				trackedSosigData.physicalSosig.physicalSosig.Hand_Secondary.PickUp(((Component)Client.objects[num2].physical).GetComponent<SosigWeapon>());
			}
			SosigPickUpPatch.skip--;
		}

		public static void SosigPlaceItemIn(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Client.objects.Length <= num || Client.objects.Length <= num2)
			{
				return;
			}
			int num3 = packet.ReadInt();
			if (!(Client.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			trackedSosigData.inventory[num3 + 2] = num2;
			if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				if (Client.objects[num2] == null)
				{
					Mod.LogError("SosigPickUpItem: item at " + num2 + " is missing item data!");
				}
				else if ((Object)(object)Client.objects[num2].physical == (Object)null)
				{
					(Client.objects[num2] as TrackedItemData).toPutInSosigInventory = new int[2]
					{
						num,
						num3 + 2
					};
				}
				else
				{
					SosigPlaceObjectInPatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.Inventory.Slots[num3].PlaceObjectIn(((Component)Client.objects[num2].physical).GetComponent<SosigWeapon>());
					SosigPlaceObjectInPatch.skip--;
				}
			}
		}

		public static void SosigDropSlot(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int num2 = packet.ReadInt();
			if (Client.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.inventory[num2 + 2] = -1;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigSlotDetachPatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.Inventory.Slots[num2].DetachHeldObject();
					SosigSlotDetachPatch.skip--;
				}
			}
		}

		public static void SosigHandDrop(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			bool flag = packet.ReadBool();
			if (!(Client.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			trackedSosigData.inventory[(!flag) ? 1u : 0u] = -1;
			if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				SosigHandDropPatch.skip++;
				if (flag)
				{
					trackedSosigData.physicalSosig.physicalSosig.Hand_Primary.DropHeldObject();
				}
				else
				{
					trackedSosigData.physicalSosig.physicalSosig.Hand_Secondary.DropHeldObject();
				}
				SosigHandDropPatch.skip--;
			}
		}

		public static void SosigConfigure(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			SosigConfigTemplate val = packet.ReadSosigConfig();
			if (Client.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.configTemplate = val;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigConfigurePatch.skipConfigure = true;
					trackedSosigData.physicalSosig.physicalSosig.Configure(val);
				}
			}
		}

		public static void SosigLinkRegisterWearable(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			byte b = packet.ReadByte();
			string text = packet.ReadString();
			if (!(Client.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			if (trackedSosigData.wearables == null)
			{
				trackedSosigData.wearables = new List<List<string>>();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					foreach (SosigLink link in trackedSosigData.physicalSosig.physicalSosig.Links)
					{
						trackedSosigData.wearables.Add(new List<string>());
					}
				}
				else
				{
					while (trackedSosigData.wearables.Count <= b)
					{
						trackedSosigData.wearables.Add(new List<string>());
					}
				}
			}
			trackedSosigData.wearables[b].Add(text);
			if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				AnvilManager.Run(trackedSosigData.EquipWearable(b, text, skip: true));
			}
		}

		public static void SosigLinkDeRegisterWearable(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			byte index = packet.ReadByte();
			string text = packet.ReadString();
			if (!(Client.objects[num] is TrackedSosigData { wearables: not null } trackedSosigData))
			{
				return;
			}
			if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				for (int i = 0; i < trackedSosigData.wearables[index].Count; i++)
				{
					if (trackedSosigData.wearables[index][i].Equals(text))
					{
						trackedSosigData.wearables[index].RemoveAt(i);
						if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
						{
							SosigLinkActionPatch.skipDeRegisterWearable++;
							trackedSosigData.physicalSosig.physicalSosig.Links[index].DeRegisterWearable(trackedSosigData.physicalSosig.physicalSosig.Links[index].m_wearables[i]);
							SosigLinkActionPatch.skipDeRegisterWearable--;
						}
						break;
					}
				}
			}
			else
			{
				trackedSosigData.wearables[index].Remove(text);
			}
		}

		public static void SosigSetIFF(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			byte iFF = packet.ReadByte();
			if (Client.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.IFF = iFF;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigIFFPatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.SetIFF((int)iFF);
					SosigIFFPatch.skip--;
				}
			}
		}

		public static void SosigSetOriginalIFF(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			byte b = packet.ReadByte();
			if (Client.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.IFF = b;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigIFFPatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.SetOriginalIFFTeam((int)b);
					SosigIFFPatch.skip--;
				}
			}
		}

		public static void SosigLinkDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				byte index = packet.ReadByte();
				Damage val = packet.ReadDamage();
				if (Client.objects[num] is TrackedSosigData trackedSosigData)
				{
					if (trackedSosigData.controller == Client.singleton.ID)
					{
						if ((Object)(object)trackedSosigData.physicalSosig != (Object)null && (Object)(object)trackedSosigData.physicalSosig.physicalSosig.Links[index] != (Object)null && !trackedSosigData.physicalSosig.physicalSosig.Links[index].IsExploded)
						{
							SosigLinkDamagePatch.skip++;
							trackedSosigData.physicalSosig.physicalSosig.Links[index].Damage(val);
							SosigLinkDamagePatch.skip--;
						}
					}
					else
					{
						ClientSend.SosigLinkDamage(packet);
					}
				}
				else
				{
					ClientSend.SosigLinkDamage(packet);
				}
			}
			else
			{
				ClientSend.SosigLinkDamage(packet);
			}
		}

		public static void AutoMeaterDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				Damage val = packet.ReadDamage();
				if (Client.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData)
				{
					if (trackedAutoMeaterData.controller == Client.singleton.ID)
					{
						if ((Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
						{
							AutoMeaterDamagePatch.skip++;
							trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Damage(val);
							AutoMeaterDamagePatch.skip--;
						}
					}
					else
					{
						ClientSend.AutoMeaterDamage(packet);
					}
				}
				else
				{
					ClientSend.AutoMeaterDamage(packet);
				}
			}
			else
			{
				ClientSend.AutoMeaterDamage(packet);
			}
		}

		public static void AutoMeaterHitZoneDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				byte b = packet.ReadByte();
				Damage val = packet.ReadDamage();
				if (Client.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData)
				{
					if (trackedAutoMeaterData.controller == Client.singleton.ID)
					{
						if ((Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
						{
							AutoMeaterHitZoneDamagePatch.skip++;
							trackedAutoMeaterData.hitZones[(AMHitZoneType)b].Damage(val);
							AutoMeaterHitZoneDamagePatch.skip--;
						}
					}
					else
					{
						ClientSend.AutoMeaterHitZoneDamage(packet);
					}
				}
				else
				{
					ClientSend.AutoMeaterHitZoneDamage(packet);
				}
			}
			else
			{
				ClientSend.AutoMeaterHitZoneDamage(packet);
			}
		}

		public static void EncryptionDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				Damage val = packet.ReadDamage();
				if (Client.objects[num] is TrackedEncryptionData trackedEncryptionData)
				{
					if (trackedEncryptionData.controller == Client.singleton.ID)
					{
						if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
						{
							EncryptionDamagePatch.skip++;
							trackedEncryptionData.physicalEncryption.physicalEncryption.Damage(val);
							EncryptionDamagePatch.skip--;
						}
					}
					else
					{
						ClientSend.EncryptionDamage(packet);
					}
				}
				else
				{
					ClientSend.EncryptionDamage(packet);
				}
			}
			else
			{
				ClientSend.EncryptionDamage(packet);
			}
		}

		public static void EncryptionSubDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				int index = packet.ReadInt();
				Damage val = packet.ReadDamage();
				if (Client.objects[num] is TrackedEncryptionData trackedEncryptionData && trackedEncryptionData.controller == GameManager.ID && (Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					EncryptionSubDamagePatch.skip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[index].GetComponent<TNH_EncryptionTarget_SubTarget>().Damage(val);
					EncryptionSubDamagePatch.skip--;
				}
			}
		}

		public static void SosigWeaponDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				Damage val = packet.ReadDamage();
				if (Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					SosigWeaponDamagePatch.skip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((SosigWeaponPlayerInterface)((physicalItem is SosigWeaponPlayerInterface) ? physicalItem : null)).W.Damage(val);
					SosigWeaponDamagePatch.skip--;
				}
			}
		}

		public static void RemoteMissileDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				RemoteMissile missile = ((RemoteMissileLauncher)((physicalItem is RemoteMissileLauncher) ? physicalItem : null)).m_missile;
				if ((Object)(object)missile != (Object)null)
				{
					RemoteMissileDamagePatch.skip++;
					missile.Damage(packet.ReadDamage());
					RemoteMissileDamagePatch.skip--;
				}
			}
		}

		public static void StingerMissileDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				StingerMissile stingerMissile = trackedItemData.physicalItem.stingerMissile;
				if ((Object)(object)stingerMissile != (Object)null)
				{
					StingerMissileDamagePatch.skip++;
					stingerMissile.Damage(packet.ReadDamage());
					StingerMissileDamagePatch.skip--;
				}
			}
		}

		public static void SosigWearableDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				if (Client.objects[num] is TrackedSosigData trackedSosigData)
				{
					byte index = packet.ReadByte();
					byte index2 = packet.ReadByte();
					Damage val = packet.ReadDamage();
					if (trackedSosigData.controller == Client.singleton.ID)
					{
						if ((Object)(object)trackedSosigData.physicalSosig != (Object)null && (Object)(object)trackedSosigData.physicalSosig.physicalSosig.Links[index] != (Object)null && !trackedSosigData.physicalSosig.physicalSosig.Links[index].IsExploded)
						{
							SosigWearableDamagePatch.skip++;
							trackedSosigData.physicalSosig.physicalSosig.Links[index].m_wearables[index2].Damage(val);
							SosigWearableDamagePatch.skip--;
						}
					}
					else
					{
						ClientSend.SosigWearableDamage(packet);
					}
				}
				else
				{
					ClientSend.SosigWearableDamage(packet);
				}
			}
			else
			{
				ClientSend.SosigWearableDamage(packet);
			}
		}

		public static void SosigSetBodyState(Packet packet)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				SosigBodyState bodyState = (SosigBodyState)packet.ReadByte();
				if (Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetBodyStateSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetBodyState(bodyState);
					SosigPatch.sosigSetBodyStateSkip--;
				}
			}
		}

		public static void SosigDamageData(Packet packet)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedSosigData trackedSosigData) || trackedSosigData.controller == Client.singleton.ID || !((Object)(object)trackedSosigData.physicalSosig != (Object)null))
			{
				return;
			}
			Sosig physicalSosig = trackedSosigData.physicalSosig.physicalSosig;
			physicalSosig.m_isStunned = packet.ReadBool();
			physicalSosig.m_stunTimeLeft = packet.ReadFloat();
			physicalSosig.BodyState = (SosigBodyState)packet.ReadByte();
			physicalSosig.m_isOnOffMeshLink = packet.ReadBool();
			physicalSosig.Agent.autoTraverseOffMeshLink = packet.ReadBool();
			((Behaviour)physicalSosig.Agent).enabled = packet.ReadBool();
			List<CharacterJoint> joints = physicalSosig.m_joints;
			byte b = packet.ReadByte();
			for (int i = 0; i < joints.Count; i++)
			{
				if ((Object)(object)joints[i] != (Object)null)
				{
					SoftJointLimit val = joints[i].lowTwistLimit;
					((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
					joints[i].lowTwistLimit = val;
					val = joints[i].highTwistLimit;
					((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
					joints[i].highTwistLimit = val;
					val = joints[i].swing1Limit;
					((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
					joints[i].swing1Limit = val;
					val = joints[i].swing2Limit;
					((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
					joints[i].swing2Limit = val;
				}
			}
			physicalSosig.m_isCountingDownToStagger = packet.ReadBool();
			physicalSosig.m_staggerAmountToApply = packet.ReadFloat();
			physicalSosig.m_recoveringFromBallisticState = packet.ReadBool();
			physicalSosig.m_recoveryFromBallisticLerp = packet.ReadFloat();
			physicalSosig.m_tickDownToWrithe = packet.ReadFloat();
			physicalSosig.m_recoveryFromBallisticTick = packet.ReadFloat();
			physicalSosig.m_lastIFFDamageSource = packet.ReadByte();
			physicalSosig.m_diedFromClass = (DamageClass)packet.ReadByte();
			physicalSosig.m_isBlinded = packet.ReadBool();
			physicalSosig.m_blindTime = packet.ReadFloat();
			physicalSosig.m_isFrozen = packet.ReadBool();
			physicalSosig.m_debuffTime_Freeze = packet.ReadFloat();
			physicalSosig.m_receivedHeadShot = packet.ReadBool();
			physicalSosig.m_timeSinceLastDamage = packet.ReadFloat();
			physicalSosig.m_isConfused = packet.ReadBool();
			physicalSosig.m_confusedTime = packet.ReadFloat();
			physicalSosig.m_storedShudder = packet.ReadFloat();
		}

		public static void EncryptionDamageData(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedEncryptionData trackedEncryptionData && trackedEncryptionData.controller != Client.singleton.ID && (Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				trackedEncryptionData.physicalEncryption.physicalEncryption.m_numHitsLeft = packet.ReadInt();
			}
		}

		public static void AutoMeaterHitZoneDamageData(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData && trackedAutoMeaterData.controller != Client.singleton.ID && (Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
			{
				AutoMeaterHitZone val = trackedAutoMeaterData.hitZones[(AMHitZoneType)packet.ReadByte()];
				val.ArmorThreshold = packet.ReadFloat();
				val.LifeUntilFailure = packet.ReadFloat();
				if (packet.ReadBool())
				{
					val.BlowUp();
				}
			}
		}

		public static void SosigLinkExplodes(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				byte index = packet.ReadByte();
				SosigLinkActionPatch.skipLinkExplodes++;
				trackedSosigData.physicalSosig.physicalSosig.Links[index].LinkExplodes((DamageClass)packet.ReadByte());
				SosigLinkActionPatch.skipLinkExplodes--;
			}
		}

		public static void SosigDies(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				byte b = packet.ReadByte();
				byte b2 = packet.ReadByte();
				SosigPatch.sosigDiesSkip++;
				trackedSosigData.physicalSosig.physicalSosig.SosigDies((DamageClass)b, (SosigDeathType)b2);
				SosigPatch.sosigDiesSkip--;
			}
		}

		public static void SosigClear(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				SosigPatch.sosigClearSkip++;
				trackedSosigData.physicalSosig.physicalSosig.ClearSosig();
				SosigPatch.sosigClearSkip--;
			}
		}

		public static void PlaySosigFootStepSound(Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			FVRPooledAudioType val = (FVRPooledAudioType)packet.ReadByte();
			Vector3 val2 = packet.ReadVector3();
			Vector2 val3 = packet.ReadVector2();
			Vector2 val4 = packet.ReadVector2();
			float num2 = packet.ReadFloat();
			if (Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				if (Mod.sosigFootstepAudioEvent == null)
				{
					Mod.sosigFootstepAudioEvent = trackedSosigData.physicalSosig.physicalSosig.AudEvent_FootSteps;
				}
				SM.PlayCoreSoundDelayedOverrides(val, Mod.sosigFootstepAudioEvent, val2, val3, val4, num2);
			}
		}

		public static void SosigSpeakState(Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected I4, but got Unknown
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			SosigOrder val = (SosigOrder)packet.ReadByte();
			if (Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null && (Object)(object)trackedSosigData.physicalSosig.physicalSosig.Speech != (Object)null)
			{
				SosigOrder val2 = val;
				SosigOrder val3 = val2;
				switch (val3 - 1)
				{
				case 0:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnWander);
					break;
				case 2:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnInvestigate);
					break;
				case 3:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnSearchingForGuns);
					break;
				case 4:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnTakingCover);
					break;
				case 5:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnWander);
					break;
				case 6:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnAssault);
					break;
				case 1:
					break;
				}
			}
		}

		public static void SosigSetCurrentOrder(Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected I4, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			SosigOrder val = (SosigOrder)packet.ReadByte();
			if (!(Client.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			trackedSosigData.currentOrder = val;
			SosigOrder val2 = val;
			SosigOrder val3 = val2;
			switch (val3 - 1)
			{
			case 0:
				trackedSosigData.guardPoint = packet.ReadVector3();
				trackedSosigData.guardDir = packet.ReadVector3();
				trackedSosigData.hardGuard = packet.ReadBool();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.CommandGuardPoint(trackedSosigData.guardPoint, trackedSosigData.hardGuard);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_guardDominantDirection = trackedSosigData.guardDir;
				}
				break;
			case 1:
				trackedSosigData.skirmishPoint = packet.ReadVector3();
				trackedSosigData.pathToPoint = packet.ReadVector3();
				trackedSosigData.assaultPoint = packet.ReadVector3();
				trackedSosigData.faceTowards = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_skirmishPoint = trackedSosigData.skirmishPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_pathToPoint = trackedSosigData.pathToPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_assaultPoint = trackedSosigData.assaultPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_faceTowards = trackedSosigData.faceTowards;
				}
				break;
			case 2:
				trackedSosigData.guardPoint = packet.ReadVector3();
				trackedSosigData.hardGuard = packet.ReadBool();
				trackedSosigData.faceTowards = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.UpdateGuardPoint(trackedSosigData.guardPoint);
					trackedSosigData.physicalSosig.physicalSosig.m_hardGuard = trackedSosigData.hardGuard;
					trackedSosigData.physicalSosig.physicalSosig.m_faceTowards = trackedSosigData.faceTowards;
				}
				break;
			case 3:
			case 5:
				trackedSosigData.wanderPoint = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_wanderPoint = trackedSosigData.wanderPoint;
				}
				break;
			case 6:
				trackedSosigData.assaultPoint = packet.ReadVector3();
				trackedSosigData.assaultSpeed = (SosigMoveSpeed)packet.ReadByte();
				trackedSosigData.faceTowards = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.CommandAssaultPoint(trackedSosigData.assaultPoint);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_faceTowards = trackedSosigData.faceTowards;
					trackedSosigData.physicalSosig.physicalSosig.SetAssaultSpeed(trackedSosigData.assaultSpeed);
				}
				break;
			case 8:
				trackedSosigData.idleToPoint = packet.ReadVector3();
				trackedSosigData.idleDominantDir = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.CommandIdle(trackedSosigData.idleToPoint, trackedSosigData.idleDominantDir);
					SosigPatch.sosigSetCurrentOrderSkip--;
				}
				break;
			case 9:
				trackedSosigData.pathToPoint = packet.ReadVector3();
				trackedSosigData.pathToLookDir = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_pathToPoint = trackedSosigData.pathToPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_pathToLookDir = trackedSosigData.pathToLookDir;
				}
				break;
			default:
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
				}
				break;
			}
		}

		public static void SosigVaporize(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				byte b = packet.ReadByte();
				if (Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigVaporizeSkip++;
					trackedSosigData.physicalSosig.physicalSosig.Vaporize(trackedSosigData.physicalSosig.physicalSosig.DamageFX_Vaporize, (int)b);
					SosigPatch.sosigVaporizeSkip--;
				}
			}
		}

		public static void SosigLinkBreak(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				byte index = packet.ReadByte();
				bool flag = packet.ReadBool();
				byte b = packet.ReadByte();
				if (Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigLinkActionPatch.sosigLinkBreakSkip++;
					trackedSosigData.physicalSosig.physicalSosig.Links[index].BreakJoint(flag, (DamageClass)b);
					SosigLinkActionPatch.sosigLinkBreakSkip--;
				}
			}
		}

		public static void SosigLinkSever(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				byte index = packet.ReadByte();
				byte b = packet.ReadByte();
				bool flag = packet.ReadBool();
				if (Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigLinkActionPatch.sosigLinkSeverSkip++;
					trackedSosigData.physicalSosig.physicalSosig.Links[index].SeverJoint((DamageClass)b, flag);
					SosigLinkActionPatch.sosigLinkSeverSkip--;
				}
			}
		}

		public static void SosigRequestHitDecal(Packet packet)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				Vector3 val = packet.ReadVector3();
				Vector3 val2 = packet.ReadVector3();
				Vector3 val3 = packet.ReadVector3();
				float num2 = packet.ReadFloat();
				byte index = packet.ReadByte();
				if ((Object)(object)trackedSosigData.physicalSosig.physicalSosig.Links[index] != (Object)null)
				{
					SosigPatch.sosigRequestHitDecalSkip++;
					trackedSosigData.physicalSosig.physicalSosig.RequestHitDecal(val, val2, val3, num2, trackedSosigData.physicalSosig.physicalSosig.Links[index]);
					SosigPatch.sosigRequestHitDecalSkip--;
				}
			}
		}

		public static void RequestUpToDateObjects(Packet packet)
		{
			bool instantiateOnReceive = packet.ReadBool();
			int forClient = packet.ReadInt();
			if (!GameManager.sceneLoading)
			{
				ClientSend.UpToDateObjects(instantiateOnReceive, forClient);
			}
			else
			{
				ClientSend.DoneSendingUpdaToDateObjects(forClient);
			}
		}

		public static void AddTNHInstance(Packet packet)
		{
			GameManager.AddTNHInstance(packet.ReadTNHInstance());
		}

		public static void AddInstance(Packet packet)
		{
			GameManager.AddInstance(packet.ReadInt());
		}

		public static void AddTNHCurrentlyPlaying(Packet packet)
		{
			int iD = packet.ReadInt();
			int key = packet.ReadInt();
			Mod.LogInfo("ClientHandle: Received AddTNHCurrentlyPlaying for instance: " + key + " to add " + iD, debug: false);
			if (GameManager.TNHInstances == null || !GameManager.TNHInstances.ContainsKey(key))
			{
				Mod.LogError("ClientHandle: Received AddTNHCurrentlyPlaying packet with missing instance");
			}
			else
			{
				GameManager.TNHInstances[key].AddCurrentlyPlaying(send: false, iD);
			}
		}

		public static void RemoveTNHCurrentlyPlaying(Packet packet)
		{
			int iD = packet.ReadInt();
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.RemoveCurrentlyPlaying(send: false, iD);
			}
		}

		public static void SetTNHProgression(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].progressionTypeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.progressionSkip++;
				Mod.currentTNHUIManager.OBS_Progression.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_Progression(num);
				GM.TNHOptions.ProgressionTypeSetting = (TNHSetting_ProgressionType)num;
				TNH_UIManagerPatch.progressionSkip--;
			}
		}

		public static void SetTNHEquipment(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].equipmentModeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.equipmentSkip++;
				Mod.currentTNHUIManager.OBS_EquipmentMode.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_EquipmentMode(num);
				GM.TNHOptions.EquipmentModeSetting = (TNHSetting_EquipmentMode)num;
				TNH_UIManagerPatch.equipmentSkip--;
			}
		}

		public static void SetTNHHealthMode(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].healthModeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.healthModeSkip++;
				Mod.currentTNHUIManager.OBS_HealthMode.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_HealthMode(num);
				GM.TNHOptions.HealthModeSetting = (TNHSetting_HealthMode)num;
				TNH_UIManagerPatch.healthModeSkip--;
			}
		}

		public static void SetTNHTargetMode(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].targetModeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.targetSkip++;
				Mod.currentTNHUIManager.OBS_TargetMode.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_TargetMode(num);
				GM.TNHOptions.TargetModeSetting = (TNHSetting_TargetMode)num;
				TNH_UIManagerPatch.targetSkip--;
			}
		}

		public static void SetTNHAIDifficulty(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].AIDifficultyModifier = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.AIDifficultySkip++;
				Mod.currentTNHUIManager.OBS_AIDifficulty.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_AIDifficulty(num);
				GM.TNHOptions.AIDifficultyModifier = (TNHModifier_AIDifficulty)num;
				TNH_UIManagerPatch.AIDifficultySkip--;
			}
		}

		public static void SetTNHRadarMode(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].radarModeModifier = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.radarSkip++;
				Mod.currentTNHUIManager.OBS_AIRadarMode.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_AIRadarMode(num);
				GM.TNHOptions.RadarModeModifier = (TNHModifier_RadarMode)num;
				TNH_UIManagerPatch.radarSkip--;
			}
		}

		public static void SetTNHItemSpawnerMode(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].itemSpawnerMode = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.itemSpawnerSkip++;
				Mod.currentTNHUIManager.OBS_ItemSpawner.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_ItemSpawner(num);
				GM.TNHOptions.ItemSpawnerMode = (TNH_ItemSpawnerMode)num;
				TNH_UIManagerPatch.itemSpawnerSkip--;
			}
		}

		public static void SetTNHBackpackMode(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].backpackMode = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.backpackSkip++;
				Mod.currentTNHUIManager.OBS_Backpack.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_Backpack(num);
				GM.TNHOptions.BackpackMode = (TNH_BackpackMode)num;
				TNH_UIManagerPatch.backpackSkip--;
			}
		}

		public static void SetTNHHealthMult(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].healthMult = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.healthMultSkip++;
				Mod.currentTNHUIManager.OBS_HealthMult.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_HealthMult(num);
				GM.TNHOptions.HealthMult = (TNH_HealthMult)num;
				TNH_UIManagerPatch.healthMultSkip--;
			}
		}

		public static void SetTNHSosigGunReload(Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].sosiggunShakeReloading = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.sosigGunReloadSkip++;
				Mod.currentTNHUIManager.OBS_SosiggunReloading.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_SosiggunShakeReloading(num);
				GM.TNHOptions.SosiggunShakeReloading = (TNH_SosiggunShakeReloading)num;
				TNH_UIManagerPatch.sosigGunReloadSkip--;
			}
		}

		public static void SetTNHSeed(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].TNHSeed = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.seedSkip++;
				Mod.currentTNHUIManager.OBS_RunSeed.SetSelectedButton(num + 1);
				Mod.currentTNHUIManager.SetOBS_RunSeed(num);
				GM.TNHOptions.TNHSeed = num;
				TNH_UIManagerPatch.seedSkip--;
			}
		}

		public static void SetTNHLevelID(Packet packet)
		{
			string text = packet.ReadString();
			int num = packet.ReadInt();
			if (!GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				return;
			}
			value.levelID = text;
			if (Mod.currentTNHInstance == null || Mod.currentTNHInstance.instance != num || !((Object)(object)Mod.currentTNHUIManager != (Object)null))
			{
				return;
			}
			bool flag = false;
			for (int i = 0; i < Mod.currentTNHUIManager.Levels.Count; i++)
			{
				if (Mod.currentTNHUIManager.Levels[i].LevelID.Equals(text))
				{
					flag = true;
					Mod.currentTNHUIManager._currentLevelIndex = i;
					Mod.currentTNHUIManager.CurrentLevel.LevelID = text;
					Mod.currentTNHUIManager.UpdateLevelSelectUi();
					Mod.currentTNHUIManager.UpdateTableBasedOnOptions();
					Mod.currentTNHUIManager.PlayButtonSound(2);
					((Component)Mod.currentTNHSceneLoader).gameObject.SetActive(true);
					break;
				}
			}
			if (!flag)
			{
				((Component)Mod.currentTNHSceneLoader).gameObject.SetActive(false);
				Mod.LogError("Missing TNH level: " + text + ", you will not be able to play in this instance if the game is started!");
			}
		}

		public static void SetTNHController(Packet packet)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Invalid comparison between Unknown and I4
			int key = packet.ReadInt();
			int num = packet.ReadInt();
			Mod.LogInfo("Client received order to set TNH instance: " + key + " controller to: " + num, debug: false);
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.controller = num;
				if ((Object)(object)value.manager != (Object)null && num == GameManager.ID && (int)value.phase == -1 && Mod.currentTNHInstance.manager.m_hasInit)
				{
					value.manager.SetPhase((TNH_Phase)0);
				}
			}
		}

		public static void TNHPlayerDied(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			TNHInstance tNHInstance = GameManager.TNHInstances[num];
			tNHInstance.dead.Add(num2);
			bool flag = true;
			for (int i = 0; i < tNHInstance.currentlyPlaying.Count; i++)
			{
				if (!tNHInstance.dead.Contains(tNHInstance.currentlyPlaying[i]))
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				foreach (int item in tNHInstance.dead)
				{
					if (GameManager.players.TryGetValue(item, out var value))
					{
						value.SetVisible(visible: true);
					}
				}
				tNHInstance.Reset();
			}
			if (Mod.currentTNHInstance == null || Mod.currentTNHInstance.instance != num || !Mod.currentlyPlayingTNH)
			{
				return;
			}
			if (flag)
			{
				Mod.currentTNHInstance.manager.m_patrolSquads.Clear();
			}
			else
			{
				if (!GameManager.players.TryGetValue(num2, out var value2))
				{
					return;
				}
				value2.SetVisible(visible: false);
				if (Mod.currentTNHInstance == null || !((Object)(object)Mod.currentTNHInstance.manager != (Object)null) || !((Object)(object)Mod.currentTNHInstance.manager.TAHReticle != (Object)null) || !((Object)(object)value2.reticleContact != (Object)null))
				{
					return;
				}
				for (int j = 0; j < Mod.currentTNHInstance.manager.TAHReticle.Contacts.Count; j++)
				{
					if ((Object)(object)Mod.currentTNHInstance.manager.TAHReticle.Contacts[j] == (Object)(object)value2.reticleContact)
					{
						GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[j].TrackedTransform);
						Object.Destroy((Object)(object)((Component)Mod.currentTNHInstance.manager.TAHReticle.Contacts[j]).gameObject);
						Mod.currentTNHInstance.manager.TAHReticle.Contacts.RemoveAt(j);
						value2.reticleContact = null;
						break;
					}
				}
			}
		}

		public static void TNHAddTokens(Packet packet)
		{
			int key = packet.ReadInt();
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.tokenCount += num;
				if ((Object)(object)value.manager != (Object)null && !value.dead.Contains(GameManager.ID))
				{
					TNH_ManagerPatch.addTokensSkip++;
					value.manager.AddTokens(num, false);
					TNH_ManagerPatch.addTokensSkip--;
				}
			}
		}

		public static void AutoMeaterSetState(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				byte b = packet.ReadByte();
				if (Client.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData && (Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
				{
					AutoMeaterSetStatePatch.skip++;
					trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.SetState((AutoMeaterState)b);
					AutoMeaterSetStatePatch.skip--;
				}
			}
		}

		public static void AutoMeaterSetBladesActive(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			bool flag = packet.ReadBool();
			if (!(Client.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData) || !((Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null))
			{
				return;
			}
			if (flag)
			{
				for (int i = 0; i < trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades.Count; i++)
				{
					trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades[i].Reactivate();
				}
			}
			else
			{
				for (int j = 0; j < trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades.Count; j++)
				{
					trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades[j].ShutDown();
				}
			}
		}

		public static void AutoMeaterFirearmFireAtWill(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				int index = packet.ReadInt();
				bool flag = packet.ReadBool();
				float num2 = packet.ReadFloat();
				if (Client.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData && (Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
				{
					AutoMeaterFirearmFireAtWillPatch.skip++;
					trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.FireControl.Firearms[index].SetFireAtWill(flag, num2);
					AutoMeaterFirearmFireAtWillPatch.skip--;
				}
			}
		}

		public static void TNHSosigKill(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Client.objects.Length > num2 && Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num && (Object)(object)Mod.currentTNHInstance.manager != (Object)null && Client.objects[num2] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				TNH_ManagerPatch.sosigKillSkip++;
				Mod.currentTNHInstance.manager.OnSosigKill(trackedSosigData.physicalSosig.physicalSosig);
				TNH_ManagerPatch.sosigKillSkip--;
			}
		}

		public static void TNHHoldPointSystemNode(Packet packet)
		{
			int key = packet.ReadInt();
			int level = packet.ReadInt();
			int curHoldIndex = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.curHoldIndex = curHoldIndex;
				value.level = level;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.manager.SetLevel(level);
				}
			}
		}

		public static void TNHHoldBeginChallenge(Packet packet)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			bool flag = packet.ReadBool();
			Mod.LogInfo("TNHHoldBeginChallenge client handle", debug: false);
			TNHInstance value2;
			if (flag)
			{
				if (!GameManager.TNHInstances.TryGetValue(key, out var value))
				{
					return;
				}
				value.holdOngoing = true;
				Mod.currentTNHInstance.holdState = (HoldState)0;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					TNH_HoldPointPatch.beginHoldSendSkip++;
					Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasActivated = true;
					Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasInitiatedHold = true;
					Mod.currentTNHInstance.manager.m_curHoldPoint.BeginHoldChallenge();
					TNH_HoldPointPatch.beginHoldSendSkip--;
					if (!value.dead.Contains(GameManager.ID) || Mod.TNHOnDeathSpectate)
					{
						GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.m_curHoldPoint.SpawnPoint_SystemNode.position, true);
					}
				}
			}
			else if (GameManager.TNHInstances.TryGetValue(key, out value2) && value2.controller == GameManager.ID)
			{
				Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasActivated = true;
				Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasInitiatedHold = true;
				Mod.currentTNHInstance.manager.m_curHoldPoint.BeginHoldChallenge();
				if (!value2.dead.Contains(GameManager.ID) || Mod.TNHOnDeathSpectate)
				{
					GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.m_curHoldPoint.SpawnPoint_SystemNode.position, true);
				}
			}
		}

		public static void ShatterableCrateSetHoldingHealth(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.additionalData.Length == 40)
			{
				trackedItemData.additionalData[37] = 1;
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					UberShatterable val = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
					if ((Object)(object)val != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
					{
						val.SpawnOnShatter.Clear();
						val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
						val.SpawnOnShatterPoints.Add(((Component)val).transform);
						val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
						val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_HealthMinor);
						val.SpawnOnShatterPoints.Add(((Component)val).transform);
						val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)2);
					}
				}
			}
			else
			{
				trackedItemData.additionalData[3] = 1;
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					TNH_ShatterableCrateSetHoldingHealthPatch.skip++;
					((Component)trackedItemData.physicalItem).GetComponent<TNH_ShatterableCrate>().SetHoldingHealth(GM.TNH_Manager);
					TNH_ShatterableCrateSetHoldingHealthPatch.skip--;
				}
			}
		}

		public static void ShatterableCrateSetHoldingToken(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.additionalData.Length == 40)
			{
				trackedItemData.additionalData[38] = 1;
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					UberShatterable val = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
					if ((Object)(object)val != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
					{
						val.SpawnOnShatter.Clear();
						val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
						val.SpawnOnShatterPoints.Add(((Component)val).transform);
						val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
						val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Token);
						val.SpawnOnShatterPoints.Add(((Component)val).transform);
						val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)2);
					}
				}
			}
			else
			{
				trackedItemData.additionalData[4] = 1;
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					TNH_ShatterableCrateSetHoldingTokenPatch.skip++;
					((Component)trackedItemData.physicalItem).GetComponent<TNH_ShatterableCrate>().SetHoldingToken(GM.TNH_Manager);
					TNH_ShatterableCrateSetHoldingTokenPatch.skip--;
				}
			}
		}

		public static void ShatterableCrateSetUsesLoot(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.additionalData.Length == 40)
			{
				trackedItemData.additionalData[39] = 1;
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					UberShatterable val = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
					if ((Object)(object)val != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
					{
						val.SpawnOnShatter.Clear();
						val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
						val.SpawnOnShatterPoints.Add(((Component)val).transform);
						val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
						val.SetUsesLoot();
					}
				}
			}
			else
			{
				trackedItemData.additionalData[5] = 1;
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					TNH_ShatterableCrateSetHoldingTokenPatch.skip++;
					((Component)trackedItemData.physicalItem).GetComponent<TNH_ShatterableCrate>().SetUsesLoot(GM.TNH_Manager);
					TNH_ShatterableCrateSetHoldingTokenPatch.skip--;
				}
			}
		}

		public static void ShatterableCrateDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					TNH_ShatterableCrateDamagePatch.skip++;
					((Component)trackedItemData.physicalItem).GetComponent<TNH_ShatterableCrate>().Damage(packet.ReadDamage());
					TNH_ShatterableCrateDamagePatch.skip--;
				}
			}
			else
			{
				ClientSend.ShatterableCrateDamage(packet);
			}
		}

		public static void ShatterableCrateDestroy(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				TNH_ShatterableCrate componentInChildren = ((Component)trackedItemData.physicalItem).GetComponentInChildren<TNH_ShatterableCrate>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					Mod.LogError("Received order to destroy shatterable crate for which we have physObj but it has not crate script!");
					return;
				}
				TNH_ShatterableCrateDestroyPatch.skip++;
				componentInChildren.Destroy(packet.ReadDamage());
				TNH_ShatterableCrateDestroyPatch.skip--;
			}
		}

		public static void TNHSetLevel(Packet packet)
		{
			int key = packet.ReadInt();
			int level = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.level = level;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.level = level;
					value.manager.m_level = level;
					value.manager.SetLevel(level);
				}
			}
		}

		public static void TNHSetPhaseTake(Packet packet)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			int curHoldIndex = packet.ReadInt();
			int num = packet.ReadInt();
			List<int> list = new List<int>();
			for (int i = 0; i < num; i++)
			{
				list.Add(packet.ReadInt());
			}
			bool flag = packet.ReadBool();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.curHoldIndex = curHoldIndex;
				value.phase = (TNH_Phase)0;
				value.activeSupplyPointIndices = list;
				if (!flag && (Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.manager.SetPhase_Take();
				}
			}
		}

		public static void TNHSetPhaseHold(Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.phase = (TNH_Phase)1;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.manager.SetPhase_Hold();
				}
			}
		}

		public static void TNHHoldCompletePhase(Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.holdState = (HoldState)3;
				value.raisedBarriers = null;
				value.raisedBarrierPrefabIndices = null;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.CompletePhase();
				}
			}
		}

		public static void TNHSetPhaseComplete(Packet packet)
		{
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				if ((Object)(object)value.manager != (Object)null)
				{
					Mod.currentTNHInstance.manager.SetPhase_Completed();
				}
				value.Reset();
			}
		}

		public static void TNHSetPhase(Packet packet)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			short num = packet.ReadShort();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.phase = (TNH_Phase)num;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.manager.Phase = (TNH_Phase)num;
				}
			}
		}

		public static void EncryptionRespawnSubTarg(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int num2 = packet.ReadInt();
			if (Client.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.subTargsActive[num2] = true;
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[num2].SetActive(true);
					TNH_EncryptionTarget physicalEncryption = trackedEncryptionData.physicalEncryption.physicalEncryption;
					physicalEncryption.m_numSubTargsLeft++;
				}
			}
		}

		public static void EncryptionRespawnSubTargGeo(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int num2 = packet.ReadInt();
			if (Client.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.subTargGeosActive[num2] = true;
				trackedEncryptionData.subTargsActive[num2] = true;
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					((Component)trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargGeo[num2]).gameObject.SetActive(true);
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[num2].SetActive(true);
					TNH_EncryptionTarget physicalEncryption = trackedEncryptionData.physicalEncryption.physicalEncryption;
					physicalEncryption.m_numSubTargsLeft++;
				}
			}
		}

		public static void EncryptionSpawnGrowth(Packet packet)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int num2 = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			if (Client.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.subTargsActive[num2] = true;
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					Vector3 val2 = val - trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].transform.position;
					EncryptionSpawnGrowthPatch.skip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.SpawnGrowth(num2, val);
					EncryptionSpawnGrowthPatch.skip--;
					trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].transform.localScale = new Vector3(0.2f, 0.2f, ((Vector3)(ref val2)).magnitude * trackedEncryptionData.physicalEncryption.physicalEncryption.TendrilFloats[num2]);
				}
			}
		}

		public static void EncryptionInit(Packet packet)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int num2 = packet.ReadInt();
			List<int> list = new List<int>();
			for (int i = 0; i < num2; i++)
			{
				list.Add(packet.ReadInt());
			}
			Vector3 initialPos = packet.ReadVector3();
			int num3 = packet.ReadInt();
			if (!(Client.objects[num] is TrackedEncryptionData trackedEncryptionData))
			{
				return;
			}
			for (int j = 0; j < num2; j++)
			{
				trackedEncryptionData.subTargsActive[list[j]] = true;
			}
			if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				EncryptionSpawnGrowthPatch.skip++;
				for (int k = 0; k < num2; k++)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[list[k]].SetActive(true);
				}
				EncryptionSpawnGrowthPatch.skip--;
				trackedEncryptionData.physicalEncryption.physicalEncryption.m_numSubTargsLeft = num2;
			}
			trackedEncryptionData.initialPos = initialPos;
			if ((Object)(object)trackedEncryptionData.physical != (Object)null && trackedEncryptionData.physicalEncryption.physicalEncryption.UseReturnToSpawnForce)
			{
				if ((Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.m_returnToSpawnLine != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)trackedEncryptionData.physicalEncryption.physicalEncryption.m_returnToSpawnLine).gameObject);
				}
				trackedEncryptionData.physicalEncryption.physicalEncryption.initialPos = initialPos;
				GameObject val = Object.Instantiate<GameObject>(trackedEncryptionData.physicalEncryption.physicalEncryption.ReturnToSpawnLineGO, ((Component)trackedEncryptionData.physicalEncryption).transform.position, Quaternion.identity);
				trackedEncryptionData.physicalEncryption.physicalEncryption.m_returnToSpawnLine = val.transform;
				trackedEncryptionData.physicalEncryption.physicalEncryption.UpdateLine();
			}
			trackedEncryptionData.numHitsLeft = num3;
			if ((Object)(object)trackedEncryptionData.physical != (Object)null)
			{
				trackedEncryptionData.physicalEncryption.physicalEncryption.m_numHitsLeft = num3;
				if (trackedEncryptionData.physicalEncryption.physicalEncryption.UsesMultipleDisplay && trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList.Count > num3 && (Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList[num3] != (Object)null)
				{
					EncryptionPatch.updateDisplaySkip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.UpdateDisplay();
					EncryptionPatch.updateDisplaySkip--;
				}
			}
		}

		public static void EncryptionResetGrowth(Packet packet)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				int num2 = packet.ReadInt();
				Vector3 val = packet.ReadVector3();
				if (Client.objects[num] is TrackedEncryptionData trackedEncryptionData && (Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					Vector3 val2 = val - trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].transform.position;
					EncryptionResetGrowthPatch.skip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.ResetGrowth(num2, val);
					EncryptionResetGrowthPatch.skip--;
				}
			}
		}

		public static void EncryptionDisableSubtarg(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int num2 = packet.ReadInt();
			if (!(Client.objects[num] is TrackedEncryptionData trackedEncryptionData))
			{
				return;
			}
			trackedEncryptionData.subTargsActive[num2] = false;
			if (trackedEncryptionData.subTargGeosActive != null && trackedEncryptionData.subTargGeosActive.Length > num2)
			{
				trackedEncryptionData.subTargGeosActive[num2] = false;
			}
			if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[num2].SetActive(false);
				if (trackedEncryptionData.physicalEncryption.physicalEncryption.UsesRegeneratingSubtargs)
				{
					((Component)trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargGeo[num2]).gameObject.SetActive(false);
				}
				if (trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils != null && trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils.Count > num2)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].SetActive(false);
				}
				TNH_EncryptionTarget physicalEncryption = trackedEncryptionData.physicalEncryption.physicalEncryption;
				physicalEncryption.m_numSubTargsLeft--;
			}
		}

		public static void InitTNHInstances(Packet packet)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			int num = packet.ReadInt();
			for (int i = 0; i < num; i++)
			{
				TNHInstance TNHInstance = packet.ReadTNHInstance(full: true);
				GameManager.TNHInstances.Add(TNHInstance.instance, TNHInstance);
				if ((TNHInstance.letPeopleJoin || TNHInstance.currentlyPlaying.Count == 0) && (Object)(object)Mod.TNHInstanceList != (Object)null && !Mod.joinTNHInstances.ContainsKey(TNHInstance.instance))
				{
					GameObject val = Object.Instantiate<GameObject>(Mod.TNHInstancePrefab, Mod.TNHInstanceList.transform);
					((Component)val.transform.GetChild(0)).GetComponent<Text>().text = "Instance " + TNHInstance.instance;
					val.SetActive(true);
					FVRPointableButton val2 = val.AddComponent<FVRPointableButton>();
					val2.SetButton();
					((FVRPointable)val2).MaxPointingRange = 5f;
					((UnityEvent)val2.Button.onClick).AddListener((UnityAction)delegate
					{
						Mod.OnTNHInstanceClicked(TNHInstance.instance);
					});
					Mod.joinTNHInstances.Add(TNHInstance.instance, val);
				}
			}
		}

		public static void TNHHoldPointBeginAnalyzing(Packet packet)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (!GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				return;
			}
			value.tickDownToID = packet.ReadFloat();
			value.holdState = (HoldState)1;
			value.warpInData = new List<Vector3>();
			byte b = packet.ReadByte();
			for (int i = 0; i < b; i++)
			{
				value.warpInData.Add(packet.ReadVector3());
			}
			if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
			{
				GM.TNH_Manager.m_curHoldPoint.BeginAnalyzing();
				for (int j = 0; j < b; j += 2)
				{
					GM.TNH_Manager.m_curHoldPoint.m_warpInTargets.Add(Object.Instantiate<GameObject>(GM.TNH_Manager.m_curHoldPoint.M.Prefab_TargetWarpingIn, value.warpInData[j], Quaternion.Euler(value.warpInData[j + 1])));
				}
			}
		}

		public static void TNHHoldPointRaiseBarriers(Packet packet)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (!GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				return;
			}
			int num = packet.ReadInt();
			value.raisedBarriers = new List<int>();
			value.raisedBarrierPrefabIndices = new List<int>();
			for (int i = 0; i < num; i++)
			{
				value.raisedBarriers.Add(packet.ReadInt());
			}
			for (int j = 0; j < num; j++)
			{
				value.raisedBarrierPrefabIndices.Add(packet.ReadInt());
			}
			if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
			{
				for (int k = 0; k < value.raisedBarriers.Count; k++)
				{
					TNH_DestructibleBarrierPoint val = GM.TNH_Manager.m_curHoldPoint.BarrierPoints[value.raisedBarriers[k]];
					BarrierDataSet val2 = val.BarrierDataSets[value.raisedBarrierPrefabIndices[k]];
					GameObject val3 = Object.Instantiate<GameObject>(val2.BarrierPrefab, ((Component)val).transform.position, ((Component)val).transform.rotation);
					TNH_DestructibleBarrier val4 = (val.m_curBarrier = val3.GetComponent<TNH_DestructibleBarrier>());
					val4.InitToPlace(((Component)val).transform.position, ((Component)val).transform.forward);
					val4.SetBarrierPoint(val);
					val.SetCoverPointData(value.raisedBarrierPrefabIndices[k]);
				}
			}
		}

		public static void TNHHoldIdentifyEncryption(Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.holdState = (HoldState)2;
				value.tickDownToFailure = 120f;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.IdentifyEncryption();
				}
			}
		}

		public static void TNHHoldPointFailOut(Packet packet)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.holdOngoing = false;
				value.holdState = (HoldState)0;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.FailOut();
				}
			}
		}

		public static void TNHHoldPointBeginPhase(Packet packet)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.holdOngoing = true;
				value.holdState = (HoldState)0;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.BeginPhase();
				}
			}
		}

		public static void TNHHoldPointCompleteHold(Packet packet)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.holdOngoing = false;
				value.holdState = (HoldState)0;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.CompleteHold();
				}
			}
		}

		public static void SosigPriorityIFFChart(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int i = packet.ReadInt();
			if (Client.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.IFFChart = SosigTargetPrioritySystemPatch.IntToBoolArr(i);
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					trackedSosigData.physicalSosig.physicalSosig.Priority.IFFChart = SosigTargetPrioritySystemPatch.IntToBoolArr(i);
				}
			}
		}

		public static void RemoteMissileDetonate(Packet packet)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				RemoteMissile missile = ((RemoteMissileLauncher)((physicalItem is RemoteMissileLauncher) ? physicalItem : null)).m_missile;
				if ((Object)(object)missile != (Object)null)
				{
					RemoteMissileDetonatePatch.overriden = true;
					((Component)missile).transform.position = packet.ReadVector3();
					missile.Detonante();
				}
			}
		}

		public static void StingerMissileExplode(Packet packet)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				StingerMissile stingerMissile = trackedItemData.physicalItem.stingerMissile;
				if ((Object)(object)stingerMissile != (Object)null)
				{
					StingerMissileExplodePatch.overriden = true;
					((Component)stingerMissile).transform.position = packet.ReadVector3();
					stingerMissile.Explode();
				}
			}
		}

		public static void PinnedGrenadeExplode(Packet packet)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				PinnedGrenade val = (PinnedGrenade)(object)((physicalItem is PinnedGrenade) ? physicalItem : null);
				if ((Object)(object)val != (Object)null)
				{
					PinnedGrenadePatch.ExplodePinnedGrenade(val, packet.ReadVector3());
				}
			}
		}

		public static void PinnedGrenadePullPin(Packet packet)
		{
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData) || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
			PinnedGrenade val = (PinnedGrenade)(object)((physicalItem is PinnedGrenade) ? physicalItem : null);
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			for (int i = 0; i < val.m_rings.Count; i++)
			{
				if (!val.m_rings[i].HasPinDetached())
				{
					val.m_rings[i].m_hasPinDetached = true;
					val.m_rings[i].Pin.RootRigidbody = ((Component)val.m_rings[i].Pin).gameObject.AddComponent<Rigidbody>();
					val.m_rings[i].Pin.RootRigidbody.mass = 0.02f;
					((FVRInteractiveObject)val.m_rings[i]).ForceBreakInteraction();
					((Component)val.m_rings[i]).transform.SetParent(((Component)val.m_rings[i].Pin).transform);
					((Behaviour)val.m_rings[i].Pin).enabled = true;
					SM.PlayCoreSound((FVRPooledAudioType)10, val.m_rings[i].G.AudEvent_Pinpull, ((Component)val.m_rings[i]).transform.position);
					((Component)val.m_rings[i]).GetComponent<Collider>().enabled = false;
					((Behaviour)val.m_rings[i]).enabled = false;
				}
			}
		}

		public static void FVRGrenadeExplode(Packet packet)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				FVRGrenade val = (FVRGrenade)(object)((physicalItem is FVRGrenade) ? physicalItem : null);
				if ((Object)(object)val != (Object)null)
				{
					FVRGrenadePatch.ExplodeGrenade(val, packet.ReadVector3());
				}
			}
		}

		public static void BangSnapSplode(Packet packet)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				BangSnap val = (BangSnap)(object)((physicalItem is BangSnap) ? physicalItem : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					BangSnapPatch.skip++;
					val.Splode();
					BangSnapPatch.skip--;
				}
			}
		}

		public static void C4Detonate(Packet packet)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				C4 val = (C4)(object)((physicalItem is C4) ? physicalItem : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					C4DetonatePatch.skip++;
					val.Detonate();
					C4DetonatePatch.skip--;
				}
			}
		}

		public static void ClaymoreMineDetonate(Packet packet)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				ClaymoreMine val = (ClaymoreMine)(object)((physicalItem is ClaymoreMine) ? physicalItem : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					ClaymoreMineDetonatePatch.skip++;
					val.Detonate();
					ClaymoreMineDetonatePatch.skip--;
				}
			}
		}

		public static void SLAMDetonate(Packet packet)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				SLAM val = (SLAM)(object)((physicalItem is SLAM) ? physicalItem : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					SLAMDetonatePatch.skip++;
					val.Detonate();
					SLAMDetonatePatch.skip--;
				}
			}
		}

		public static void ClientDisconnect(Packet packet)
		{
			int playerID = packet.ReadInt();
			Mod.RemovePlayerFromLists(playerID);
		}

		public static void ServerClosed(Packet packet)
		{
			Client.singleton.Disconnect(sendToServer: false, 0);
		}

		public static void SpectatorHost(Packet packet)
		{
			int num = packet.ReadInt();
			if (packet.ReadBool())
			{
				if (!GameManager.spectatorHosts.Contains(num))
				{
					GameManager.spectatorHosts.Add(num);
				}
			}
			else
			{
				GameManager.spectatorHosts.Remove(num);
			}
			GameManager.UpdatePlayerHidden(GameManager.players[num]);
			GameManager.OnSpectatorHostsChangedInvoke();
		}

		public static void ResetTNH(Packet packet)
		{
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.Reset();
				if ((Object)(object)value.manager != (Object)null)
				{
					value.ResetManager();
				}
			}
		}

		public static void ReviveTNHPlayer(Packet packet)
		{
			int iD = packet.ReadInt();
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.RevivePlayer(iD, received: true);
			}
		}

		public static void PlayerColor(Packet packet)
		{
			int iD = packet.ReadInt();
			int index = packet.ReadInt();
			GameManager.SetPlayerColor(iD, index, received: true);
		}

		public static void ColorByIFF(Packet packet)
		{
			GameManager.colorByIFF = packet.ReadBool();
			if ((Object)(object)H3MPWristMenuSection.colorByIFFText != (Object)null)
			{
				H3MPWristMenuSection.colorByIFFText.text = "Color by IFF (" + GameManager.colorByIFF + ")";
			}
			if (GameManager.colorByIFF)
			{
				GameManager.colorIndex = GM.CurrentPlayerBody.GetPlayerIFF() % GameManager.colors.Length;
				if ((Object)(object)BodyWristMenuSection.colorText != (Object)null)
				{
					BodyWristMenuSection.colorText.text = "Current color: " + GameManager.colorNames[GameManager.colorIndex];
				}
				{
					foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
					{
						player.Value.SetColor(player.Value.IFF);
					}
					return;
				}
			}
			foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
			{
				player2.Value.SetColor(player2.Value.colorIndex);
			}
		}

		public static void NameplateMode(Packet packet)
		{
			GameManager.nameplateMode = packet.ReadInt();
			switch (GameManager.nameplateMode)
			{
			case 0:
				if ((Object)(object)H3MPWristMenuSection.nameplateText != (Object)null)
				{
					H3MPWristMenuSection.nameplateText.text = "Nameplates (All)";
				}
				{
					foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
					{
						if ((Object)(object)player.Value.playerBody != (Object)null)
						{
							player.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(enabled: true);
						}
					}
					break;
				}
			case 1:
				if ((Object)(object)H3MPWristMenuSection.nameplateText != (Object)null)
				{
					H3MPWristMenuSection.nameplateText.text = "Nameplates (Friendly only)";
				}
				if (!((Object)(object)GM.CurrentPlayerBody != (Object)null))
				{
					break;
				}
				{
					foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
					{
						if ((Object)(object)player2.Value.playerBody != (Object)null)
						{
							player2.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(GM.CurrentPlayerBody.GetPlayerIFF() == player2.Value.IFF);
						}
					}
					break;
				}
			case 2:
				if ((Object)(object)H3MPWristMenuSection.nameplateText != (Object)null)
				{
					H3MPWristMenuSection.nameplateText.text = "Nameplates (None)";
				}
				{
					foreach (KeyValuePair<int, PlayerManager> player3 in GameManager.players)
					{
						if ((Object)(object)player3.Value.playerBody != (Object)null)
						{
							player3.Value.playerBody.physicalPlayerBody.SetCanvasesEnabled(enabled: false);
						}
					}
					break;
				}
			}
		}

		public static void RadarMode(Packet packet)
		{
			GameManager.radarMode = packet.ReadInt();
			switch (GameManager.radarMode)
			{
			case 0:
				if ((Object)(object)H3MPWristMenuSection.radarModeText != (Object)null)
				{
					H3MPWristMenuSection.radarModeText.text = "Radar mode (All)";
				}
				if (Mod.currentTNHInstance == null || !((Object)(object)Mod.currentTNHInstance.manager != (Object)null))
				{
					break;
				}
				{
					foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
					{
						if (player.Value.visible && (Object)(object)player.Value.reticleContact == (Object)null && Mod.currentTNHInstance.currentlyPlaying.Contains(player.Key))
						{
							player.Value.reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(player.Value.head, (ContactType)((!GameManager.radarColor) ? (player.Value.colorIndex - 4) : ((player.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
						}
					}
					break;
				}
			case 1:
				if ((Object)(object)H3MPWristMenuSection.radarModeText != (Object)null)
				{
					H3MPWristMenuSection.radarModeText.text = "Radar mode (Friendly only)";
				}
				if (Mod.currentTNHInstance == null || !((Object)(object)Mod.currentTNHInstance.manager != (Object)null))
				{
					break;
				}
				{
					foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
					{
						if (player2.Value.visible && Mod.currentTNHInstance.currentlyPlaying.Contains(player2.Key) && player2.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF() && (Object)(object)player2.Value.reticleContact == (Object)null)
						{
							player2.Value.reticleContact = GM.TNH_Manager.TAHReticle.RegisterTrackedObject(player2.Value.head, (ContactType)((!GameManager.radarColor) ? (player2.Value.colorIndex - 4) : ((player2.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? (-2) : (-3))));
						}
						else
						{
							if ((player2.Value.visible && Mod.currentTNHInstance.currentlyPlaying.Contains(player2.Key) && player2.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) || !((Object)(object)player2.Value.reticleContact != (Object)null))
							{
								continue;
							}
							for (int num2 = GM.TNH_Manager.TAHReticle.Contacts.Count - 1; num2 >= 0; num2--)
							{
								if ((Object)(object)GM.TNH_Manager.TAHReticle.Contacts[num2] == (Object)(object)player2.Value.reticleContact)
								{
									GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[num2].TrackedTransform);
									Object.Destroy((Object)(object)((Component)GM.TNH_Manager.TAHReticle.Contacts[num2]).gameObject);
									GM.TNH_Manager.TAHReticle.Contacts.RemoveAt(num2);
									player2.Value.reticleContact = null;
									break;
								}
							}
						}
					}
					break;
				}
			case 2:
				if ((Object)(object)H3MPWristMenuSection.radarModeText != (Object)null)
				{
					H3MPWristMenuSection.radarModeText.text = "Radar mode (None)";
				}
				if (Mod.currentTNHInstance == null || !((Object)(object)Mod.currentTNHInstance.manager != (Object)null))
				{
					break;
				}
				{
					foreach (KeyValuePair<int, PlayerManager> player3 in GameManager.players)
					{
						if (!((Object)(object)player3.Value.reticleContact != (Object)null))
						{
							continue;
						}
						for (int num = GM.TNH_Manager.TAHReticle.Contacts.Count - 1; num >= 0; num--)
						{
							if ((Object)(object)GM.TNH_Manager.TAHReticle.Contacts[num] == (Object)(object)player3.Value.reticleContact)
							{
								GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[num].TrackedTransform);
								Object.Destroy((Object)(object)((Component)GM.TNH_Manager.TAHReticle.Contacts[num]).gameObject);
								GM.TNH_Manager.TAHReticle.Contacts.RemoveAt(num);
								player3.Value.reticleContact = null;
								break;
							}
						}
					}
					break;
				}
			}
		}

		public static void RadarColor(Packet packet)
		{
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			GameManager.radarColor = packet.ReadBool();
			if ((Object)(object)H3MPWristMenuSection.radarColorText != (Object)null)
			{
				H3MPWristMenuSection.radarColorText.text = "Radar color IFF (" + GameManager.radarColor + ")";
			}
			if (GameManager.radarColor)
			{
				foreach (KeyValuePair<int, PlayerManager> player in GameManager.players)
				{
					if ((Object)(object)player.Value.reticleContact == (Object)null)
					{
						player.Value.reticleContact.R_Arrow.material.color = ((player.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? Color.green : Color.red);
						player.Value.reticleContact.R_Icon.material.color = ((player.Value.IFF == GM.CurrentPlayerBody.GetPlayerIFF()) ? Color.green : Color.red);
					}
				}
				return;
			}
			foreach (KeyValuePair<int, PlayerManager> player2 in GameManager.players)
			{
				if ((Object)(object)player2.Value.reticleContact == (Object)null)
				{
					player2.Value.reticleContact.R_Arrow.material.color = GameManager.colors[player2.Value.colorIndex];
					player2.Value.reticleContact.R_Icon.material.color = GameManager.colors[player2.Value.colorIndex];
				}
			}
		}

		public static void TNHInitializer(Packet packet)
		{
			int key = packet.ReadInt();
			int num = packet.ReadInt();
			if (!GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				return;
			}
			value.initializer = num;
			if (num != GameManager.ID)
			{
				value.initializationRequested = false;
				if (Mod.currentTNHInstance == value && Mod.waitingForTNHGameStart)
				{
					Mod.currentTNHSceneLoader.Load();
				}
			}
		}

		public static void MaxHealth(Packet packet)
		{
			string scene = packet.ReadString();
			int instance = packet.ReadInt();
			int index = packet.ReadInt();
			float original = packet.ReadFloat();
			H3MPWristMenuSection.UpdateMaxHealth(scene, instance, index, original);
		}

		public static void FuseIgnite(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.physicalItem is FVRFusedThrowable)
			{
				FusePatch.igniteSkip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((FVRFusedThrowable)((physicalItem is FVRFusedThrowable) ? physicalItem : null)).Fuse.Ignite(0f);
				FusePatch.igniteSkip--;
			}
		}

		public static void FuseBoom(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.physicalItem is FVRFusedThrowable)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((FVRFusedThrowable)((physicalItem is FVRFusedThrowable) ? physicalItem : null)).Fuse.Boom();
			}
		}

		public static void MolotovShatter(Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.physicalItem is Molotov)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				Molotov val = (Molotov)(object)((physicalItem is Molotov) ? physicalItem : null);
				if (flag && !val.Igniteable.IsOnFire())
				{
					val.RemoteIgnite();
				}
				MolotovPatch.shatterSkip++;
				val.Shatter();
				MolotovPatch.shatterSkip--;
			}
		}

		public static void MolotovDamage(Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (Client.objects.Length > num)
			{
				if (Client.objects[num] is TrackedItemData trackedItemData)
				{
					if (trackedItemData.controller == Client.singleton.ID)
					{
						if ((Object)(object)trackedItemData.physicalItem != (Object)null)
						{
							MolotovPatch.damageSkip++;
							FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
							((Molotov)((physicalItem is Molotov) ? physicalItem : null)).Damage(val);
							MolotovPatch.damageSkip--;
						}
					}
					else
					{
						ClientSend.MolotovDamage(num, val);
					}
				}
				else
				{
					ClientSend.MolotovDamage(num, val);
				}
			}
			else
			{
				ClientSend.MolotovDamage(num, val);
			}
		}

		public static void MagazineAddRound(Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				MagazinePatch.addRoundSkip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((FVRFireArmMagazine)((physicalItem is FVRFireArmMagazine) ? physicalItem : null)).AddRound(val, true, true);
				MagazinePatch.addRoundSkip--;
			}
		}

		public static void ClipAddRound(Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				ClipPatch.addRoundSkip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((FVRFireArmClip)((physicalItem is FVRFireArmClip) ? physicalItem : null)).AddRound(val, true, true);
				ClipPatch.addRoundSkip--;
			}
		}

		public static void SpeedloaderChamberLoad(Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int index = packet.ReadByte();
				if (Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					SpeedloaderChamberPatch.loadSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((Speedloader)((physicalItem is Speedloader) ? physicalItem : null)).Chambers[index].Load(val, true);
					SpeedloaderChamberPatch.loadSkip--;
				}
			}
		}

		public static void RemoteGunChamber(Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				FireArmRoundType val2 = (FireArmRoundType)packet.ReadShort();
				if (Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					FVRFireArmRound component = ((AnvilAsset)AM.GetRoundSelfPrefab(val2, val)).GetGameObject().GetComponent<FVRFireArmRound>();
					RemoteGunPatch.chamberSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((RemoteGun)((physicalItem is RemoteGun) ? physicalItem : null)).ChamberCartridge(component);
					RemoteGunPatch.chamberSkip--;
				}
			}
		}

		public static void ChamberRound(Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				FireArmRoundClass roundClass = (FireArmRoundClass)packet.ReadShort();
				int chamberIndex = packet.ReadByte();
				if (Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.chamberRound != null)
				{
					trackedItemData.physicalItem.chamberRound(roundClass, (FireArmRoundType)(-1), chamberIndex);
				}
			}
		}

		public static void MagazineLoad(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Client.objects.Length <= num || Client.objects.Length <= num2)
			{
				return;
			}
			short num3 = packet.ReadShort();
			TrackedItemData trackedItemData = Client.objects[num] as TrackedItemData;
			TrackedItemData trackedItemData2 = Client.objects[num2] as TrackedItemData;
			if (trackedItemData != null && trackedItemData2 != null && trackedItemData2.controller == GameManager.ID && (Object)(object)trackedItemData2.physicalItem != (Object)null && (Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				if (num3 == -1)
				{
					MagazinePatch.loadSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					? val = ((physicalItem is FVRFireArmMagazine) ? physicalItem : null);
					FVRPhysicalObject physicalItem2 = trackedItemData2.physicalItem.physicalItem;
					((FVRFireArmMagazine)val).Load((FVRFireArm)(object)((physicalItem2 is FVRFireArm) ? physicalItem2 : null));
					MagazinePatch.loadSkip--;
				}
				else
				{
					MagazinePatch.loadSkip++;
					FVRPhysicalObject physicalItem3 = trackedItemData.physicalItem.physicalItem;
					? val2 = ((physicalItem3 is FVRFireArmMagazine) ? physicalItem3 : null);
					FVRPhysicalObject physicalItem4 = trackedItemData2.physicalItem.physicalItem;
					((FVRFireArmMagazine)val2).LoadIntoSecondary((FVRFireArm)(object)((physicalItem4 is FVRFireArm) ? physicalItem4 : null), (int)num3);
					MagazinePatch.loadSkip--;
				}
			}
		}

		public static void MagazineLoadAttachable(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects.Length > num2)
			{
				TrackedItemData trackedItemData = Client.objects[num] as TrackedItemData;
				TrackedItemData trackedItemData2 = Client.objects[num2] as TrackedItemData;
				if (trackedItemData != null && trackedItemData2 != null && trackedItemData2.controller == GameManager.ID && (Object)(object)trackedItemData2.physicalItem != (Object)null && (Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					MagazinePatch.loadSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					? val = ((physicalItem is FVRFireArmMagazine) ? physicalItem : null);
					Object dataObject = trackedItemData2.physicalItem.dataObject;
					((FVRFireArmMagazine)val).Load((AttachableFirearm)(object)((dataObject is AttachableFirearm) ? dataObject : null));
					MagazinePatch.loadSkip--;
				}
			}
		}

		public static void ClipLoad(Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects.Length > num2)
			{
				TrackedItemData trackedItemData = Client.objects[num] as TrackedItemData;
				TrackedItemData trackedItemData2 = Client.objects[num2] as TrackedItemData;
				if (trackedItemData != null && trackedItemData2 != null && trackedItemData2.controller == GameManager.ID && (Object)(object)trackedItemData2.physicalItem != (Object)null && (Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					ClipPatch.loadSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					? val = ((physicalItem is FVRFireArmClip) ? physicalItem : null);
					FVRPhysicalObject physicalItem2 = trackedItemData2.physicalItem.physicalItem;
					((FVRFireArmClip)val).Load((FVRFireArm)(object)((physicalItem2 is FVRFireArm) ? physicalItem2 : null));
					ClipPatch.loadSkip--;
				}
			}
		}

		public static void RevolverCylinderLoad(Packet packet)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			int num2 = packet.ReadByte();
			List<short> list = new List<short>();
			for (int i = 0; i < num2; i++)
			{
				list.Add(packet.ReadShort());
			}
			if (trackedItemData.controller != GameManager.ID || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
			Revolver val = (Revolver)(object)((physicalItem is Revolver) ? physicalItem : null);
			ChamberPatch.chamberSkip++;
			for (int j = 0; j < val.Chambers.Length; j++)
			{
				if (list[j] != -1)
				{
					val.Chambers[j].SetRound((FireArmRoundClass)list[j], ((Component)val.Chambers[j]).transform.position, ((Component)val.Chambers[j]).transform.rotation);
				}
			}
			ChamberPatch.chamberSkip--;
		}

		public static void RevolvingShotgunLoad(Packet packet)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			int num2 = packet.ReadByte();
			List<short> list = new List<short>();
			for (int i = 0; i < num2; i++)
			{
				list.Add(packet.ReadShort());
			}
			if (trackedItemData.controller != 0 || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
			RevolvingShotgun val = (RevolvingShotgun)(object)((physicalItem is RevolvingShotgun) ? physicalItem : null);
			if (val.CylinderLoaded)
			{
				return;
			}
			val.CylinderLoaded = true;
			((Component)val.ProxyCylinder).gameObject.SetActive(true);
			((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
			val.CurChamber = 0;
			val.ProxyCylinder.localRotation = val.GetLocalRotationFromCylinder(0);
			ChamberPatch.chamberSkip++;
			for (int j = 0; j < val.Chambers.Length; j++)
			{
				if (list[j] == -1)
				{
					val.Chambers[j].Unload();
				}
				else
				{
					val.Chambers[j].Autochamber((FireArmRoundClass)list[j]);
				}
				val.Chambers[j].UpdateProxyDisplay();
			}
			ChamberPatch.chamberSkip--;
		}

		public static void GrappleGunLoad(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			int num2 = packet.ReadByte();
			List<short> list = new List<short>();
			for (int i = 0; i < num2; i++)
			{
				list.Add(packet.ReadShort());
			}
			if (trackedItemData.controller != 0 || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
			GrappleGun val = (GrappleGun)(object)((physicalItem is GrappleGun) ? physicalItem : null);
			if (val.IsMagLoaded)
			{
				return;
			}
			val.IsMagLoaded = true;
			val.ProxyMag.gameObject.SetActive(true);
			((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
			val.m_curChamber = 0;
			ChamberPatch.chamberSkip++;
			for (int j = 0; j < val.Chambers.Length; j++)
			{
				if (list[j] == -1)
				{
					val.Chambers[j].Unload();
				}
				else
				{
					val.Chambers[j].Autochamber((FireArmRoundClass)list[j]);
				}
				val.Chambers[j].UpdateProxyDisplay();
			}
			ChamberPatch.chamberSkip--;
		}

		public static void CarlGustafLatchSate(Packet packet)
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Invalid comparison between Unknown and I4
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			byte b = packet.ReadByte();
			byte b2 = packet.ReadByte();
			if (trackedItemData.controller != GameManager.ID || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
			CarlGustafLatch val = ((CarlGustaf)((physicalItem is CarlGustaf) ? physicalItem : null)).TailLatch;
			if (b == 1)
			{
				val = val.RestrictingLatch;
			}
			CarlGustafLatchPatch.skip++;
			if (b2 == 0)
			{
				if ((int)val.LState > 0)
				{
					float num2 = (val.m_tarRot = (val.m_curRot = (val.IsMinOpen ? val.RotMax : val.RotMin)));
					((Component)val).transform.localEulerAngles = new Vector3(0f, num2, 0f);
					val.LState = (CGLatchState)0;
				}
			}
			else if ((int)val.LState != 2)
			{
				float num3 = (val.m_tarRot = (val.m_curRot = (val.IsMinOpen ? val.RotMin : val.RotMax)));
				((Component)val).transform.localEulerAngles = new Vector3(0f, num3, 0f);
				val.LState = (CGLatchState)2;
			}
			CarlGustafLatchPatch.skip--;
		}

		public static void CarlGustafShellSlideSate(Packet packet)
		{
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Invalid comparison between Unknown and I4
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			byte b = packet.ReadByte();
			if (trackedItemData.controller != GameManager.ID || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
			CarlGustaf val = (CarlGustaf)(object)((physicalItem is CarlGustaf) ? physicalItem : null);
			CarlGustafShellInsertEjectPatch.skip++;
			if (b == 0)
			{
				if ((int)val.ShellInsertEject.CSState > 0)
				{
					val.ShellInsertEject.m_curZ = val.ShellInsertEject.ChamberPoint_Forward.localPosition.z;
					val.ShellInsertEject.m_tarZ = val.ShellInsertEject.ChamberPoint_Forward.localPosition.z;
					((Component)val.Chamber).transform.localPosition = new Vector3(((Component)val.Chamber).transform.localPosition.x, ((Component)val.Chamber).transform.localPosition.y, val.ShellInsertEject.ChamberPoint_Forward.localPosition.z);
					val.ShellInsertEject.CSState = (ChamberSlideState)0;
				}
			}
			else if ((int)val.ShellInsertEject.CSState != 2)
			{
				val.ShellInsertEject.m_curZ = val.ShellInsertEject.ChamberPoint_Back.localPosition.z;
				val.ShellInsertEject.m_tarZ = val.ShellInsertEject.ChamberPoint_Back.localPosition.z;
				((Component)val.Chamber).transform.localPosition = new Vector3(((Component)val.Chamber).transform.localPosition.x, ((Component)val.Chamber).transform.localPosition.y, val.ShellInsertEject.ChamberPoint_Back.localPosition.z);
				val.ShellInsertEject.CSState = (ChamberSlideState)2;
			}
			CarlGustafShellInsertEjectPatch.skip--;
		}

		public static void TNHHostStartHold(Packet packet)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num && Mod.currentTNHInstance.controller == GameManager.ID && (Object)(object)Mod.currentTNHInstance.manager != (Object)null && !Mod.currentTNHInstance.holdOngoing)
			{
				GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].SpawnPoint_SystemNode.position, true);
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasActivated = true;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasInitiatedHold = true;
				Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].BeginHoldChallenge();
			}
		}

		public static void GrappleAttached(Packet packet)
		{
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			byte[] additionalData = packet.ReadBytes(packet.ReadShort());
			if (!(Client.objects[num] is TrackedItemData trackedItemData) || trackedItemData.controller == GameManager.ID)
			{
				return;
			}
			trackedItemData.additionalData = additionalData;
			if (!((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
			GrappleThrowable val = (GrappleThrowable)(object)((physicalItem is GrappleThrowable) ? physicalItem : null);
			((FVRPhysicalObject)val).RootRigidbody.isKinematic = true;
			val.m_isRopeFree = true;
			val.BundledRope.SetActive(false);
			val.m_hasBeenThrown = true;
			val.m_hasLanded = true;
			if (val.m_ropeLengths.Count > 0)
			{
				for (int num2 = val.m_ropeLengths.Count - 1; num2 >= 0; num2--)
				{
					Object.Destroy((Object)(object)val.m_ropeLengths[num2]);
				}
				val.m_ropeLengths.Clear();
			}
			val.finalRopePoints.Clear();
			val.FakeRopeLength.SetActive(false);
			int num3 = trackedItemData.additionalData[1];
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(BitConverter.ToSingle(trackedItemData.additionalData, 2), BitConverter.ToSingle(trackedItemData.additionalData, 6), BitConverter.ToSingle(trackedItemData.additionalData, 10));
			Vector3 val3 = default(Vector3);
			for (int i = 1; i < num3; i++)
			{
				((Vector3)(ref val3))..ctor(BitConverter.ToSingle(trackedItemData.additionalData, i * 12 + 2), BitConverter.ToSingle(trackedItemData.additionalData, i * 12 + 6), BitConverter.ToSingle(trackedItemData.additionalData, i * 12 + 10));
				Vector3 val4 = val3 - val2;
				GameObject val5 = Object.Instantiate<GameObject>(val.RopeLengthPrefab, val3, Quaternion.LookRotation(-val4, Vector3.up));
				val5.transform.localScale = new Vector3(1f, 1f, ((Vector3)(ref val4)).magnitude);
				FVRHandGrabPoint val6 = null;
				if (val.m_ropeLengths.Count > 0)
				{
					val6 = val.m_ropeLengths[val.m_ropeLengths.Count - 1].GetComponent<FVRHandGrabPoint>();
				}
				FVRHandGrabPoint component = val5.GetComponent<FVRHandGrabPoint>();
				val.m_ropeLengths.Add(val5);
				if ((Object)(object)val6 != (Object)null && (Object)(object)component != (Object)null)
				{
					val6.ConnectedGrabPoint_Base = component;
					component.ConnectedGrabPoint_End = val6;
				}
				val.finalRopePoints.Add(val3);
				val2 = val3;
			}
		}

		public static void RegisterCustomPacketType(Packet packet)
		{
			string text = packet.ReadString();
			int num = packet.ReadInt();
			if (Mod.registeredCustomPacketIDs.TryGetValue(text, out var value))
			{
				Mod.LogError("Server sent for " + text + " custom packet handler to be registered at " + num + " but this ID already exists at " + value + ".");
				return;
			}
			if (num >= Mod.customPacketHandlers.Length)
			{
				int num2 = num - num % 10 + 10;
				Mod.CustomPacketHandler[] customPacketHandlers = Mod.customPacketHandlers;
				Mod.customPacketHandlers = new Mod.CustomPacketHandler[num2];
				for (int i = 0; i < customPacketHandlers.Length; i++)
				{
					Mod.customPacketHandlers[i] = customPacketHandlers[i];
				}
			}
			Mod.registeredCustomPacketIDs.Add(text, num);
			Mod.CustomPacketHandlerReceivedInvoke(text, num);
		}

		public static void BreakableGlassDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			Damage val = packet.ReadDamage();
			if (!(Client.objects[num] is TrackedBreakableGlassData trackedBreakableGlassData))
			{
				return;
			}
			if (trackedBreakableGlassData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedBreakableGlassData.damager != (Object)null)
				{
					BreakableGlassDamagerPatch.damageSkip++;
					trackedBreakableGlassData.damager.Damage(val);
					BreakableGlassDamagerPatch.damageSkip--;
				}
			}
			else
			{
				ClientSend.BreakableGlassDamage(packet);
			}
		}

		public static void WindowShatterSound(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				int mode = packet.ReadByte();
				if (Client.objects[num] is TrackedBreakableGlassData trackedBreakableGlassData && (Object)(object)trackedBreakableGlassData.physicalBreakableGlass != (Object)null)
				{
					trackedBreakableGlassData.physicalBreakableGlass.PlayerShatterAudio(mode);
				}
			}
		}

		public static void SpectatorHostAssignment(Packet packet)
		{
			int num = packet.ReadInt();
			int spectatorHostControlledBy = packet.ReadInt();
			bool reassignment = packet.ReadBool();
			if (num == GameManager.ID)
			{
				if (GameManager.spectatorHost)
				{
					GameManager.spectatorHostControlledBy = spectatorHostControlledBy;
				}
			}
			else
			{
				Mod.OnSpectatorHostReceivedInvoke(num, reassignment);
			}
		}

		public static void GiveUpSpectatorHost(Packet packet)
		{
			Mod.OnSpectatorHostGiveUpInvoke();
		}

		public static void SpectatorHostOrderTNHHost(Packet packet)
		{
			if (GameManager.spectatorHost && GameManager.spectatorHostControlledBy != -1)
			{
				if (GameManager.sceneLoading)
				{
					Mod.spectatorHostWaitingForTNHSetup = true;
					Mod.TNHRequestHostOnDeathSpectate = packet.ReadBool();
				}
				else if (GameManager.scene.Equals("TakeAndHold_Lobby_2"))
				{
					Mod.OnTNHHostClicked();
					Mod.TNHOnDeathSpectate = packet.ReadBool();
					Mod.OnTNHHostConfirmClicked();
					Mod.spectatorHostWaitingForTNHInstance = true;
					Mod.spectatorHostWaitingForTNHSetup = false;
				}
				else if (GameManager.scene.Equals("MainMenu3"))
				{
					SteamVR_LoadLevel.Begin("TakeAndHold_Lobby_2", false, 0.5f, 0f, 0f, 0f, 1f);
					Mod.spectatorHostWaitingForTNHSetup = true;
				}
				else
				{
					SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
					Mod.spectatorHostWaitingForTNHSetup = true;
				}
			}
		}

		public static void TNHSpectatorHostReady(Packet packet)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (GameManager.controlledSpectatorHost != -1 && GameManager.TNHInstances.TryGetValue(num, out var _) && Mod.waitingForTNHHost)
			{
				if ((Object)(object)Mod.TNHMenu != (Object)null)
				{
					Mod.TNHHostedInstance = num;
					Mod.TNHMenuPages[6].SetActive(false);
					Mod.TNHMenuPages[2].SetActive(true);
					Mod.TNHStatusText.text = "Setting up as Client";
					((Graphic)Mod.TNHStatusText).color = Color.blue;
				}
				else
				{
					Mod.waitingForTNHHost = false;
				}
			}
		}

		public static void SpectatorHostStartTNH(Packet packet)
		{
			if (GameManager.spectatorHost && !GameManager.sceneLoading && GameManager.scene.Equals("TakeAndHold_Lobby_2") && Mod.currentTNHInstance != null && Mod.currentTNHInstance.playerIDs.Count > 0 && Mod.currentTNHInstance.playerIDs[0] == GameManager.ID && (Object)(object)Mod.currentTNHSceneLoader != (Object)null)
			{
				Mod.currentTNHSceneLoader.Load();
			}
		}

		public static void UnassignSpectatorHost(Packet packet)
		{
			if (!GameManager.spectatorHost)
			{
				return;
			}
			GameManager.spectatorHostControlledBy = -1;
			if (!GameManager.sceneLoading)
			{
				if (!GameManager.scene.Equals("MainMenu3"))
				{
					SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
				}
			}
			else
			{
				GameManager.resetSpectatorHost = true;
			}
		}

		public static void ReactiveSteelTargetDamage(Packet packet)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int index = packet.ReadInt();
			float num2 = packet.ReadInt();
			float num3 = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			Vector3 val2 = packet.ReadVector3();
			bool flag = packet.ReadBool();
			Vector3 val3 = Vector3.zero;
			Quaternion val4 = Quaternion.identity;
			float num4 = 0f;
			if (flag)
			{
				val3 = packet.ReadVector3();
				val4 = packet.ReadQuaternion();
				num4 = packet.ReadFloat();
			}
			if (!(Client.objects[num] is TrackedItemData trackedItemData) || !((Object)(object)trackedItemData.physicalItem != (Object)null))
			{
				return;
			}
			object obj = trackedItemData.physicalItem.getSecondary(index);
			ReactiveSteelTarget val5 = (ReactiveSteelTarget)((obj is ReactiveSteelTarget) ? obj : null);
			if (!((Object)(object)val5 != (Object)null))
			{
				return;
			}
			if (val5.BulletHolePrefabs.Length != 0 && flag)
			{
				if (val5.m_currentHoles.Count > val5.MaxHoles)
				{
					val5.holeindex++;
					if (val5.holeindex > val5.MaxHoles - 1)
					{
						val5.holeindex = 0;
					}
					val5.m_currentHoles[val5.holeindex].transform.position = val3;
					val5.m_currentHoles[val5.holeindex].transform.rotation = val4;
					val5.m_currentHoles[val5.holeindex].transform.localScale = new Vector3(num4, num4, num4);
				}
				else
				{
					GameObject val6 = Object.Instantiate<GameObject>(val5.BulletHolePrefabs[Random.Range(0, val5.BulletHolePrefabs.Length)], val3, val4);
					val6.transform.SetParent(((Component)val5).transform);
					val6.transform.localScale = new Vector3(num4, num4, num4);
					val5.m_currentHoles.Add(val6);
				}
			}
			if (trackedItemData.controller == GameManager.ID && val5.m_hasRB && val5.AddForceJuice)
			{
				float num5 = Mathf.Clamp(num3 * 0.01f, 0f, val5.MaxForceImpulse);
				Debug.DrawLine(val, val + val2 * num5, Color.red, 40f);
				val5.rb.AddForceAtPosition(val2 * num5, val, (ForceMode)1);
			}
			val5.PlayHitSound(Mathf.Clamp(num2 * 0.0025f, 0.05f, 1f));
		}

		public static void MTUTest(Packet packet)
		{
			Mod.LogWarning("Received MTU test packet from server");
		}

		public static void IDConfirm(Packet packet)
		{
			int num = packet.ReadInt();
			Mod.LogInfo("Client received IDConfirm for " + num);
			if (Client.objects.Length > num)
			{
				TrackedObjectData trackedObjectData = Client.objects[num];
				if (trackedObjectData != null)
				{
					trackedObjectData.awaitingInstantiation = false;
					if ((Object)(object)trackedObjectData.physical != (Object)null)
					{
						trackedObjectData.removeFromListOnDestroy = true;
						trackedObjectData.physical.sendDestroy = false;
						trackedObjectData.physical.dontGiveControl = true;
						TrackedObject[] componentsInChildren = ((Component)trackedObjectData.physical).GetComponentsInChildren<TrackedObject>();
						for (int i = 0; i < componentsInChildren.Length; i++)
						{
							if ((Object)(object)componentsInChildren[i] != (Object)null)
							{
								componentsInChildren[i].sendDestroy = false;
								componentsInChildren[i].data.removeFromListOnDestroy = true;
								componentsInChildren[i].dontGiveControl = true;
							}
						}
						trackedObjectData.physical.SecondaryDestroy();
						Object.Destroy((Object)(object)((Component)trackedObjectData.physical).gameObject);
					}
					else
					{
						if (trackedObjectData.localTrackedID != -1)
						{
							trackedObjectData.RemoveFromLocal();
						}
						trackedObjectData.RemoveFromLists();
					}
				}
			}
			ClientSend.IDConfirm(num);
		}

		public static void EnforcePlayerModels(Packet packet)
		{
		}

		public static void ObjectScene(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			string text = packet.ReadString();
			if (Mod.trackedObjectTypesByName.TryGetValue(text, out var value))
			{
				TrackedObjectData trackedObjectData = (TrackedObjectData)Activator.CreateInstance(value, packet, text, num);
				if (Client.objects[num] != null)
				{
					Client.objects[num].SetScene(trackedObjectData.scene, send: false);
				}
				else
				{
					Client.AddTrackedObject(trackedObjectData);
				}
			}
		}

		public static void ObjectInstance(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			string text = packet.ReadString();
			if (Mod.trackedObjectTypesByName.TryGetValue(text, out var value))
			{
				TrackedObjectData trackedObjectData = (TrackedObjectData)Activator.CreateInstance(value, packet, text, num);
				if (Client.objects[num] != null)
				{
					Client.objects[num].SetInstance(trackedObjectData.instance, send: false);
				}
				else
				{
					Client.AddTrackedObject(trackedObjectData);
				}
			}
		}

		public static void UpdateEncryptionDisplay(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			int num2 = packet.ReadInt();
			if (!(Client.objects[num] is TrackedEncryptionData trackedEncryptionData))
			{
				return;
			}
			trackedEncryptionData.numHitsLeft = num2;
			if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				trackedEncryptionData.physicalEncryption.physicalEncryption.m_numHitsLeft = num2;
				if (trackedEncryptionData.physicalEncryption.physicalEncryption.UsesMultipleDisplay && trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList.Count > num2 && (Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList[num2] != (Object)null)
				{
					EncryptionPatch.updateDisplaySkip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.UpdateDisplay();
					EncryptionPatch.updateDisplaySkip--;
				}
			}
		}

		public static void RoundDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			Damage val = packet.ReadDamage();
			if (!(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((FVRFireArmRound)((physicalItem is FVRFireArmRound) ? physicalItem : null)).Damage(val);
				}
			}
			else
			{
				ClientSend.RoundDamage(num, val);
			}
		}

		public static void RoundSplode(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physical != (Object)null)
			{
				float num2 = packet.ReadFloat();
				bool flag = packet.ReadBool();
				RoundPatch.splodeSkip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((FVRFireArmRound)((physicalItem is FVRFireArmRound) ? physicalItem : null)).Splode(num2, flag, false);
				RoundPatch.splodeSkip--;
			}
		}

		public static void ConnectionComplete(Packet packet)
		{
			Client.isFullyConnected = true;
			Mod.OnConnectionInvoke();
		}

		public static void SightFlipperState(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			TrackedObjectData trackedObjectData = Client.objects[num];
			if (trackedObjectData != null && Object.op_Implicit((Object)(object)trackedObjectData.physical))
			{
				int num2 = packet.ReadInt();
				AR15HandleSightFlipper[] componentsInChildren = ((Component)trackedObjectData.physical).GetComponentsInChildren<AR15HandleSightFlipper>();
				if (componentsInChildren.Length > num2)
				{
					componentsInChildren[num2].m_isLargeAperture = packet.ReadBool();
				}
			}
		}

		public static void SightRaiserState(Packet packet)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected I4, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			TrackedObjectData trackedObjectData = Client.objects[num];
			if (trackedObjectData == null || !Object.op_Implicit((Object)(object)trackedObjectData.physical))
			{
				return;
			}
			int num2 = packet.ReadInt();
			AR15HandleSightRaiser[] componentsInChildren = ((Component)trackedObjectData.physical).GetComponentsInChildren<AR15HandleSightRaiser>();
			if (componentsInChildren.Length > num2)
			{
				SightHeights val = (SightHeights)packet.ReadByte();
				SightHeights val2 = val;
				switch ((int)val2)
				{
				case 1:
					componentsInChildren[num2].height = (SightHeights)1;
					componentsInChildren[num2].m_sightHeight = 0.25f;
					break;
				case 2:
					componentsInChildren[num2].height = (SightHeights)2;
					componentsInChildren[num2].m_sightHeight = 0.5f;
					break;
				case 3:
					componentsInChildren[num2].height = (SightHeights)3;
					componentsInChildren[num2].m_sightHeight = 0.75f;
					break;
				case 4:
					componentsInChildren[num2].height = (SightHeights)4;
					componentsInChildren[num2].m_sightHeight = 1f;
					break;
				case 0:
					componentsInChildren[num2].height = (SightHeights)0;
					componentsInChildren[num2].m_sightHeight = 0f;
					break;
				}
			}
		}

		public static void GatlingGunFire(Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			Vector3 val = packet.ReadVector3();
			Quaternion val2 = packet.ReadQuaternion();
			Vector3 val3 = packet.ReadVector3();
			TrackedObjectData trackedObjectData = Client.objects[num];
			if (trackedObjectData != null && Object.op_Implicit((Object)(object)trackedObjectData.physical))
			{
				wwGatlingGun physicalGatlingGun = (trackedObjectData as TrackedGatlingGunData).physicalGatlingGun.physicalGatlingGun;
				MuzzleFireType val4 = physicalGatlingGun.MuzzleFX[physicalGatlingGun.AmmoType];
				for (int i = 0; i < val4.MuzzleFires.Length; i++)
				{
					val4.MuzzleFires[i].Emit(val4.MuzzleFireAmounts[i]);
				}
				physicalGatlingGun.m_pool_shot.PlayClip(physicalGatlingGun.AudioClipSet.Shots_Main, physicalGatlingGun.MuzzlePos.position, (AudioMixerGroup)null);
				physicalGatlingGun.m_pool_mechanics.PlayClip(physicalGatlingGun.AudioClipSet.HammerHit, physicalGatlingGun.MuzzlePos.position, (AudioMixerGroup)null);
				physicalGatlingGun.m_pool_tail.PlayClipPitchOverride(SM.GetTailSet(physicalGatlingGun.TailClass, GM.CurrentPlayerBody.GetCurrentSoundEnvironment()), physicalGatlingGun.MuzzlePos.position, physicalGatlingGun.AudioClipSet.TailPitchMod_Main, (AudioMixerGroup)null);
				GameObject val5 = Object.Instantiate<GameObject>(val4.ProjectilePrefab, val, val2);
				val5.GetComponent<BallisticProjectile>().Fire(val3, (FVRFireArm)null);
			}
		}

		public static void GasCuboidGout(Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			Vector3 val = packet.ReadVector3();
			Vector3 val2 = packet.ReadVector3();
			if (Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.additionalData[0] < byte.MaxValue)
			{
				byte[] additionalData = trackedItemData.additionalData;
				trackedItemData.additionalData = new byte[additionalData.Length + 24];
				for (int i = 0; i < additionalData.Length; i++)
				{
					trackedItemData.additionalData[i] = additionalData[i];
				}
				trackedItemData.additionalData[1]++;
				if (Object.op_Implicit((Object)(object)trackedItemData.physical))
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val3 = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					val3.hasGeneratedGoutYet = false;
					GasCuboidPatch.generateGoutSkip++;
					val3.GenerateGout(val, val2);
					GasCuboidPatch.generateGoutSkip--;
				}
			}
		}

		public static void GasCuboidDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physical != (Object)null)
			{
				GasCuboidDamagePatch.skip++;
				Object dataObject = trackedItemData.physicalItem.dataObject;
				((Brut_GasCuboid)((dataObject is Brut_GasCuboid) ? dataObject : null)).Damage(packet.ReadDamage());
				GasCuboidDamagePatch.skip--;
			}
		}

		public static void GasCuboidHandleDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData && trackedItemData.controller == GameManager.ID && (Object)(object)trackedItemData.physical != (Object)null)
			{
				GasCuboidHandleDamagePatch.skip++;
				Object dataObject = trackedItemData.physicalItem.dataObject;
				((Brut_GasCuboid)((dataObject is Brut_GasCuboid) ? dataObject : null)).Handle.GetComponent<Brut_GasCuboidHandle>().Damage(packet.ReadDamage());
				GasCuboidHandleDamagePatch.skip--;
			}
		}

		public static void GasCuboidDamageHandle(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedItemData trackedItemData)
			{
				trackedItemData.additionalData[0] = 1;
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					val.m_isHandleBrokenOff = true;
					val.Handle.SetActive(false);
				}
			}
		}

		public static void GasCuboidExplode(Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				Vector3 val = packet.ReadVector3();
				Vector3 val2 = packet.ReadVector3();
				bool flag = packet.ReadBool();
				if (Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val3 = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					GasCuboidPatch.explodeSkip++;
					val3.Explode(val, val2, flag);
					GasCuboidPatch.explodeSkip--;
				}
			}
		}

		public static void GasCuboidShatter(Packet packet)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				Vector3 val = packet.ReadVector3();
				Vector3 val2 = packet.ReadVector3();
				if (Client.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val3 = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					GasCuboidPatch.shatterSkip++;
					val3.Shatter(val, val2);
					GasCuboidPatch.shatterSkip--;
				}
			}
		}

		public static void FloaterDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedFloaterData trackedFloaterData && trackedFloaterData.controller == GameManager.ID && (Object)(object)trackedFloaterData.physical != (Object)null)
			{
				FloaterDamagePatch.skip++;
				trackedFloaterData.physicalFloater.physicalFloater.Damage(packet.ReadDamage());
				FloaterDamagePatch.skip--;
			}
		}

		public static void FloaterCoreDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedFloaterData trackedFloaterData && trackedFloaterData.controller == GameManager.ID && (Object)(object)trackedFloaterData.physical != (Object)null)
			{
				FloaterCoreDamagePatch.skip++;
				((Component)trackedFloaterData.physicalFloater).GetComponentInChildren<Construct_Floater_Core>().Damage(packet.ReadDamage());
				FloaterCoreDamagePatch.skip--;
			}
		}

		public static void FloaterBeginExploding(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			bool flag = packet.ReadBool();
			if (Client.objects[num] is TrackedFloaterData trackedFloaterData)
			{
				if (flag)
				{
					FloaterPatch.beginExplodingOverride = true;
					trackedFloaterData.physicalFloater.physicalFloater.BeginExploding();
					FloaterPatch.beginExplodingOverride = false;
				}
				else if (trackedFloaterData.controller == GameManager.ID)
				{
					trackedFloaterData.physicalFloater.physicalFloater.BeginExploding();
				}
			}
		}

		public static void FloaterBeginDefusing(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			bool flag = packet.ReadBool();
			if (Client.objects[num] is TrackedFloaterData trackedFloaterData)
			{
				if (flag)
				{
					FloaterPatch.beginExplodingOverride = true;
					trackedFloaterData.physicalFloater.physicalFloater.BeginDefusing();
					FloaterPatch.beginExplodingOverride = false;
				}
				else if (trackedFloaterData.controller == GameManager.ID)
				{
					trackedFloaterData.physicalFloater.physicalFloater.BeginDefusing();
				}
			}
		}

		public static void FloaterExplode(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				bool isExplosionDefuse = packet.ReadBool();
				if (Client.objects[num] is TrackedFloaterData trackedFloaterData && (Object)(object)trackedFloaterData.physicalFloater != (Object)null)
				{
					trackedFloaterData.physicalFloater.physicalFloater.isExplosionDefuse = isExplosionDefuse;
					FloaterPatch.explodeSkip++;
					trackedFloaterData.physicalFloater.physicalFloater.Explode();
					FloaterPatch.explodeSkip--;
				}
			}
		}

		public static void IrisShatter(Packet packet)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedIrisData trackedIrisData && (Object)(object)trackedIrisData.physicalIris != (Object)null)
			{
				byte index = packet.ReadByte();
				Vector3 val = packet.ReadVector3();
				Vector3 val2 = packet.ReadVector3();
				float num2 = packet.ReadFloat();
				UberShatterableShatterPatch.skip++;
				trackedIrisData.physicalIris.physicalIris.Rings[index].Shatter(val, val2, num2);
				UberShatterableShatterPatch.skip--;
			}
		}

		public static void IrisSetState(Packet packet)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num)
			{
				return;
			}
			IrisState state = (IrisState)packet.ReadByte();
			if (Client.objects[num] is TrackedIrisData trackedIrisData)
			{
				trackedIrisData.state = state;
				if ((Object)(object)trackedIrisData.physicalIris != (Object)null)
				{
					IrisPatch.stateSkip++;
					trackedIrisData.physicalIris.physicalIris.SetState(state);
					IrisPatch.stateSkip--;
				}
			}
		}

		public static void BrutBlockSystemStart(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num)
			{
				bool isNextBlock = packet.ReadBool();
				if (Client.objects[num] is TrackedBrutBlockSystemData trackedBrutBlockSystemData && (Object)(object)trackedBrutBlockSystemData.physicalBrutBlockSystem != (Object)null)
				{
					trackedBrutBlockSystemData.physicalBrutBlockSystem.physicalBrutBlockSystem.isNextBlock0 = isNextBlock;
					BrutBlockSystemPatch.startSkip++;
					trackedBrutBlockSystemData.physicalBrutBlockSystem.physicalBrutBlockSystem.TryToStartBlock();
					BrutBlockSystemPatch.startSkip--;
				}
			}
		}

		public static void BatchedPackets(Packet packet)
		{
			while (packet.UnreadLength() > 0)
			{
				int length = packet.ReadInt();
				byte[] data = packet.ReadBytes(length);
				using Packet packet2 = new Packet(data);
				int num = packet2.ReadInt();
				Client.packetHandlers[num](packet2);
			}
		}

		public static void NodeInit(Packet packet)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedNodeData trackedNodeData))
			{
				return;
			}
			trackedNodeData.points = new List<Vector3>();
			int num2 = packet.ReadByte();
			for (int i = 0; i < num2; i++)
			{
				trackedNodeData.points.Add(packet.ReadVector3());
			}
			trackedNodeData.ups = new List<Vector3>();
			int num3 = packet.ReadByte();
			for (int j = 0; j < num3; j++)
			{
				trackedNodeData.ups.Add(packet.ReadVector3());
			}
			if ((Object)(object)trackedNodeData.physicalNode != (Object)null)
			{
				trackedNodeData.physicalNode.physicalNode.initialPos = trackedNodeData.position;
				trackedNodeData.physicalNode.physicalNode.m_center = trackedNodeData.position;
				for (int k = 0; k < trackedNodeData.physicalNode.physicalNode.Cages.Count; k++)
				{
					trackedNodeData.physicalNode.physicalNode.Cages[k].SetParent((Transform)null);
				}
				trackedNodeData.physicalNode.physicalNode.UpdateCageStems();
			}
		}

		public static void NodeFire(Packet packet)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedNodeData trackedNodeData && (Object)(object)trackedNodeData.physicalNode != (Object)null)
			{
				float num2 = packet.ReadFloat();
				Vector3 val = packet.ReadVector3();
				GameObject val2 = Object.Instantiate<GameObject>(trackedNodeData.physicalNode.physicalNode.ProjPrefab, ((Component)trackedNodeData.physicalNode.physicalNode).transform.position, Quaternion.LookRotation(val));
				BallisticProjectile component = val2.GetComponent<BallisticProjectile>();
				component.Fire(300f * num2, val, (FVRFireArm)null, false);
				component.SetSource_IFF(0);
				trackedNodeData.physicalNode.physicalNode.UpdateCageStems();
			}
		}

		public static void HazeDamage(Packet packet)
		{
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedHazeData trackedHazeData && trackedHazeData.controller == GameManager.ID && (Object)(object)trackedHazeData.physical != (Object)null)
			{
				HazeDamagePatch.skip++;
				trackedHazeData.physicalHaze.physicalHaze.Damage(packet.ReadDamage());
				HazeDamagePatch.skip--;
			}
		}

		public static void EncryptionFireGun(Packet packet)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedEncryptionData trackedEncryptionData && (Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				List<float> list = new List<float>();
				int num2 = packet.ReadByte();
				for (int i = 0; i < num2; i++)
				{
					list.Add(packet.ReadFloat());
				}
				List<Vector3> list2 = new List<Vector3>();
				int num3 = packet.ReadByte();
				for (int j = 0; j < num3; j++)
				{
					list2.Add(packet.ReadVector3());
				}
				for (int k = 0; k < trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles.Count; k++)
				{
					Vector3 position = trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles[k].position;
					GameObject val = Object.Instantiate<GameObject>(trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveProjectile, position, trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles[k].rotation);
					BallisticProjectile component = val.GetComponent<BallisticProjectile>();
					component.FlightVelocityMultiplier = 0.04f;
					component.Fire(list[k], list2[k], (FVRFireArm)null, true);
				}
				if ((Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.GunShotProfile != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.PlayShotEvent(trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles[0].position);
				}
			}
		}

		public static void EncryptionNextPos(Packet packet)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedEncryptionData trackedEncryptionData && (Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				trackedEncryptionData.refractivePreviewPos = packet.ReadVector3();
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.RefractivePreview.position = trackedEncryptionData.refractivePreviewPos;
				}
			}
		}

		public static void EncryptionShieldRot(Packet packet)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length > num && Client.objects[num] is TrackedEncryptionData trackedEncryptionData && (Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				trackedEncryptionData.refractiveShieldRot = packet.ReadQuaternion();
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveShield.rotation = trackedEncryptionData.refractiveShieldRot;
				}
			}
		}

		public static void SentinelInit(Packet packet)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Client.objects.Length <= num || !(Client.objects[num] is TrackedSentinelData trackedSentinelData))
			{
				return;
			}
			if (trackedSentinelData.patrolPoints == null)
			{
				trackedSentinelData.patrolPoints = new List<Vector3>();
			}
			else
			{
				trackedSentinelData.patrolPoints.Clear();
			}
			int num2 = packet.ReadByte();
			for (int i = 0; i < num2; i++)
			{
				trackedSentinelData.patrolPoints.Add(packet.ReadVector3());
			}
			trackedSentinelData.currentPointIndex = packet.ReadByte();
			trackedSentinelData.targetPointIndex = packet.ReadByte();
			trackedSentinelData.isMovingUpIndicies = packet.ReadBool();
			if (!((Object)(object)trackedSentinelData.physical != (Object)null))
			{
				return;
			}
			if (trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints == null)
			{
				trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints = new List<Transform>();
			}
			else
			{
				for (int j = 0; j < trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints.Count; j++)
				{
					Object.Destroy((Object)(object)((Component)trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints[j]).gameObject);
				}
				trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints.Clear();
			}
			for (int k = 0; k < trackedSentinelData.patrolPoints.Count; k++)
			{
				GameObject val = new GameObject("Sentinel " + num + " patrol point " + k);
				val.transform.position = trackedSentinelData.patrolPoints[k];
				trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints.Add(val.transform);
			}
			trackedSentinelData.physicalSentinel.physicalSentinel.curPointIndex = trackedSentinelData.currentPointIndex;
			trackedSentinelData.physicalSentinel.physicalSentinel.tarPointIndex = trackedSentinelData.targetPointIndex;
			trackedSentinelData.physicalSentinel.physicalSentinel.isMovingUpIndicies = trackedSentinelData.isMovingUpIndicies;
		}

		public static void AlertSosigs(Packet packet)
		{
		}

		public static void SetModulWeaponPart(Packet packet)
		{
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Expected O, but got Unknown
			int num = packet.ReadInt();
			if (!(Client.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			string text = packet.ReadString();
			string text2 = packet.ReadString();
			string text3 = null;
			if (packet.ReadBool())
			{
				text3 = packet.ReadString();
			}
			if ((Object)(object)trackedItemData.physical == (Object)null)
			{
				List<byte> list = new List<byte>();
				int num2 = 0;
				int num3 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
				num2 += 4;
				for (int i = 0; i < num3; i++)
				{
					int num4 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					num2 += 4;
					string text4 = Encoding.ASCII.GetString(trackedItemData.additionalData, num2, num4);
					num2 += num4;
					int num5 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					num2 += 4;
					string s = Encoding.ASCII.GetString(trackedItemData.additionalData, num2, num5);
					num2 += num5;
					int num6 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					num2 += 4;
					string s2 = null;
					if (num6 > 0)
					{
						s2 = Encoding.ASCII.GetString(trackedItemData.additionalData, num2, num5);
						num2 += num6;
					}
					list.AddRange(BitConverter.GetBytes(num4));
					list.AddRange(Encoding.ASCII.GetBytes(text4));
					if (text4.Equals(text))
					{
						list.AddRange(BitConverter.GetBytes(text2.Length));
						list.AddRange(Encoding.ASCII.GetBytes(text2));
						list.AddRange(BitConverter.GetBytes(text3?.Length ?? 0));
						if (text3 != null)
						{
							list.AddRange(Encoding.ASCII.GetBytes(text3));
						}
					}
					else
					{
						list.AddRange(BitConverter.GetBytes(num5));
						list.AddRange(Encoding.ASCII.GetBytes(s));
						list.AddRange(BitConverter.GetBytes(num6));
						if (num6 > 0)
						{
							list.AddRange(Encoding.ASCII.GetBytes(s2));
						}
					}
					int num7 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					for (int j = 0; j < num7; j++)
					{
						list.Add(trackedItemData.additionalData[j + num2]);
					}
					num2 += num7;
					num2 += 4;
				}
				trackedItemData.additionalData = list.ToArray();
				return;
			}
			IDictionary dictionary = PatchController.MW_IModularWeapon_get_AllAttachmentPoints.Invoke(trackedItemData.physicalItem.dataObject, null) as IDictionary;
			ModularWeaponPartPatch.skip++;
			PatchController.MW_IModularWeapon_ConfigureModularWeaponPart.Invoke(trackedItemData.physicalItem.dataObject, new object[3]
			{
				dictionary[text],
				text2,
				false
			});
			if (text3 != null)
			{
				PatchController.MW_IModularWeapon_ApplySkin.Invoke(trackedItemData.physicalItem.dataObject, new object[2] { text, text3 });
			}
			ModularWeaponPartPatch.skip--;
			List<byte> list2 = new List<byte>();
			list2.AddRange(BitConverter.GetBytes(dictionary.Count));
			foreach (DictionaryEntry item in dictionary)
			{
				string text5 = (string)item.Key;
				string text6 = (string)PatchController.MW_ModularWeaponPartsAttachmentPoint_SelectedModularWeaponPart.GetValue(item.Value);
				list2.AddRange(BitConverter.GetBytes(text5.Length));
				list2.AddRange(Encoding.ASCII.GetBytes(text5));
				list2.AddRange(BitConverter.GetBytes(text6.Length));
				list2.AddRange(Encoding.ASCII.GetBytes(text6));
				Transform val = (Transform)PatchController.MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint.GetValue(item.Value);
				MonoBehaviour[] components = ((Component)val).GetComponents<MonoBehaviour>();
				MonoBehaviour val2 = null;
				for (int k = 0; k < components.Length; k++)
				{
					if ((object)((object)components[k]).GetType() == PatchController.MW_ModularWeaponPart || ((object)components[k]).GetType().IsSubclassOf(PatchController.MW_ModularWeaponPart))
					{
						val2 = components[k];
						break;
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					list2.AddRange(BitConverter.GetBytes(0));
				}
				else
				{
					string text7 = (string)PatchController.MW_ModularWeaponPart_SelectedModularWeaponPartSkinID.GetValue(val2);
					list2.AddRange(BitConverter.GetBytes(text7.Length));
					list2.AddRange(Encoding.ASCII.GetBytes(text7));
				}
				List<byte> list3 = new List<byte>();
				TrackedItem.AddModulPartDataInvoke(list3, text5, text6, dictionary, trackedItemData.physicalItem);
				list2.AddRange(BitConverter.GetBytes(list3.Count));
				list2.AddRange(list3);
			}
			trackedItemData.additionalData = list2.ToArray();
		}
	}
	public class ClientSend
	{
		public static Dictionary<object, byte[]> queuedPackets = new Dictionary<object, byte[]>();

		private static void ConvertToCustomID(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(BitConverter.ToInt32(new byte[4]
			{
				packet.buffer[0],
				packet.buffer[1],
				packet.buffer[2],
				packet.buffer[3]
			}, 0) * -1 - 2);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
		}

		public static void SendTCPData(Packet packet, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendTCPData: " + BitConverter.ToInt32(packet.ToArray(), 0));
			}
			packet.WriteLength();
			Client.singleton.tcp.SendData(packet);
		}

		public static void SendUDPData(Packet packet, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendUDPData: " + BitConverter.ToInt32(packet.ToArray(), 0) + " length " + packet.buffer.Count);
			}
			packet.WriteLength();
			Client.singleton.udp.SendData(packet);
		}

		public static void SendUDPDataBatched(Packet packet, object key = null, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (key == null)
			{
				key = new object();
			}
			packet.WriteLength();
			lock (queuedPackets)
			{
				queuedPackets[key] = packet.ToArray();
			}
		}

		public static void SendBatchedPackets()
		{
			List<byte[]> list = new List<byte[]>();
			lock (queuedPackets)
			{
				list.AddRange(queuedPackets.Values);
				queuedPackets.Clear();
			}
			Packet packet = new Packet(189);
			foreach (byte[] item in list)
			{
				int num = packet.Length();
				if (num > 0 && num + item.Length > 1300)
				{
					packet.WriteLength();
					Client.singleton.udp.SendData(packet);
					packet.Dispose();
					packet = new Packet(189);
				}
				packet.Write(item);
			}
			if (packet.Length() > 0)
			{
				packet.WriteLength();
				Client.singleton.udp.SendData(packet);
			}
			packet.Dispose();
		}

		public static void WelcomeReceived()
		{
			using Packet packet = new Packet(1);
			packet.Write(Client.singleton.ID);
			packet.Write(((object)Mod.config["Username"]).ToString());
			packet.Write(GameManager.scene);
			packet.Write(GameManager.instance);
			packet.Write(GM.CurrentPlayerBody.GetPlayerIFF());
			packet.Write(GameManager.colorIndex);
			SendTCPData(packet);
		}

		public static void Ping(long time)
		{
			using Packet packet = new Packet(140);
			packet.Write(time);
			SendTCPData(packet);
		}

		public static void PlayerState(Vector3 playerPos, Quaternion playerRot, Vector3 headPos, Quaternion headRot, Vector3 torsoPos, Quaternion torsoRot, Vector3 leftHandPos, Quaternion leftHandRot, Vector3 rightHandPos, Quaternion rightHandRot, float health, int maxHealth)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(2);
			packet.Write(playerPos);
			packet.Write(playerRot);
			packet.Write(headPos);
			packet.Write(headRot);
			packet.Write(torsoPos);
			packet.Write(torsoRot);
			packet.Write(leftHandPos);
			packet.Write(leftHandRot);
			packet.Write(rightHandPos);
			packet.Write(rightHandRot);
			packet.Write(health);
			packet.Write(maxHealth);
			byte[] array = ((GameManager.playerStateAddtionalDataSize == -1) ? null : new byte[GameManager.playerStateAddtionalDataSize]);
			if (array != null && array.Length != 0)
			{
				GameManager.playerStateAddtionalDataSize = array.Length;
				packet.Write((short)array.Length);
				packet.Write(array);
			}
			else
			{
				GameManager.playerStateAddtionalDataSize = 0;
				packet.Write((short)0);
			}
			SendUDPDataBatched(packet, GM.CurrentPlayerBody);
		}

		public static void PlayerIFF(int iff)
		{
			using Packet packet = new Packet(111);
			packet.Write(iff);
			SendTCPData(packet);
		}

		public static void PlayerScene(string sceneName)
		{
			using Packet packet = new Packet(3);
			packet.Write(sceneName);
			SendTCPData(packet);
		}

		public static void PlayerInstance(int instance, bool sceneLoading)
		{
			using Packet packet = new Packet(42);
			packet.Write(instance);
			packet.Write(sceneLoading);
			SendTCPData(packet);
		}

		public static void AddTNHInstance(int hostID, bool letPeopleJoin, int progressionTypeSetting, int healthModeSetting, int equipmentModeSetting, int targetModeSetting, int AIDifficultyModifier, int radarModeModifier, int itemSpawnerMode, int backpackMode, int healthMult, int sosiggunShakeReloading, int TNHSeed, string levelID)
		{
			using Packet packet = new Packet(43);
			packet.Write(hostID);
			packet.Write(letPeopleJoin);
			packet.Write(progressionTypeSetting);
			packet.Write(healthModeSetting);
			packet.Write(equipmentModeSetting);
			packet.Write(targetModeSetting);
			packet.Write(AIDifficultyModifier);
			packet.Write(radarModeModifier);
			packet.Write(itemSpawnerMode);
			packet.Write(backpackMode);
			packet.Write(healthMult);
			packet.Write(sosiggunShakeReloading);
			packet.Write(TNHSeed);
			packet.Write(levelID);
			SendTCPData(packet);
		}

		public static void AddInstance()
		{
			using Packet packet = new Packet(58);
			SendTCPData(packet);
		}

		public static void TrackedObjects()
		{
			for (int i = 0; i < GameManager.objects.Count; i++)
			{
				TrackedObjectData trackedObjectData = GameManager.objects[i];
				if (trackedObjectData.trackedID == -1)
				{
					continue;
				}
				if (trackedObjectData.Update())
				{
					trackedObjectData.latestUpdateSent = false;
					using Packet packet = new Packet(9);
					trackedObjectData.WriteToPacket(packet, incrementOrder: true, full: false);
					if (packet.buffer.Count >= 1500)
					{
						Mod.LogWarning("Update packet size for " + trackedObjectData.trackedID + " of type: " + trackedObjectData.typeIdentifier + " is above 1500 bytes");
					}
					SendUDPDataBatched(packet, trackedObjectData);
				}
				else if (!trackedObjectData.latestUpdateSent)
				{
					trackedObjectData.latestUpdateSent = true;
					ObjectUpdate(trackedObjectData);
				}
			}
		}

		public static void ObjectUpdate(TrackedObjectData objectData)
		{
			using Packet packet = new Packet(6);
			objectData.WriteToPacket(packet, incrementOrder: true, full: false);
			SendTCPData(packet);
		}

		public static void TrackedObject(TrackedObjectData trackedObject)
		{
			using Packet packet = new Packet(16);
			trackedObject.WriteToPacket(packet, incrementOrder: false, full: true);
			SendTCPData(packet);
		}

		public static void GiveObjectControl(int trackedID, int newController, List<int> debounce)
		{
			using Packet packet = new Packet(8);
			packet.Write(trackedID);
			packet.Write(newController);
			if (debounce == null || debounce.Count == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(debounce.Count);
				for (int i = 0; i < debounce.Count; i++)
				{
					packet.Write(debounce[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void DestroyObject(int trackedID, bool removeFromList = true)
		{
			using Packet packet = new Packet(5);
			packet.Write(trackedID);
			packet.Write(removeFromList);
			SendTCPData(packet);
		}

		public static void ObjectParent(int trackedID, int newParentID)
		{
			using Packet packet = new Packet(10);
			packet.Write(trackedID);
			packet.Write(newParentID);
			SendTCPData(packet);
		}

		public static void WeaponFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, List<Vector3> positions, List<Vector3> directions, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(11);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			packet.Write(chamberIndex);
			SendTCPData(packet);
		}

		public static void FlintlockWeaponBurnOffOuter(int trackedID, LoadedElementType[] loadedElementTypes, float[] loadedElementPositions, int powderAmount, bool ramRod, float num2, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(122);
			packet.Write(trackedID);
			packet.Write((byte)loadedElementTypes.Length);
			for (int i = 0; i < loadedElementTypes.Length; i++)
			{
				packet.Write((byte)loadedElementTypes[i]);
				packet.Write(loadedElementPositions[i]);
			}
			packet.Write(powderAmount);
			packet.Write(ramRod);
			packet.Write(num2);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int j = 0; j < positions.Count; j++)
				{
					packet.Write(positions[j]);
					packet.Write(directions[j]);
				}
			}
			SendTCPData(packet);
		}

		public static void FlintlockWeaponFire(int trackedID, LoadedElementType[] loadedElementTypes, float[] loadedElementPositions, int[] loadedElementPowderAmounts, bool ramRod, float num5, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_009e: 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)
			using Packet packet = new Packet(123);
			packet.Write(trackedID);
			packet.Write((byte)loadedElementTypes.Length);
			for (int i = 0; i < loadedElementTypes.Length; i++)
			{
				packet.Write((byte)loadedElementTypes[i]);
				packet.Write(loadedElementPositions[i]);
				packet.Write(loadedElementPowderAmounts[i]);
			}
			packet.Write(ramRod);
			packet.Write(num5);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int j = 0; j < positions.Count; j++)
				{
					packet.Write(positions[j]);
					packet.Write(directions[j]);
				}
			}
			SendTCPData(packet);
		}

		public static void BreakActionWeaponFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int barrelIndex, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(110);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)barrelIndex);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void DerringerFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int barrelIndex, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(121);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)barrelIndex);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void LeverActionFirearmFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, bool hammer1, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(119);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write(hammer1);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void RevolvingShotgunFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(120);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void RevolverFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(128);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void SingleActionRevolverFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(129);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void GrappleGunFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(124);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void HCBReleaseSled(int trackedID, float cookedAmount, Vector3 position, Vector3 direction)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(125);
			packet.Write(trackedID);
			packet.Write(cookedAmount);
			packet.Write(position);
			packet.Write(direction);
			SendTCPData(packet);
		}

		public static void StingerLauncherFire(int trackedID, Vector3 targetPos, Vector3 position, Quaternion rotation)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(130);
			packet.Write(trackedID);
			packet.Write(targetPos);
			packet.Write(position);
			packet.Write(rotation);
			SendTCPData(packet);
		}

		public static void SosigWeaponFire(int trackedID, float recoilMult, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(102);
			packet.Write(trackedID);
			packet.Write(recoilMult);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void LAPD2019Fire(int trackedID, int chamberIndex, FireArmRoundType roundType, FireArmRoundClass roundClass, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(105);
			packet.Write(trackedID);
			packet.Write(chamberIndex);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void LAPD2019LoadBattery(int trackedID, int batteryTrackedID)
		{
			using Packet packet = new Packet(106);
			packet.Write(trackedID);
			packet.Write(batteryTrackedID);
			SendTCPData(packet);
		}

		public static void LAPD2019ExtractBattery(int trackedID)
		{
			using Packet packet = new Packet(107);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void AttachableFirearmFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, bool firedFromInterface, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(109);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write(firedFromInterface);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void IntegratedFirearmFire(int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(15);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void SosigWeaponShatter(int trackedID)
		{
			using Packet packet = new Packet(103);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void AutoMeaterFirearmFireShot(int trackedID, Vector3 angles)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(73);
			packet.Write(trackedID);
			packet.Write(angles);
			SendTCPData(packet);
		}

		public static void PlayerDamage(int clientID, float damageMult, bool head, Damage damage)
		{
			using Packet packet = new Packet(12);
			packet.Write(clientID);
			packet.Write(damageMult);
			packet.Write(head);
			packet.Write(damage);
			SendTCPData(packet);
		}

		public static void UberShatterableShatter(int trackedID, Vector3 point, Vector3 dir, float intensity, byte[] data)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(112);
			packet.Write(trackedID);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(intensity);
			if (data == null)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(data.Length);
				packet.Write(data);
			}
			SendTCPData(packet);
		}

		public static void SosigPickUpItem(TrackedSosig trackedSosig, int itemTrackedID, bool primaryHand)
		{
			using Packet packet = new Packet(17);
			packet.Write(trackedSosig.data.trackedID);
			packet.Write(itemTrackedID);
			packet.Write(primaryHand);
			SendTCPData(packet);
		}

		public static void SosigPlaceItemIn(int sosigTrackedID, int slotIndex, int itemTrackedID)
		{
			using Packet packet = new Packet(18);
			packet.Write(sosigTrackedID);
			packet.Write(itemTrackedID);
			packet.Write(slotIndex);
			SendTCPData(packet);
		}

		public static void SosigDropSlot(int sosigTrackedID, int slotIndex)
		{
			using Packet packet = new Packet(19);
			packet.Write(sosigTrackedID);
			packet.Write(slotIndex);
			SendTCPData(packet);
		}

		public static void SosigHandDrop(int sosigTrackedID, bool primaryHand)
		{
			using Packet packet = new Packet(20);
			packet.Write(sosigTrackedID);
			packet.Write(primaryHand);
			SendTCPData(packet);
		}

		public static void SosigConfigure(int sosigTrackedID, SosigConfigTemplate config)
		{
			using Packet packet = new Packet(21);
			packet.Write(sosigTrackedID);
			packet.Write(config);
			SendTCPData(packet);
		}

		public static void SosigLinkRegisterWearable(int trackedSosigID, int linkIndex, string itemID)
		{
			using Packet packet = new Packet(22);
			packet.Write(trackedSosigID);
			packet.Write((byte)linkIndex);
			packet.Write(itemID);
			SendTCPData(packet);
		}

		public static void SosigLinkDeRegisterWearable(int trackedSosigID, int linkIndex, string itemID)
		{
			using Packet packet = new Packet(23);
			packet.Write(trackedSosigID);
			packet.Write((byte)linkIndex);
			packet.Write(itemID);
			SendTCPData(packet);
		}

		public static void SosigSetIFF(int trackedSosigID, int IFF)
		{
			using Packet packet = new Packet(24);
			packet.Write(trackedSosigID);
			packet.Write((byte)IFF);
			SendTCPData(packet);
		}

		public static void SosigSetOriginalIFF(int trackedSosigID, int IFF)
		{
			using Packet packet = new Packet(25);
			packet.Write(trackedSosigID);
			packet.Write((byte)IFF);
			SendTCPData(packet);
		}

		public static void SosigLinkDamage(int trackedSosigID, int linkIndex, Damage d)
		{
			using Packet packet = new Packet(26);
			packet.Write(trackedSosigID);
			packet.Write((byte)linkIndex);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void SosigLinkDamage(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(26);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(packet);
		}

		public static void SosigWearableDamage(int trackedSosigID, int linkIndex, int wearableIndex, Damage d)
		{
			using Packet packet = new Packet(28);
			packet.Write(trackedSosigID);
			packet.Write((byte)linkIndex);
			packet.Write((byte)wearableIndex);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void SosigWearableDamage(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(28);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(packet);
		}

		public static void SosigDamageData(TrackedSosig trackedSosig)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(27);
			packet.Write(trackedSosig.data.trackedID);
			packet.Write(trackedSosig.physicalSosig.IsStunned);
			packet.Write(trackedSosig.physicalSosig.m_stunTimeLeft);
			packet.Write((byte)trackedSosig.physicalSosig.BodyState);
			packet.Write(trackedSosig.physicalSosig.m_isOnOffMeshLink);
			packet.Write(trackedSosig.physicalSosig.Agent.autoTraverseOffMeshLink);
			packet.Write(((Behaviour)trackedSosig.physicalSosig.Agent).enabled);
			List<CharacterJoint> joints = trackedSosig.physicalSosig.m_joints;
			packet.Write((byte)joints.Count);
			for (int i = 0; i < joints.Count; i++)
			{
				if ((Object)(object)joints[i] != (Object)null)
				{
					SoftJointLimit val = joints[i].lowTwistLimit;
					packet.Write(((SoftJointLimit)(ref val)).limit);
					val = joints[i].highTwistLimit;
					packet.Write(((SoftJointLimit)(ref val)).limit);
					val = joints[i].swing1Limit;
					packet.Write(((SoftJointLimit)(ref val)).limit);
					val = joints[i].swing2Limit;
					packet.Write(((SoftJointLimit)(ref val)).limit);
				}
				else
				{
					packet.Write(0);
					packet.Write(0);
					packet.Write(0);
					packet.Write(0);
				}
			}
			packet.Write(trackedSosig.physicalSosig.m_isCountingDownToStagger);
			packet.Write(trackedSosig.physicalSosig.m_staggerAmountToApply);
			packet.Write(trackedSosig.physicalSosig.m_recoveringFromBallisticState);
			packet.Write(trackedSosig.physicalSosig.m_recoveryFromBallisticLerp);
			packet.Write(trackedSosig.physicalSosig.m_tickDownToWrithe);
			packet.Write(trackedSosig.physicalSosig.m_recoveryFromBallisticTick);
			packet.Write((byte)trackedSosig.physicalSosig.GetDiedFromIFF());
			packet.Write((byte)trackedSosig.physicalSosig.GetDiedFromClass());
			packet.Write(trackedSosig.physicalSosig.IsBlinded);
			packet.Write(trackedSosig.physicalSosig.m_blindTime);
			packet.Write(trackedSosig.physicalSosig.IsFrozen);
			packet.Write(trackedSosig.physicalSosig.m_debuffTime_Freeze);
			packet.Write(trackedSosig.physicalSosig.GetDiedFromHeadShot());
			packet.Write(trackedSosig.physicalSosig.m_timeSinceLastDamage);
			packet.Write(trackedSosig.physicalSosig.IsConfused);
			packet.Write(trackedSosig.physicalSosig.m_confusedTime);
			packet.Write(trackedSosig.physicalSosig.m_storedShudder);
			SendTCPData(packet);
		}

		public static void EncryptionDamageData(TrackedEncryption trackedEncryption)
		{
			using Packet packet = new Packet(91);
			packet.Write(trackedEncryption.data.trackedID);
			packet.Write(trackedEncryption.physicalEncryption.m_numHitsLeft);
			SendTCPData(packet);
		}

		public static void AutoMeaterHitZoneDamageData(int trackedID, AutoMeaterHitZone hitZone)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(76);
			packet.Write(trackedID);
			packet.Write((byte)hitZone.Type);
			packet.Write(hitZone.ArmorThreshold);
			packet.Write(hitZone.LifeUntilFailure);
			packet.Write(hitZone.m_isDestroyed);
			SendTCPData(packet);
		}

		public static void SosigLinkExplodes(int sosigTrackedID, int linkIndex, DamageClass damClass)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(29);
			packet.Write(sosigTrackedID);
			packet.Write((byte)linkIndex);
			packet.Write((byte)damClass);
			SendTCPData(packet);
		}

		public static void SosigDies(int sosigTrackedID, DamageClass damClass, SosigDeathType deathType)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(30);
			packet.Write(sosigTrackedID);
			packet.Write((byte)damClass);
			packet.Write((byte)deathType);
			SendTCPData(packet);
		}

		public static void SosigClear(int sosigTrackedID)
		{
			using Packet packet = new Packet(31);
			packet.Write(sosigTrackedID);
			SendTCPData(packet);
		}

		public static void SosigSetBodyState(int sosigTrackedID, SosigBodyState s)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(32);
			packet.Write(sosigTrackedID);
			packet.Write((byte)s);
			SendTCPData(packet);
		}

		public static void PlaySosigFootStepSound(int sosigTrackedID, FVRPooledAudioType audioType, Vector3 position, Vector2 vol, Vector2 pitch, float delay)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(33);
			packet.Write(sosigTrackedID);
			packet.Write((byte)audioType);
			packet.Write(position);
			packet.Write(vol);
			packet.Write(pitch);
			packet.Write(delay);
			SendTCPData(packet);
		}

		public static void SosigSpeakState(int sosigTrackedID, SosigOrder currentOrder)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(34);
			packet.Write(sosigTrackedID);
			packet.Write((byte)currentOrder);
			SendTCPData(packet);
		}

		public static void SosigSetCurrentOrder(TrackedSosigData trackedSosig, SosigOrder currentOrder)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected I4, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(35);
			packet.Write(trackedSosig.trackedID);
			packet.Write((byte)currentOrder);
			SosigOrder currentOrder2 = trackedSosig.currentOrder;
			SosigOrder val = currentOrder2;
			switch (val - 1)
			{
			case 0:
				packet.Write(trackedSosig.guardPoint);
				packet.Write(trackedSosig.guardDir);
				packet.Write(trackedSosig.hardGuard);
				break;
			case 1:
				packet.Write(trackedSosig.skirmishPoint);
				packet.Write(trackedSosig.pathToPoint);
				packet.Write(trackedSosig.assaultPoint);
				packet.Write(trackedSosig.faceTowards);
				break;
			case 2:
				packet.Write(trackedSosig.guardPoint);
				packet.Write(trackedSosig.hardGuard);
				packet.Write(trackedSosig.faceTowards);
				break;
			case 3:
			case 5:
				packet.Write(trackedSosig.wanderPoint);
				break;
			case 6:
				packet.Write(trackedSosig.assaultPoint);
				packet.Write((byte)trackedSosig.assaultSpeed);
				packet.Write(trackedSosig.faceTowards);
				break;
			case 8:
				packet.Write(trackedSosig.idleToPoint);
				packet.Write(trackedSosig.idleDominantDir);
				break;
			case 9:
				packet.Write(trackedSosig.pathToPoint);
				packet.Write(trackedSosig.pathToLookDir);
				break;
			}
			SendTCPData(packet);
		}

		public static void SosigVaporize(int sosigTrackedID, int iff)
		{
			using Packet packet = new Packet(36);
			packet.Write(sosigTrackedID);
			packet.Write((byte)iff);
			SendTCPData(packet);
		}

		public static void SosigRequestHitDecal(int sosigTrackedID, Vector3 point, Vector3 normal, Vector3 edgeNormal, float scale, int linkIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(37);
			packet.Write(sosigTrackedID);
			packet.Write(point);
			packet.Write(normal);
			packet.Write(edgeNormal);
			packet.Write(scale);
			packet.Write((byte)linkIndex);
			SendTCPData(packet);
		}

		public static void SosigLinkBreak(int sosigTrackedID, int linkIndex, bool isStart, DamageClass damClass)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(38);
			packet.Write(sosigTrackedID);
			packet.Write((byte)linkIndex);
			packet.Write(isStart);
			packet.Write((byte)damClass);
			SendTCPData(packet);
		}

		public static void SosigLinkSever(int sosigTrackedID, int linkIndex, DamageClass damClass, bool isPullApart)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(39);
			packet.Write(sosigTrackedID);
			packet.Write((byte)linkIndex);
			packet.Write((byte)damClass);
			packet.Write(isPullApart);
			SendTCPData(packet);
		}

		public static void UpToDateObjects(bool instantiateOnReceive, int forClient)
		{
			for (int i = 0; i < GameManager.objects.Count; i++)
			{
				using Packet packet = new Packet(40);
				TrackedObjectData trackedObjectData = GameManager.objects[i];
				if (trackedObjectData.trackedID != -1)
				{
					packet.Write(instantiateOnReceive);
					trackedObjectData.latestUpdateSent = false;
					trackedObjectData.Update(full: true);
					trackedObjectData.WriteToPacket(packet, incrementOrder: false, full: true);
					SendTCPData(packet);
				}
			}
			DoneSendingUpdaToDateObjects(forClient);
		}

		public static void DoneLoadingScene()
		{
			using Packet packet = new Packet(100);
			SendTCPData(packet);
		}

		public static void DoneSendingUpdaToDateObjects(int forClient)
		{
			using Packet packet = new Packet(101);
			packet.Write(forClient);
			SendTCPData(packet);
		}

		public static void AddTNHCurrentlyPlaying(int instance)
		{
			using Packet packet = new Packet(44);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void RemoveTNHCurrentlyPlaying(int instance)
		{
			using Packet packet = new Packet(45);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHProgression(int i, int instance)
		{
			using Packet packet = new Packet(46);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHEquipment(int i, int instance)
		{
			using Packet packet = new Packet(47);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHHealthMode(int i, int instance)
		{
			using Packet packet = new Packet(48);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHTargetMode(int i, int instance)
		{
			using Packet packet = new Packet(49);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHAIDifficulty(int i, int instance)
		{
			using Packet packet = new Packet(50);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHRadarMode(int i, int instance)
		{
			using Packet packet = new Packet(51);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHItemSpawnerMode(int i, int instance)
		{
			using Packet packet = new Packet(52);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHBackpackMode(int i, int instance)
		{
			using Packet packet = new Packet(53);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHHealthMult(int i, int instance)
		{
			using Packet packet = new Packet(54);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHSosigGunReload(int i, int instance)
		{
			using Packet packet = new Packet(55);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHSeed(int i, int instance)
		{
			using Packet packet = new Packet(56);
			packet.Write(i);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHLevelID(string levelID, int instance)
		{
			using Packet packet = new Packet(57);
			packet.Write(levelID);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SetTNHController(int instance, int ID)
		{
			using Packet packet = new Packet(59);
			packet.Write(instance);
			packet.Write(ID);
			SendTCPData(packet);
		}

		public static void TNHPlayerDied(int instance, int ID)
		{
			using Packet packet = new Packet(61);
			packet.Write(instance);
			packet.Write(ID);
			SendTCPData(packet);
		}

		public static void TNHAddTokens(int instance, int amount)
		{
			using Packet packet = new Packet(62);
			packet.Write(instance);
			packet.Write(amount);
			SendTCPData(packet);
		}

		public static void AutoMeaterSetState(int trackedID, byte state)
		{
			using Packet packet = new Packet(69);
			packet.Write(trackedID);
			packet.Write(state);
			SendTCPData(packet);
		}

		public static void AutoMeaterSetBladesActive(int trackedID, bool active)
		{
			using Packet packet = new Packet(70);
			packet.Write(trackedID);
			packet.Write(active);
			SendTCPData(packet);
		}

		public static void AutoMeaterDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(71);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void AutoMeaterDamage(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(71);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(packet);
		}

		public static void AutoMeaterFirearmFireAtWill(int trackedID, int firearmIndex, bool fireAtWill, float dist)
		{
			using Packet packet = new Packet(74);
			packet.Write(trackedID);
			packet.Write(firearmIndex);
			packet.Write(fireAtWill);
			packet.Write(dist);
			SendTCPData(packet);
		}

		public static void AutoMeaterHitZoneDamage(int trackedID, AMHitZoneType type, Damage d)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(75);
			packet.Write(trackedID);
			packet.Write((byte)type);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void AutoMeaterHitZoneDamage(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(75);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(packet);
		}

		public static void EncryptionDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(90);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void EncryptionDamage(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(90);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(packet);
		}

		public static void TNHSosigKill(int instance, int sosigTrackedID)
		{
			using Packet packet = new Packet(77);
			packet.Write(instance);
			packet.Write(sosigTrackedID);
			SendTCPData(packet);
		}

		public static void TNHHoldPointSystemNode(int instance, int levelIndex, int holdPointIndex)
		{
			using Packet packet = new Packet(78);
			packet.Write(instance);
			packet.Write(levelIndex);
			packet.Write(holdPointIndex);
			SendTCPData(packet);
		}

		public static void TNHHoldBeginChallenge(int instance, bool controller)
		{
			using Packet packet = new Packet(79);
			Mod.LogInfo("TNHHoldBeginChallenge client send", debug: false);
			packet.Write(instance);
			packet.Write(controller);
			SendTCPData(packet);
		}

		public static void TNHHoldPointRaiseBarriers(int instance, List<int> barrierIndices, List<int> barrierPrefabIndices)
		{
			using Packet packet = new Packet(114);
			packet.Write(instance);
			if (barrierIndices == null || barrierIndices.Count == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(barrierIndices.Count);
				for (int i = 0; i < barrierIndices.Count; i++)
				{
					packet.Write(barrierIndices[i]);
				}
				for (int j = 0; j < barrierIndices.Count; j++)
				{
					packet.Write(barrierPrefabIndices[j]);
				}
			}
			SendTCPData(packet);
		}

		public static void ShatterableCrateSetHoldingHealth(int trackedID)
		{
			using Packet packet = new Packet(7);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void ShatterableCrateSetHoldingToken(int trackedID)
		{
			using Packet packet = new Packet(142);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void ShatterableCrateSetUsesLoot(int trackedID)
		{
			using Packet packet = new Packet(199);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void ShatterableCrateDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(80);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void ShatterableCrateDamage(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(80);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(packet);
		}

		public static void ShatterableCrateDestroy(int trackedID, Damage d)
		{
			using Packet packet = new Packet(98);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void TNHSetLevel(int instance, int level)
		{
			using Packet packet = new Packet(63);
			packet.Write(instance);
			packet.Write(level);
			SendTCPData(packet);
		}

		public static void TNHSetPhaseTake(int instance, int holdIndex, List<int> activeSupplyPointIndices, bool init)
		{
			using Packet packet = new Packet(81);
			packet.Write(instance);
			packet.Write(holdIndex);
			packet.Write(activeSupplyPointIndices.Count);
			foreach (int activeSupplyPointIndex in activeSupplyPointIndices)
			{
				packet.Write(activeSupplyPointIndex);
			}
			packet.Write(init);
			SendTCPData(packet);
		}

		public static void TNHSetPhaseHold(int instance)
		{
			using Packet packet = new Packet(141);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void TNHHoldCompletePhase(int instance)
		{
			using Packet packet = new Packet(82);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void TNHHoldPointFailOut(int instance)
		{
			using Packet packet = new Packet(83);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void TNHHoldPointBeginPhase(int instance)
		{
			using Packet packet = new Packet(116);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void TNHHoldPointCompleteHold(int instance)
		{
			using Packet packet = new Packet(117);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void TNHSetPhaseComplete(int instance)
		{
			using Packet packet = new Packet(84);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void TNHSetPhase(int instance, TNH_Phase p)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(85);
			packet.Write(instance);
			packet.Write((short)p);
			SendTCPData(packet);
		}

		public static void EncryptionRespawnSubTarg(int trackedID, int index)
		{
			using Packet packet = new Packet(92);
			packet.Write(trackedID);
			packet.Write(index);
			SendTCPData(packet);
		}

		public static void EncryptionRespawnSubTargGeo(int trackedID, int index)
		{
			using Packet packet = new Packet(169);
			packet.Write(trackedID);
			packet.Write(index);
			SendTCPData(packet);
		}

		public static void EncryptionSpawnGrowth(int trackedID, int index, Vector3 point)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(93);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write(point);
			SendTCPData(packet);
		}

		public static void EncryptionInit(int trackedID, List<int> indices, Vector3 initialPos, int numHitsLeft)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(94);
			packet.Write(trackedID);
			if (indices == null || indices.Count == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(indices.Count);
				for (int i = 0; i < indices.Count; i++)
				{
					packet.Write(indices[i]);
				}
			}
			packet.Write(initialPos);
			packet.Write(numHitsLeft);
			SendTCPData(packet);
		}

		public static void EncryptionResetGrowth(int trackedID, int index, Vector3 point)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(95);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write(point);
			SendTCPData(packet);
		}

		public static void EncryptionDisableSubtarg(int trackedID, int index)
		{
			using Packet packet = new Packet(96);
			packet.Write(trackedID);
			packet.Write(index);
			SendTCPData(packet);
		}

		public static void EncryptionSubDamage(int trackedID, int index, Damage d)
		{
			using Packet packet = new Packet(97);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void SosigWeaponDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(104);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void RemoteMissileDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(127);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void StingerMissileDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(131);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void TNHHoldPointBeginAnalyzing(int instance, List<Vector3> data, float tickDownToID)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(113);
			packet.Write(instance);
			packet.Write(tickDownToID);
			if (data == null || data.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)data.Count);
				foreach (Vector3 datum in data)
				{
					packet.Write(datum);
				}
			}
			SendTCPData(packet);
		}

		public static void TNHHoldIdentifyEncryption(int instance)
		{
			using Packet packet = new Packet(115);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SosigPriorityIFFChart(int trackedID, int chart)
		{
			using Packet packet = new Packet(118);
			packet.Write(trackedID);
			packet.Write(chart);
			SendTCPData(packet);
		}

		public static void RemoteMissileDetonate(int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(126);
			packet.Write(trackedID);
			packet.Write(pos);
			SendTCPData(packet);
		}

		public static void StingerMissileExplode(int trackedID, Vector3 pos)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(132);
			packet.Write(trackedID);
			packet.Write(pos);
			SendTCPData(packet);
		}

		public static void PinnedGrenadeExplode(int trackedID, Vector3 pos)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(133);
			packet.Write(trackedID);
			packet.Write(pos);
			SendTCPData(packet);
		}

		public static void PinnedGrenadePullPin(int trackedID)
		{
			using Packet packet = new Packet(152);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void FVRGrenadeExplode(int trackedID, Vector3 pos)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(134);
			packet.Write(trackedID);
			packet.Write(pos);
			SendTCPData(packet);
		}

		public static void ClientDisconnect()
		{
			using Packet packet = new Packet(135);
			packet.Write(Convert.ToInt64((DateTime.Now.ToUniversalTime() - ThreadManager.epoch).TotalMilliseconds));
			SendTCPData(packet);
		}

		public static void BangSnapSplode(int trackedID, Vector3 position)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(136);
			packet.Write(trackedID);
			packet.Write(position);
			SendTCPData(packet);
		}

		public static void C4Detonate(int trackedID, Vector3 position)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(137);
			packet.Write(trackedID);
			packet.Write(position);
			SendTCPData(packet);
		}

		public static void ClaymoreMineDetonate(int trackedID, Vector3 position)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(138);
			packet.Write(trackedID);
			packet.Write(position);
			SendTCPData(packet);
		}

		public static void SLAMDetonate(int trackedID, Vector3 position)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(139);
			packet.Write(trackedID);
			packet.Write(position);
			SendTCPData(packet);
		}

		public static void SpectatorHost(bool spectatorHost)
		{
			using Packet packet = new Packet(60);
			packet.Write(spectatorHost);
			SendTCPData(packet);
		}

		public static void ResetTNH(int instance)
		{
			using Packet packet = new Packet(143);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void ReviveTNHPlayer(int ID, int instance)
		{
			using Packet packet = new Packet(144);
			packet.Write(ID);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void PlayerColor(int ID, int index)
		{
			using Packet packet = new Packet(145);
			packet.Write(ID);
			packet.Write(index);
			SendTCPData(packet);
		}

		public static void RequestTNHInitialization(int instance)
		{
			using Packet packet = new Packet(146);
			Mod.LogInfo("Sending request for perm to init TNH " + instance, debug: false);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void TNHInitializer(int instance)
		{
			using Packet packet = new Packet(147);
			Mod.LogInfo("Sending TNH " + instance + " init signal", debug: false);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void FuseIgnite(int trackedID)
		{
			using Packet packet = new Packet(148);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void FuseBoom(int trackedID)
		{
			using Packet packet = new Packet(149);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void MolotovShatter(int trackedID, bool ignited)
		{
			using Packet packet = new Packet(150);
			packet.Write(trackedID);
			packet.Write(ignited);
			SendTCPData(packet);
		}

		public static void MolotovDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(151);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void MagazineAddRound(int trackedID, FireArmRoundClass roundClass)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(153);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			SendTCPData(packet);
		}

		public static void ClipAddRound(int trackedID, FireArmRoundClass roundClass)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(154);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			SendTCPData(packet);
		}

		public static void RemoteGunChamber(int trackedID, FireArmRoundClass roundClass, FireArmRoundType roundType)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(13);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			packet.Write((short)roundType);
			SendTCPData(packet);
		}

		public static void SpeedloaderChamberLoad(int trackedID, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(41);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			packet.Write((byte)chamberIndex);
			SendTCPData(packet);
		}

		public static void ChamberRound(int trackedID, FireArmRoundClass roundClass, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(14);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			packet.Write((byte)chamberIndex);
			SendTCPData(packet);
		}

		public static void MagazineLoad(int trackedID, int FATrackedID, int slot = -1)
		{
			using Packet packet = new Packet(86);
			packet.Write(trackedID);
			packet.Write(FATrackedID);
			packet.Write((short)slot);
			SendTCPData(packet);
		}

		public static void MagazineLoadAttachable(int trackedID, int FATrackedID)
		{
			using Packet packet = new Packet(87);
			packet.Write(trackedID);
			packet.Write(FATrackedID);
			SendTCPData(packet);
		}

		public static void ClipLoad(int trackedID, int FATrackedID)
		{
			using Packet packet = new Packet(88);
			packet.Write(trackedID);
			packet.Write(FATrackedID);
			SendTCPData(packet);
		}

		public static void RevolverCylinderLoad(int trackedID, Speedloader speedLoader)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(89);
			packet.Write(trackedID);
			packet.Write((byte)speedLoader.Chambers.Count);
			for (int i = 0; i < speedLoader.Chambers.Count; i++)
			{
				if (speedLoader.Chambers[i].IsLoaded && !speedLoader.Chambers[i].IsSpent)
				{
					packet.Write((short)speedLoader.Chambers[i].LoadedClass);
				}
				else
				{
					packet.Write((short)(-1));
				}
			}
			SendTCPData(packet);
		}

		public static void RevolvingShotgunLoad(int trackedID, Speedloader speedLoader)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(64);
			packet.Write(trackedID);
			packet.Write((byte)speedLoader.Chambers.Count);
			for (int i = 0; i < speedLoader.Chambers.Count; i++)
			{
				if (speedLoader.Chambers[i].IsLoaded && !speedLoader.Chambers[i].IsSpent)
				{
					packet.Write((short)speedLoader.Chambers[i].LoadedClass);
				}
				else
				{
					packet.Write((short)(-1));
				}
			}
			SendTCPData(packet);
		}

		public static void GrappleGunLoad(int trackedID, Speedloader speedLoader)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(65);
			packet.Write(trackedID);
			packet.Write((byte)speedLoader.Chambers.Count);
			for (int i = 0; i < speedLoader.Chambers.Count; i++)
			{
				if (speedLoader.Chambers[i].IsLoaded && !speedLoader.Chambers[i].IsSpent)
				{
					packet.Write((short)speedLoader.Chambers[i].LoadedClass);
				}
				else
				{
					packet.Write((short)(-1));
				}
			}
			SendTCPData(packet);
		}

		public static void CarlGustafLatchSate(int trackedID, CGLatchType type, CGLatchState state)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(66);
			packet.Write(trackedID);
			packet.Write((byte)type);
			packet.Write((byte)state);
			SendTCPData(packet);
		}

		public static void CarlGustafShellSlideSate(int trackedID, ChamberSlideState state)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(67);
			packet.Write(trackedID);
			packet.Write((byte)state);
			SendTCPData(packet);
		}

		public static void TNHHostStartHold(int instance)
		{
			using Packet packet = new Packet(68);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void GrappleAttached(int trackedID, byte[] data)
		{
			using Packet packet = new Packet(0);
			packet.Write(trackedID);
			packet.Write((short)data.Length);
			packet.Write(data);
			SendTCPData(packet);
		}

		public static void RegisterCustomPacketType(string ID)
		{
			using Packet packet = new Packet(99);
			packet.Write(ID);
			SendTCPData(packet);
		}

		public static void BreakableGlassDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(155);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void BreakableGlassDamage(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(155);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(packet);
		}

		public static void WindowShatterSound(int trackedID, int mode)
		{
			using Packet packet = new Packet(156);
			packet.Write(trackedID);
			packet.Write((byte)mode);
			SendTCPData(packet);
		}

		public static void RequestSpectatorHost()
		{
			using Packet packet = new Packet(157);
			SendTCPData(packet);
		}

		public static void UnassignSpectatorHost()
		{
			using Packet packet = new Packet(158);
			SendTCPData(packet);
		}

		public static void SpectatorHostOrderTNHHost(bool onDeathSpectate)
		{
			using Packet packet = new Packet(159);
			packet.Write(onDeathSpectate);
			SendTCPData(packet);
		}

		public static void TNHSpectatorHostReady(int instance)
		{
			using Packet packet = new Packet(160);
			packet.Write(instance);
			SendTCPData(packet);
		}

		public static void SpectatorHostStartTNH(int host)
		{
			using Packet packet = new Packet(161);
			packet.Write(host);
			SendTCPData(packet);
		}

		public static void ReassignSpectatorHost(List<int> debounce)
		{
			using Packet packet = new Packet(162);
			if (debounce == null)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(debounce.Count);
				for (int i = 0; i < debounce.Count; i++)
				{
					packet.Write(debounce[i]);
				}
			}
			SendTCPData(packet);
		}

		public static void ReactiveSteelTargetDamage(int trackedID, int targetIndex, float damKinetic, float damBlunt, Vector3 point, Vector3 dir, bool usesHoles, Vector3 pos, Quaternion rot, float scale)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(163);
			packet.Write(trackedID);
			packet.Write(targetIndex);
			packet.Write(damKinetic);
			packet.Write(damBlunt);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(usesHoles);
			if (usesHoles)
			{
				packet.Write(pos);
				packet.Write(rot);
				packet.Write(scale);
			}
			SendTCPData(packet);
		}

		public static void IDConfirm(int trackedID)
		{
			using Packet packet = new Packet(165);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void ObjectScene(TrackedObjectData trackedObjectData)
		{
			using Packet packet = new Packet(166);
			trackedObjectData.WriteToPacket(packet, incrementOrder: false, full: true);
			SendTCPData(packet);
		}

		public static void ObjectInstance(TrackedObjectData trackedObjectData)
		{
			using Packet packet = new Packet(167);
			trackedObjectData.WriteToPacket(packet, incrementOrder: false, full: true);
			SendTCPData(packet);
		}

		public static void UpdateEncryptionDisplay(int trackedID, int numHitsLeft)
		{
			using Packet packet = new Packet(168);
			packet.Write(trackedID);
			packet.Write(numHitsLeft);
			SendTCPData(packet);
		}

		public static void RoundDamage(int trackedID, Damage damage)
		{
			using Packet packet = new Packet(170);
			packet.Write(trackedID);
			packet.Write(damage);
			SendTCPData(packet);
		}

		public static void RoundSplode(int trackedID, float velMultiplier, bool isRandomDir)
		{
			using Packet packet = new Packet(171);
			packet.Write(trackedID);
			packet.Write(velMultiplier);
			packet.Write(isRandomDir);
			SendTCPData(packet);
		}

		public static void SightFlipperState(int trackedID, int index, bool large)
		{
			using Packet packet = new Packet(172);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write(large);
			SendTCPData(packet);
		}

		public static void SightRaiserState(int trackedID, int index, SightHeights height)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(173);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write((byte)height);
			SendTCPData(packet);
		}

		public static void GatlingGunFire(int trackedID, Vector3 pos, Quaternion rot, Vector3 dir)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(174);
			packet.Write(trackedID);
			packet.Write(pos);
			packet.Write(rot);
			packet.Write(dir);
			SendTCPData(packet);
		}

		public static void GasCuboidGout(int trackedID, Vector3 pos, Vector3 norm)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(175);
			packet.Write(trackedID);
			packet.Write(pos);
			packet.Write(norm);
			SendTCPData(packet);
		}

		public static void GasCuboidDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(176);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void GasCuboidHandleDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(177);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void GasCuboidDamageHandle(int trackedID)
		{
			using Packet packet = new Packet(178);
			packet.Write(trackedID);
			SendTCPData(packet);
		}

		public static void GasCuboidExplode(int trackedID, Vector3 point, Vector3 dir, bool big)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(179);
			packet.Write(trackedID);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(big);
			SendTCPData(packet);
		}

		public static void GasCuboidShatter(int trackedID, Vector3 point, Vector3 dir)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(180);
			packet.Write(trackedID);
			packet.Write(point);
			packet.Write(dir);
			SendTCPData(packet);
		}

		public static void FloaterDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(181);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void FloaterCoreDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(182);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(packet);
		}

		public static void FloaterBeginExploding(int trackedID, bool control)
		{
			using Packet packet = new Packet(183);
			packet.Write(trackedID);
			packet.Write(control);
			SendTCPData(packet);
		}

		public static void FloaterBeginDefusing(int trackedID, bool control)
		{
			using Packet packet = new Packet(188);
			packet.Write(trackedID);
			packet.Write(control);
			SendTCPData(packet);
		}

		public static void FloaterExplode(int trackedID, bool defusing)
		{
			using Packet packet = new Packet(184);
			packet.Write(trackedID);
			packet.Write(defusing);
			SendTCPData(packet);
		}

		public static void IrisShatter(int trackedID, byte index, Vector3 point, Vector3 dir, float intensity)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(185);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(intensity);
			SendTCPData(packet);
		}

		public static void IrisSetState(int trackedID, IrisState s)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(186);
			packet.Write(trackedID);
			packet.Write((byte)s);
			SendTCPData(packet);
		}

		public static void BrutBlockSystemStart(int trackedID, bool next)
		{
			using Packet packet = new Packet(187);
			packet.Write(trackedID);
			packet.Write(next);
			SendTCPData(packet);
		}

		public static void NodeInit(int trackedID, List<Vector3> points, List<Vector3> ups)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(190);
			packet.Write(trackedID);
			if (points == null || points.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)points.Count);
				for (int i = 0; i < points.Count; i++)
				{
					packet.Write(points[i]);
				}
			}
			if (ups == null || ups.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)ups.Count);
				for (int j = 0; j < ups.Count; j++)
				{
					packet.Write(ups[j]);
				}
			}
			SendTCPData(packet);
		}

		public static void NodeFire(int trackedID, float velMult, Vector3 firingDir)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(191);
			packet.Write(trackedID);
			packet.Write(velMult);
			packet.Write(firingDir);
			SendTCPData(packet);
		}

		public static void HazeDamage(int trackedID, Damage D)
		{
			using Packet packet = new Packet(192);
			packet.Write(trackedID);
			packet.Write(D);
			SendTCPData(packet);
		}

		public static void EncryptionFireGun(int trackedID, float[] vels, Vector3[] dirs)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(193);
			packet.Write(trackedID);
			if (vels == null || vels.Length == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)vels.Length);
				for (int i = 0; i < vels.Length; i++)
				{
					packet.Write(vels[i]);
				}
			}
			if (dirs == null || dirs.Length == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)dirs.Length);
				for (int j = 0; j < dirs.Length; j++)
				{
					packet.Write(dirs[j]);
				}
			}
			SendTCPData(packet);
		}

		public static void EncryptionNextPos(int trackedID, Vector3 previewPos)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(194);
			packet.Write(trackedID);
			packet.Write(previewPos);
			SendTCPData(packet);
		}

		public static void EncryptionShieldRot(int trackedID, Quaternion shieldRot)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(195);
			packet.Write(trackedID);
			packet.Write(shieldRot);
			SendTCPData(packet);
		}

		public static void SentinelInit(int trackedID, List<Vector3> points, int currentPointIndex, int targetPointIndex, bool movingUp)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(196);
			packet.Write(trackedID);
			if (points == null || points.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)points.Count);
				for (int i = 0; i < points.Count; i++)
				{
					packet.Write(points[i]);
				}
			}
			packet.Write((byte)currentPointIndex);
			packet.Write((byte)targetPointIndex);
			packet.Write(movingUp);
			SendTCPData(packet);
		}

		public static void AlertSosigs(string scene, int instance, Vector3 position)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(197);
			packet.Write(scene);
			packet.Write(instance);
			packet.Write(position);
			SendTCPData(packet);
		}

		public static void SetModulWeaponPart(int trackedID, string groupID, string selectedPart, string skinID)
		{
			using Packet packet = new Packet(198);
			packet.Write(trackedID);
			packet.Write(groupID);
			packet.Write(selectedPart);
			if (skinID == null)
			{
				packet.Write(_value: false);
			}
			else
			{
				packet.Write(_value: true);
				packet.Write(skinID);
			}
			SendTCPData(packet);
		}
	}
	public class Player
	{
		public int ID;

		public string username;

		public int IFF;

		public Vector3 position;

		public Quaternion rotation;

		public Vector3 headPos;

		public Quaternion headRot;

		public Vector3 torsoPos;

		public Quaternion torsoRot;

		public Vector3 leftHandPos;

		public Quaternion leftHandRot;

		public Vector3 rightHandPos;

		public Quaternion rightHandRot;

		public float health;

		public int maxHealth;

		public string scene;

		public int instance;

		public bool firstInSceneInstance;

		public int colorIndex;

		public string playerPrefabID;

		public Player(int ID, string username, Vector3 spawnPos, int IFF, int colorIndex)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			this.ID = ID;
			this.username = username;
			position = spawnPos;
			rotation = Quaternion.identity;
			this.IFF = IFF;
			this.colorIndex = colorIndex;
		}
	}
	public class ServerClient
	{
		public delegate void OnSendPostWelcomDataDelegate(int clientID);

		public delegate void OnClientDisconnectDelegate();

		public class TCP
		{
			public TcpClient socket;

			public long openTime;

			private readonly int ID;

			private NetworkStream stream;

			private Packet receivedData;

			private byte[] receiveBuffer;

			public TCP(int ID)
			{
				this.ID = ID;
			}

			public void Connect(TcpClient socket)
			{
				openTime = Convert.ToInt64((DateTime.Now.ToUniversalTime() - ThreadManager.epoch).TotalMilliseconds);
				this.socket = socket;
				socket.ReceiveBufferSize = dataBufferSize;
				socket.SendBufferSize = dataBufferSize;
				stream = socket.GetStream();
				receivedData = new Packet();
				receiveBuffer = new byte[dataBufferSize];
				stream.BeginRead(receiveBuffer, 0, dataBufferSize, ReceiveCallback, null);
				ServerSend.Welcome(ID, "Welcome to the server", GameManager.colorByIFF, GameManager.nameplateMode, GameManager.radarMode, GameManager.radarColor, GameManager.maxHealthByInstanceByScene);
			}

			public void SendData(Packet packet)
			{
				try
				{
					if (socket != null)
					{
						stream.BeginWrite(packet.ToArray(), 0, packet.Length(), null, null);
					}
				}
				catch (Exception arg)
				{
					Mod.LogError($"Error sending data to player {ID} via TCP: {arg}");
				}
			}

			private void ReceiveCallback(IAsyncResult result)
			{
				int num = 0;
				byte[] array = null;
				try
				{
					num = stream.EndRead(result);
					if (num == 0 && Server.clients[ID].connected)
					{
						Server.clients[ID].Disconnect(0);
						return;
					}
					array = new byte[num];
					Array.Copy(receiveBuffer, array, num);
					int num2 = HandleData(array);
					if (num2 > 0)
					{
						receivedData.Reset(num2 == 2);
					}
					stream.BeginRead(receiveBuffer, 0, dataBufferSize, ReceiveCallback, null);
				}
				catch (Exception ex)
				{
					if (!Server.clients[ID].connected)
					{
						return;
					}
					if (array != null)
					{
						for (int i = 0; i < num; i++)
						{
							Mod.LogWarning("data[" + i + "] = " + array[i]);
						}
					}
					Server.clients[ID].Disconnect(1, ex);
				}
			}

			private int HandleData(byte[] data)
			{
				int num = 0;
				bool flag = false;
				receivedData.SetBytes(data);
				if (receivedData.UnreadLength() >= 4)
				{
					num = receivedData.ReadInt();
					flag = true;
					if (num <= 0)
					{
						return 2;
					}
				}
				while (num > 0 && num <= receivedData.UnreadLength())
				{
					flag = false;
					byte[] packetBytes = receivedData.ReadBytes(num);
					ThreadManager.ExecuteOnMainThread(delegate
					{
						if (Server.tcpListener != null)
						{
							using (Packet packet = new Packet(packetBytes))
							{
								int num2 = packet.ReadInt();
								try
								{
									if (num2 < 0)
									{
										if (num2 == -1)
										{
											Mod.GenericCustomPacketReceivedInvoke(ID, packet.ReadString(), packet);
										}
										else
										{
											int num3 = num2 * -1 - 2;
											if (Mod.customPacketHandlers.Length > num3 && Mod.customPacketHandlers[num3] != null)
											{
												if (Input.GetKey((KeyCode)281))
												{
													Mod.LogInfo("\tHandling custom TCP packet: " + num2);
												}
												Mod.customPacketHandlers[num3](ID, packet);
											}
											else
											{
												string text = num2.ToString();
												int iD = ID;
												Mod.LogWarning("\tServer received invalid custom TCP packet ID: " + text + " from client " + iD);
											}
										}
									}
									else
									{
										if (Input.GetKey((KeyCode)281))
										{
											string[] obj = new string[8]
											{
												"\tHandling TCP packet: ",
												num2.ToString(),
												" (",
												null,
												null,
												null,
												null,
												null
											};
											ClientPackets clientPackets = (ClientPackets)num2;
											obj[3] = clientPackets.ToString();
											obj[4] = "), length: ";
											obj[5] = packet.buffer.Count.ToString();
											obj[6] = ", from client ";
											int iD = ID;
											obj[7] = iD.ToString();
											Mod.LogInfo(string.Concat(obj));
										}
										Server.packetHandlers[num2](ID, packet);
									}
								}
								catch (IndexOutOfRangeException ex)
								{
									string[] obj2 = new string[6]
									{
										"Server TCP received packet with ID: ",
										num2.ToString(),
										" as ClientPacket: ",
										null,
										null,
										null
									};
									ClientPackets clientPackets = (ClientPackets)num2;
									obj2[3] = clientPackets.ToString();
									obj2[4] = ":\n";
									obj2[5] = ex.StackTrace;
									Mod.LogError(string.Concat(obj2));
								}
							}
						}
					});
					num = 0;
					if (receivedData.UnreadLength() >= 4)
					{
						num = receivedData.ReadInt();
						flag = true;
						if (num <= 0)
						{
							return 2;
						}
					}
				}
				if (num == 0 && receivedData.UnreadLength() == 0)
				{
					return 2;
				}
				return flag ? 1 : 0;
			}

			public void Disconnect()
			{
				socket.Close();
				stream = null;
				receiveBuffer = null;
				receivedData = null;
				socket = null;
			}
		}

		public class UDP
		{
			public IPEndPoint endPoint;

			private int ID;

			public UDP(int ID)
			{
				this.ID = ID;
			}

			public void Connect(IPEndPoint endPoint)
			{
				this.endPoint = endPoint;
			}

			public void SendData(Packet packet)
			{
				Server.SendUDPData(endPoint, packet);
			}

			public void HandleData(Packet packetData)
			{
				int length = packetData.ReadInt();
				byte[] packetBytes = packetData.ReadBytes(length);
				ThreadManager.ExecuteOnMainThread(delegate
				{
					if (Server.tcpListener != null)
					{
						using (Packet packet = new Packet(packetBytes))
						{
							int num = packet.ReadInt();
							if (num < 0)
							{
								if (num == -1)
								{
									Mod.GenericCustomPacketReceivedInvoke(ID, packet.ReadString(), packet);
								}
								else
								{
									int num2 = num * -1 - 2;
									if (Mod.customPacketHandlers.Length > num2 && Mod.customPacketHandlers[num2] != null)
									{
										if (Input.GetKey((KeyCode)281))
										{
											Mod.LogInfo("\tHandling custom UDP packet: " + num);
										}
										Mod.customPacketHandlers[num2](ID, packet);
									}
									else
									{
										Mod.LogWarning("\tServer received invalid custom UDP packet ID: " + num + " from client " + ID);
									}
								}
							}
							else
							{
								if (Input.GetKey((KeyCode)281))
								{
									string[] obj = new string[8]
									{
										"\tHandling UDP packet: ",
										num.ToString(),
										" (",
										null,
										null,
										null,
										null,
										null
									};
									ClientPackets clientPackets = (ClientPackets)num;
									obj[3] = clientPackets.ToString();
									obj[4] = "), length: ";
									obj[5] = packet.buffer.Count.ToString();
									obj[6] = ", from client ";
									obj[7] = ID.ToString();
									Mod.LogInfo(string.Concat(obj));
								}
								Server.packetHandlers[num](ID, packet);
							}
							packet.Dispose();
						}
					}
				});
			}

			public void Disconnect()
			{
				endPoint = null;
			}
		}

		public static int dataBufferSize = 4096;

		public int ID;

		public Player player;

		public TCP tcp;

		public UDP udp;

		public bool connected;

		public bool attemptingPunchThrough;

		public long ping;

		public Dictionary<object, byte[]> queuedPackets = new Dictionary<object, byte[]>();

		public IPEndPoint PTEndPoint;

		public bool punchThrough;

		public bool PTUDPEstablished;

		public UdpClient PTUDP;

		public IAsyncResult PTConnectionResult;

		public int punchThroughAttemptCounter;

		public static event OnSendPostWelcomDataDelegate OnSendPostWelcomeData;

		public event OnClientDisconnectDelegate OnClientDisconnect;

		public ServerClient(int ID)
		{
			this.ID = ID;
			tcp = new TCP(ID);
			udp = new UDP(ID);
		}

		public void SendIntoGame(string playerName, string scene, int instance, int IFF, int colorIndex)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			player = new Player(ID, playerName, Vector3.zero, IFF, colorIndex);
			player.scene = scene;
			player.instance = instance;
			foreach (ServerClient value3 in Server.clients.Values)
			{
				if (value3.player != null && value3.ID != ID)
				{
					ServerSend.SpawnPlayer(ID, value3.player, value3.player.scene, value3.player.instance, value3.player.IFF, value3.player.colorIndex);
				}
			}
			GameManager.singleton.SpawnPlayer(player.ID, player.username, scene, instance, IFF, colorIndex);
			bool flag = true;
			foreach (ServerClient value4 in Server.clients.Values)
			{
				if (value4.player != null && value4.ID != ID)
				{
					ServerSend.SpawnPlayer(value4.ID, player, scene, instance, IFF, colorIndex, join: true);
					flag &= !scene.Equals(value4.player.scene);
				}
			}
			ServerSend.SpawnPlayer(ID, 0, ((object)Mod.config["Username"]).ToString(), GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene, GameManager.instance, ((Object)(object)GM.CurrentPlayerBody == (Object)null) ? (-3) : GM.CurrentPlayerBody.GetPlayerIFF(), GameManager.colorIndex, join: true);
			flag &= !scene.Equals(GameManager.sceneLoading ? LoadLevelBeginPatch.loadingLevel : GameManager.scene);
			Mod.LogInfo("Player " + ID + " join server in scene " + scene, debug: false);
			if (!GameManager.nonSynchronizedScenes.ContainsKey(scene))
			{
				if (GameManager.playersByInstanceByScene.TryGetValue(scene, out var value) && value.TryGetValue(player.instance, out var value2) && value2.Count > 1)
				{
					List<int> list = new List<int>();
					for (int i = 0; i < value2.Count; i++)
					{
						if (value2[i] != ID)
						{
							if (Server.clientsWaitingUpDate.ContainsKey(value2[i]))
							{
								Server.clientsWaitingUpDate[value2[i]].Add(ID);
							}
							else
							{
								Server.clientsWaitingUpDate.Add(value2[i], new List<int> { ID });
							}
							ServerSend.RequestUpToDateObjects(value2[i], instantiateOnReceive: false, ID);
							list.Add(value2[i]);
						}
					}
					if (list.Count > 0)
					{
						if (Server.loadingClientsWaitingFrom.ContainsKey(ID))
						{
							Server.loadingClientsWaitingFrom[ID] = list;
						}
						else
						{
							Server.loadingClientsWaitingFrom.Add(ID, list);
						}
					}
					else
					{
						Mod.LogInfo("Client " + ID + " just got sent into game, no other player in scene/instance, sending relevant tracked objects");
						SendRelevantTrackedObjects();
					}
				}
				else
				{
					Mod.LogInfo("Client " + ID + " just got sent into game, no other player in scene/instance, sending relevant tracked objects");
					SendRelevantTrackedObjects();
				}
				ServerSend.ConnectSync(ID, flag);
			}
			if (ServerClient.OnSendPostWelcomeData != null)
			{
				ServerClient.OnSendPostWelcomeData(ID);
			}
			ServerSend.InitTNHInstances(ID);
		}

		public void SendRelevantTrackedObjects(int fromClient = -1)
		{
			Mod.LogInfo("Sending relevant object to " + ID + " from " + fromClient + " in " + player.scene + "/" + player.instance);
			if (!GameManager.objectsByInstanceByScene.TryGetValue(player.scene, out var value) || !value.TryGetValue(player.instance, out var value2))
			{
				return;
			}
			Mod.LogInfo("\tGot " + value2.Count + " objects to send");
			for (int i = 0; i < value2.Count; i++)
			{
				TrackedObjectData trackedObjectData = Server.objects[value2[i]];
				Mod.LogInfo("\t\tObject " + i + " null: " + (trackedObjectData == null));
				if (trackedObjectData == null || (fromClient != -1 && trackedObjectData.controller != fromClient))
				{
					continue;
				}
				if (trackedObjectData.controller == 0)
				{
					if (GameManager.sceneLoading && trackedObjectData.scene.Equals(GameManager.scene))
					{
						continue;
					}
					trackedObjectData.Update();
				}
				Mod.LogInfo("\t\t\tSending");
				ServerSend.TrackedObjectSpecific(trackedObjectData, ID);
			}
		}

		public void Disconnect(int code, Exception ex = null)
		{
			connected = false;
			switch (code)
			{
			case 0:
				Mod.LogWarning("Client " + ID + " : " + tcp.socket.Client.RemoteEndPoint?.ToString() + " disconnected, end of stream.");
				break;
			case 1:
				Mod.LogWarning("Client " + ID + " : " + tcp.socket.Client.RemoteEndPoint?.ToString() + " forcibly disconnected.");
				break;
			case 2:
				Mod.LogWarning("Client " + ID + " : " + tcp.socket.Client.RemoteEndPoint?.ToString() + " disconnected.");
				break;
			}
			tcp.Disconnect();
			udp.Disconnect();
			Mod.RemovePlayerFromLists(ID);
			GameManager.DistributeAllControl(ID);
			SpecificDisconnect();
			if (this.OnClientDisconnect != null)
			{
				this.OnClientDisconnect();
			}
			ServerSend.ClientDisconnect(ID);
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, List<int>> item in Server.IDsToConfirm)
			{
				item.Value.Remove(ID);
				if (item.Value.Count == 0)
				{
					list.Add(item.Key);
				}
			}
			for (int i = 0; i < list.Count; i++)
			{
				Server.IDsToConfirm.Remove(list[i]);
			}
			Server.availableIndexBufferClients.Remove(ID);
			List<int> list2 = new List<int>();
			foreach (KeyValuePair<int, List<int>> item2 in Server.availableIndexBufferWaitingFor)
			{
				item2.Value.Remove(ID);
				if (item2.Value.Count == 0)
				{
					Server.availableObjectIndices.Add(item2.Key);
					list2.Add(item2.Key);
				}
			}
			for (int j = 0; j < list2.Count; j++)
			{
				Server.availableIndexBufferWaitingFor.Remove(list2[j]);
			}
			Server.connectedClients.Remove(ID);
			player = null;
		}

		private void SpecificDisconnect()
		{
			if (GameManager.TNHInstances.TryGetValue(player.instance, out var value) && value.currentlyPlaying.Contains(ID))
			{
				value.RemoveCurrentlyPlaying(send: true, ID, fromServer: true);
			}
		}
	}
	public class ServerHandle
	{
		public static void WelcomeReceived(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			string text = packet.ReadString();
			string scene = packet.ReadString();
			int instance = packet.ReadInt();
			int iFF = packet.ReadInt();
			int colorIndex = packet.ReadInt();
			Mod.LogInfo($"{Server.clients[clientID].tcp.socket.Client.RemoteEndPoint} connected successfully and is now player {clientID}.", debug: false);
			if (clientID != num)
			{
				Mod.LogInfo($"Player \"{text}\" (ID:{clientID}) has assumed wrong client ID ({num})", debug: false);
			}
			Server.clients[clientID].SendIntoGame(text, scene, instance, iFF, colorIndex);
			Server.connectedClients.Add(clientID);
			ServerSend.ConnectionComplete(clientID);
			Mod.LogInfo("\tChecking if we are connected and listed on IS", debug: false);
			if (ISClient.isConnected && ISClient.listed)
			{
				Mod.LogInfo("\t\tWe are, sending new playercount: " + (GameManager.players.Count + 1), debug: false);
				ISClientSend.PlayerCount(GameManager.players.Count + 1);
			}
		}

		public static void Ping(int clientID, Packet packet)
		{
			long num = packet.ReadLong();
			Server.clients[clientID].ping = Convert.ToInt64((DateTime.Now.ToUniversalTime() - ThreadManager.epoch).TotalMilliseconds) - num;
			ServerSend.Ping(clientID, num);
		}

		public static void PlayerState(int clientID, Packet packet)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (Server.clients[clientID] != null && Server.clients[clientID].player != null)
			{
				Player player = Server.clients[clientID].player;
				player.position = packet.ReadVector3();
				player.rotation = packet.ReadQuaternion();
				player.headPos = packet.ReadVector3();
				player.headRot = packet.ReadQuaternion();
				player.torsoPos = packet.ReadVector3();
				player.torsoRot = packet.ReadQuaternion();
				player.leftHandPos = packet.ReadVector3();
				player.leftHandRot = packet.ReadQuaternion();
				player.rightHandPos = packet.ReadVector3();
				player.rightHandRot = packet.ReadQuaternion();
				player.health = packet.ReadFloat();
				player.maxHealth = packet.ReadInt();
				short num = packet.ReadShort();
				byte[] additionalData = null;
				if (num > 0)
				{
					additionalData = packet.ReadBytes(num);
				}
				GameManager.UpdatePlayerState(player.ID, player.position, player.rotation, player.headPos, player.headRot, player.torsoPos, player.torsoRot, player.leftHandPos, player.leftHandRot, player.rightHandPos, player.rightHandRot, player.health, player.maxHealth, additionalData);
				ServerSend.PlayerState(packet, player);
			}
		}

		public static void PlayerIFF(int clientID, Packet packet)
		{
			int iFF = packet.ReadInt();
			if (Server.clients.ContainsKey(clientID))
			{
				Server.clients[clientID].player.IFF = iFF;
			}
			if (GameManager.players.ContainsKey(clientID))
			{
				GameManager.players[clientID].SetIFF(iFF);
			}
			ServerSend.PlayerIFF(clientID, iFF);
		}

		public static void PlayerScene(int clientID, Packet packet)
		{
			Player player = Server.clients[clientID].player;
			string text = packet.ReadString();
			GameManager.UpdatePlayerScene(player.ID, text);
			ServerSend.PlayerScene(player.ID, text);
			if (GameManager.nonSynchronizedScenes.ContainsKey(text))
			{
				return;
			}
			if (GameManager.playersByInstanceByScene.TryGetValue(text, out var value) && value.TryGetValue(player.instance, out var value2) && value2.Count > 1)
			{
				List<int> list = new List<int>();
				for (int i = 0; i < value2.Count; i++)
				{
					if (value2[i] != clientID)
					{
						if (Server.clientsWaitingUpDate.ContainsKey(value2[i]))
						{
							Server.clientsWaitingUpDate[value2[i]].Add(clientID);
						}
						else
						{
							Server.clientsWaitingUpDate.Add(value2[i], new List<int> { clientID });
						}
						ServerSend.RequestUpToDateObjects(value2[i], instantiateOnReceive: false, clientID);
						list.Add(value2[i]);
					}
				}
				if (list.Count > 0)
				{
					if (Server.loadingClientsWaitingFrom.ContainsKey(clientID))
					{
						Server.loadingClientsWaitingFrom[clientID] = list;
					}
					else
					{
						Server.loadingClientsWaitingFrom.Add(clientID, list);
					}
				}
				else
				{
					Server.clients[clientID].SendRelevantTrackedObjects();
				}
			}
			else
			{
				Server.clients[clientID].SendRelevantTrackedObjects();
			}
		}

		public static void PlayerInstance(int clientID, Packet packet)
		{
			Player player = Server.clients[clientID].player;
			int instance = packet.ReadInt();
			bool flag = packet.ReadBool();
			GameManager.UpdatePlayerInstance(player.ID, instance);
			ServerSend.PlayerInstance(player.ID, instance);
			if (flag || GameManager.nonSynchronizedScenes.ContainsKey(player.scene))
			{
				return;
			}
			if (GameManager.playersByInstanceByScene.TryGetValue(player.scene, out var value) && value.TryGetValue(player.instance, out var value2) && value2.Count > 1)
			{
				List<int> list = new List<int>();
				for (int i = 0; i < value2.Count; i++)
				{
					if (value2[i] != clientID)
					{
						if (Server.clientsWaitingUpDate.ContainsKey(value2[i]))
						{
							Server.clientsWaitingUpDate[value2[i]].Add(clientID);
						}
						else
						{
							Server.clientsWaitingUpDate.Add(value2[i], new List<int> { clientID });
						}
						ServerSend.RequestUpToDateObjects(value2[i], instantiateOnReceive: false, clientID);
						list.Add(value2[i]);
					}
				}
				if (list.Count > 0)
				{
					if (Server.loadingClientsWaitingFrom.ContainsKey(clientID))
					{
						Server.loadingClientsWaitingFrom[clientID] = list;
					}
					else
					{
						Server.loadingClientsWaitingFrom.Add(clientID, list);
					}
				}
				else
				{
					Server.clients[clientID].SendRelevantTrackedObjects();
				}
			}
			else
			{
				Server.clients[clientID].SendRelevantTrackedObjects();
			}
		}

		public static void AddTNHInstance(int clientID, Packet packet)
		{
			int hostID = packet.ReadInt();
			bool letPeopleJoin = packet.ReadBool();
			int progressionTypeSetting = packet.ReadInt();
			int healthModeSetting = packet.ReadInt();
			int equipmentModeSetting = packet.ReadInt();
			int targetModeSetting = packet.ReadInt();
			int aIDifficultyModifier = packet.ReadInt();
			int radarModeModifier = packet.ReadInt();
			int itemSpawnerMode = packet.ReadInt();
			int backpackMode = packet.ReadInt();
			int healthMult = packet.ReadInt();
			int sosiggunShakeReloading = packet.ReadInt();
			int tNHSeed = packet.ReadInt();
			string levelID = packet.ReadString();
			ServerSend.AddTNHInstance(GameManager.AddNewTNHInstance(hostID, letPeopleJoin, progressionTypeSetting, healthModeSetting, equipmentModeSetting, targetModeSetting, aIDifficultyModifier, radarModeModifier, itemSpawnerMode, backpackMode, healthMult, sosiggunShakeReloading, tNHSeed, levelID));
		}

		public static void AddInstance(int clientID, Packet packet)
		{
			ServerSend.AddInstance(GameManager.AddNewInstance());
		}

		public static void TrackedObject(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			string text = packet.ReadString();
			if (Mod.trackedObjectTypesByName.TryGetValue(text, out var _))
			{
				Server.AddTrackedObject((TrackedObjectData)Activator.CreateInstance(Mod.trackedObjectTypesByName[text], packet, text, num), clientID);
			}
		}

		public static void TrackedObjects(int clientID, Packet packet)
		{
			TrackedObjectData.Update(packet);
			if (GameManager.playersByInstanceByScene.TryGetValue(Server.clients[clientID].player.scene, out var value) && value.TryGetValue(Server.clients[clientID].player.instance, out var value2))
			{
				ServerSend.TrackedObjects(packet, value2, clientID);
			}
		}

		public static void ObjectUpdate(int clientID, Packet packet)
		{
			TrackedObjectData.Update(packet, includesLength: false);
			ServerSend.ObjectUpdate(packet, clientID);
		}

		public static void GiveObjectControl(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			int num3 = packet.ReadInt();
			List<int> list = new List<int>();
			for (int i = 0; i < num3; i++)
			{
				list.Add(packet.ReadInt());
			}
			Mod.LogInfo("Server received GiveObjectControl for " + num + " to controller: " + num2, debug: false);
			TrackedObjectData trackedObjectData = Server.objects[num];
			bool flag = false;
			if (trackedObjectData == null)
			{
				Mod.LogError("Server received order to set object " + num + " controller to " + num2 + " but object is missing from objects array!");
				ServerSend.DestroyObject(num);
				return;
			}
			if (trackedObjectData.controller != 0 && num2 == 0)
			{
				Mod.LogInfo("\tNew controller", debug: false);
				trackedObjectData.localTrackedID = GameManager.objects.Count;
				GameManager.objects.Add(trackedObjectData);
				if ((Object)(object)trackedObjectData.physical == (Object)null)
				{
					Mod.LogInfo("\t\tNo phys", debug: false);
					if (!GameManager.sceneLoading)
					{
						Mod.LogInfo("\t\t\tNot loading", debug: false);
						if (trackedObjectData.scene.Equals(GameManager.scene) && trackedObjectData.instance == GameManager.instance)
						{
							Mod.LogInfo("\t\t\t\tSame scene instance, instantiating", debug: false);
							if (!trackedObjectData.awaitingInstantiation)
							{
								trackedObjectData.awaitingInstantiation = true;
								AnvilManager.Run(trackedObjectData.Instantiate());
							}
						}
						else
						{
							Mod.LogInfo("\t\t\t\tDifferent scene instance, can't take control", debug: false);
							if (GameManager.playersByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value) && value.TryGetValue(trackedObjectData.instance, out var value2))
							{
								List<int> list2 = new List<int>(value2);
								for (int j = 0; j < list.Count; j++)
								{
									list2.Remove(list[j]);
								}
								num2 = Mod.GetBestPotentialObjectHost(trackedObjectData.controller, forUs: true, hasWhiteList: true, list2, trackedObjectData.scene, trackedObjectData.instance);
								if (num2 == -1)
								{
									Mod.LogInfo("\t\t\t\t\tNo one to bounce to, destroying", debug: false);
									ServerSend.DestroyObject(num);
									trackedObjectData.RemoveFromLocal();
									Server.objects[num] = null;
									if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value3) && value3.TryGetValue(trackedObjectData.instance, out var value4))
									{
										value4.Remove(trackedObjectData.trackedID);
									}
									trackedObjectData.awaitingInstantiation = false;
									flag = true;
								}
								else
								{
									Mod.LogInfo("\t\t\t\t\tBouncing to " + num2, debug: false);
									trackedObjectData.RemoveFromLocal();
									list.Add(GameManager.ID);
								}
							}
							else
							{
								Mod.LogInfo("\t\t\t\t\tNo one to bounce to, destroying", debug: false);
								ServerSend.DestroyObject(num);
								trackedObjectData.RemoveFromLocal();
								Server.objects[num] = null;
								if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value5) && value5.TryGetValue(trackedObjectData.instance, out var value6))
								{
									value6.Remove(trackedObjectData.trackedID);
								}
								trackedObjectData.awaitingInstantiation = false;
								flag = true;
							}
							if (num2 == -1)
							{
								if (Server.connectedClients.Count > 0)
								{
									if (Server.availableIndexBufferWaitingFor.TryGetValue(trackedObjectData.trackedID, out var value7))
									{
										for (int k = 0; k < Server.connectedClients.Count; k++)
										{
											if (!value7.Contains(Server.connectedClients[k]))
											{
												value7.Add(Server.connectedClients[k]);
											}
										}
									}
									else
									{
										Server.availableIndexBufferWaitingFor.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
									}
									for (int l = 0; l < Server.connectedClients.Count; l++)
									{
										if (Server.availableIndexBufferClients.TryGetValue(Server.connectedClients[l], out var value8))
										{
											value8.Add(trackedObjectData.trackedID);
											continue;
										}
										Server.availableIndexBufferClients.Add(Server.connectedClients[l], new List<int> { trackedObjectData.trackedID });
									}
									if (Server.IDsToConfirm.TryGetValue(trackedObjectData.trackedID, out var value9))
									{
										for (int m = 0; m < Server.connectedClients.Count; m++)
										{
											if (!value9.Contains(Server.connectedClients[m]))
											{
												value9.Add(Server.connectedClients[m]);
											}
										}
									}
									else
									{
										Server.IDsToConfirm.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
									}
									Mod.LogInfo("Added " + trackedObjectData.trackedID + " to ID buffer");
								}
								else
								{
									Server.availableObjectIndices.Add(trackedObjectData.trackedID);
								}
							}
						}
					}
					else
					{
						Mod.LogInfo("\t\t\tLoading or not our scene/instance", debug: false);
						if (GameManager.playersByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value10) && value10.TryGetValue(trackedObjectData.instance, out var value11))
						{
							List<int> list3 = new List<int>(value11);
							for (int n = 0; n < list.Count; n++)
							{
								list3.Remove(list[n]);
							}
							num2 = Mod.GetBestPotentialObjectHost(trackedObjectData.controller, forUs: true, hasWhiteList: true, list3, trackedObjectData.scene, trackedObjectData.instance);
							if (num2 == -1)
							{
								Mod.LogInfo("\t\t\t\tNo one to bounce to, destroying", debug: false);
								ServerSend.DestroyObject(num);
								trackedObjectData.RemoveFromLocal();
								Server.objects[num] = null;
								if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value12) && value12.TryGetValue(trackedObjectData.instance, out var value13))
								{
									value13.Remove(trackedObjectData.trackedID);
								}
								trackedObjectData.awaitingInstantiation = false;
								flag = true;
							}
							else
							{
								Mod.LogInfo("\t\t\t\tBouncing to " + num2, debug: false);
								trackedObjectData.RemoveFromLocal();
								list.Add(GameManager.ID);
							}
						}
						else
						{
							Mod.LogInfo("\t\t\t\tNo one to bounce to, destroying", debug: false);
							ServerSend.DestroyObject(num);
							trackedObjectData.RemoveFromLocal();
							Server.objects[num] = null;
							if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObjectData.scene, out var value14) && value14.TryGetValue(trackedObjectData.instance, out var value15))
							{
								value15.Remove(trackedObjectData.trackedID);
							}
							trackedObjectData.awaitingInstantiation = false;
							flag = true;
						}
						if (num2 == -1)
						{
							if (Server.connectedClients.Count > 0)
							{
								if (Server.availableIndexBufferWaitingFor.TryGetValue(trackedObjectData.trackedID, out var value16))
								{
									for (int num4 = 0; num4 < Server.connectedClients.Count; num4++)
									{
										if (!value16.Contains(Server.connectedClients[num4]))
										{
											value16.Add(Server.connectedClients[num4]);
										}
									}
								}
								else
								{
									Server.availableIndexBufferWaitingFor.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
								}
								for (int num5 = 0; num5 < Server.connectedClients.Count; num5++)
								{
									if (Server.availableIndexBufferClients.TryGetValue(Server.connectedClients[num5], out var value17))
									{
										value17.Add(trackedObjectData.trackedID);
										continue;
									}
									Server.availableIndexBufferClients.Add(Server.connectedClients[num5], new List<int> { trackedObjectData.trackedID });
								}
								if (Server.IDsToConfirm.TryGetValue(trackedObjectData.trackedID, out var value18))
								{
									for (int num6 = 0; num6 < Server.connectedClients.Count; num6++)
									{
										if (!value18.Contains(Server.connectedClients[num6]))
										{
											value18.Add(Server.connectedClients[num6]);
										}
									}
								}
								else
								{
									Server.IDsToConfirm.Add(trackedObjectData.trackedID, new List<int>(Server.connectedClients));
								}
								Mod.LogInfo("Added " + trackedObjectData.trackedID + " to ID buffer");
							}
							else
							{
								Server.availableObjectIndices.Add(trackedObjectData.trackedID);
							}
						}
					}
				}
			}
			else if (trackedObjectData.controller == 0 && num2 != 0)
			{
				Mod.LogInfo("\tNew controller", debug: false);
				trackedObjectData.RemoveFromLocal();
			}
			if (!flag)
			{
				trackedObjectData.SetController(num2);
				ServerSend.GiveObjectControl(num, num2, list);
			}
		}

		public static void DestroyObject(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			TrackedObjectData trackedObjectData = Server.objects[num];
			Mod.LogInfo("Server received object destruction for tracked ID: " + num + ", remove from lists: " + flag, debug: false);
			if (trackedObjectData != null)
			{
				Mod.LogInfo("\tGot object", debug: false);
				trackedObjectData.awaitingInstantiation = false;
				bool flag2 = false;
				if ((Object)(object)trackedObjectData.physical != (Object)null)
				{
					Mod.LogInfo("\t\tGot phys, destroying", debug: false);
					trackedObjectData.removeFromListOnDestroy = flag;
					trackedObjectData.physical.sendDestroy = false;
					trackedObjectData.physical.dontGiveControl = true;
					TrackedObject[] componentsInChildren = ((Component)trackedObjectData.physical).GetComponentsInChildren<TrackedObject>();
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						if ((Object)(object)componentsInChildren[i] != (Object)null)
						{
							componentsInChildren[i].sendDestroy = false;
							componentsInChildren[i].data.removeFromListOnDestroy = flag;
							componentsInChildren[i].dontGiveControl = true;
						}
					}
					trackedObjectData.physical.SecondaryDestroy();
					Object.Destroy((Object)(object)((Component)trackedObjectData.physical).gameObject);
					flag2 = true;
				}
				if (!flag2 && trackedObjectData.localTrackedID != -1)
				{
					Mod.LogInfo("\t\tNo phys, is local, removing from local", debug: false);
					trackedObjectData.RemoveFromLocal();
				}
				if (flag && !flag2)
				{
					Mod.LogInfo("\t\tNo phys, removing from lists", debug: false);
					trackedObjectData.RemoveFromLists();
				}
			}
			ServerSend.DestroyObject(num, flag, clientID);
		}

		public static void ObjectParent(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			Server.objects[num].SetParent(num2);
			ServerSend.ObjectParent(num, num2, clientID);
		}

		public static void WeaponFire(int clientID, Packet packet)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] == null)
			{
				Mod.LogError("Server received order to fire weapon " + num + " but item is missing from items array!");
			}
			else if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				int num2 = packet.ReadShort();
				int num3 = packet.ReadShort();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				int chamberIndex = packet.ReadInt();
				Mod.skipNextFires++;
				(Server.objects[num] as TrackedItemData).physicalItem.setFirearmUpdateOverride((FireArmRoundType)num2, (FireArmRoundClass)num3, chamberIndex);
				ProjectileFirePatch.skipBlast++;
				(Server.objects[num] as TrackedItemData).physicalItem.fireFunc(chamberIndex);
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.WeaponFire(clientID, packet);
		}

		public static void FlintlockWeaponBurnOffOuter(int clientID, Packet packet)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				Object dataObject = (Server.objects[num] as TrackedItemData).physicalItem.dataObject;
				FlintlockBarrel val = (FlintlockBarrel)(object)((dataObject is FlintlockBarrel) ? dataObject : null);
				FVRPhysicalObject physicalItem = (Server.objects[num] as TrackedItemData).physicalItem.physicalItem;
				FlintlockWeapon val2 = (FlintlockWeapon)(object)((physicalItem is FlintlockWeapon) ? physicalItem : null);
				int num2 = packet.ReadByte();
				val.LoadedElements = new List<LoadedElement>();
				for (int i = 0; i < num2; i++)
				{
					LoadedElement val3 = new LoadedElement();
					val3.Type = (LoadedElementType)packet.ReadByte();
					val3.Position = packet.ReadFloat();
				}
				val.LoadedElements[val.LoadedElements.Count - 1].PowderAmount = packet.ReadInt();
				if (packet.ReadBool() && (Object)(object)val2.RamRod.GetCurBarrel() != (Object)(object)val)
				{
					val2.RamRod.m_curBarrel = val;
				}
				FireFlintlockWeaponPatch.num2 = packet.ReadFloat();
				FireFlintlockWeaponPatch.positions = new List<Vector3>();
				FireFlintlockWeaponPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int j = 0; j < b; j++)
				{
					FireFlintlockWeaponPatch.positions.Add(packet.ReadVector3());
					FireFlintlockWeaponPatch.directions.Add(packet.ReadVector3());
				}
				FireFlintlockWeaponPatch.overriden = true;
				FireFlintlockWeaponPatch.burnSkip++;
				val.BurnOffOuter();
				FireFlintlockWeaponPatch.burnSkip--;
			}
			ServerSend.FlintlockWeaponBurnOffOuter(clientID, packet);
		}

		public static void FlintlockWeaponFire(int clientID, Packet packet)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				Object dataObject = (Server.objects[num] as TrackedItemData).physicalItem.dataObject;
				FlintlockBarrel val = (FlintlockBarrel)(object)((dataObject is FlintlockBarrel) ? dataObject : null);
				FVRPhysicalObject physicalItem = (Server.objects[num] as TrackedItemData).physicalItem.physicalItem;
				FlintlockWeapon val2 = (FlintlockWeapon)(object)((physicalItem is FlintlockWeapon) ? physicalItem : null);
				int num2 = packet.ReadByte();
				val.LoadedElements = new List<LoadedElement>();
				for (int i = 0; i < num2; i++)
				{
					LoadedElement val3 = new LoadedElement();
					val3.Type = (LoadedElementType)packet.ReadByte();
					val3.Position = packet.ReadFloat();
					val3.PowderAmount = packet.ReadInt();
				}
				if (packet.ReadBool() && (Object)(object)val2.RamRod.GetCurBarrel() != (Object)(object)val)
				{
					val2.RamRod.m_curBarrel = val;
				}
				FireFlintlockWeaponPatch.num5 = packet.ReadFloat();
				FireFlintlockWeaponPatch.positions = new List<Vector3>();
				FireFlintlockWeaponPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int j = 0; j < b; j++)
				{
					FireFlintlockWeaponPatch.positions.Add(packet.ReadVector3());
					FireFlintlockWeaponPatch.directions.Add(packet.ReadVector3());
				}
				FireFlintlockWeaponPatch.overriden = true;
				FireFlintlockWeaponPatch.fireSkip++;
				val.Fire();
				FireFlintlockWeaponPatch.fireSkip--;
			}
			ServerSend.FlintlockWeaponFire(clientID, packet);
		}

		public static void BreakActionWeaponFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				FVRPhysicalObject physicalItem = (Server.objects[num] as TrackedItemData).physicalItem.physicalItem;
				BreakActionWeapon val2 = (BreakActionWeapon)(object)((physicalItem is BreakActionWeapon) ? physicalItem : null);
				FireArmRoundType roundType2 = val2.Barrels[num2].Chamber.RoundType;
				val2.Barrels[num2].Chamber.RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Barrels[num2].Chamber.SetRound(val, ((Component)val2.Barrels[num2].Chamber).transform.position, ((Component)val2.Barrels[num2].Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Barrels[num2].Chamber.RoundType = roundType2;
				ProjectileFirePatch.skipBlast++;
				val2.Fire(num2, false, 0);
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.BreakActionWeaponFire(clientID, packet);
		}

		public static void DerringerFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				Derringer val2 = (Derringer)(object)((physical is Derringer) ? physical : null);
				FireArmRoundType roundType2 = val2.Barrels[num2].Chamber.RoundType;
				val2.Barrels[num2].Chamber.RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Barrels[num2].Chamber.SetRound(val, ((Component)val2.Barrels[num2].Chamber).transform.position, ((Component)val2.Barrels[num2].Chamber).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Barrels[num2].Chamber.RoundType = roundType2;
				val2.m_curBarrel = num2;
				ProjectileFirePatch.skipBlast++;
				val2.FireBarrel(num2);
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.DerringerFire(clientID, packet);
		}

		public static void RevolvingShotgunFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				RevolvingShotgun val2 = (RevolvingShotgun)(object)((physical is RevolvingShotgun) ? physical : null);
				val2.CurChamber = num2;
				FireArmRoundType roundType2 = val2.Chambers[num2].RoundType;
				val2.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[num2].SetRound(val, ((Component)val2.Chambers[num2]).transform.position, ((Component)val2.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[num2].RoundType = roundType2;
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.RevolvingShotgunFire(clientID, packet);
		}

		public static void RevolverFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				Revolver val2 = (Revolver)(object)((physical is Revolver) ? physical : null);
				bool flag = false;
				int chamberOffset = 0;
				if (val2.ChamberOffset != 0)
				{
					flag = true;
					chamberOffset = val2.ChamberOffset;
					val2.ChamberOffset = 0;
				}
				val2.CurChamber = num2;
				FireArmRoundType roundType2 = val2.Chambers[num2].RoundType;
				val2.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[num2].SetRound(val, ((Component)val2.Chambers[num2]).transform.position, ((Component)val2.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[num2].RoundType = roundType2;
				if (flag)
				{
					val2.ChamberOffset = chamberOffset;
				}
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.RevolverFire(clientID, packet);
		}

		public static void SingleActionRevolverFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				SingleActionRevolver val2 = (SingleActionRevolver)(object)((physical is SingleActionRevolver) ? physical : null);
				val2.CurChamber = num2;
				FireArmRoundType roundType2 = val2.Cylinder.Chambers[num2].RoundType;
				val2.Cylinder.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Cylinder.Chambers[num2].SetRound(val, ((Component)val2.Cylinder.Chambers[num2]).transform.position, ((Component)val2.Cylinder.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Cylinder.Chambers[num2].RoundType = roundType2;
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.SingleActionRevolverFire(clientID, packet);
		}

		public static void GrappleGunFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				int num2 = packet.ReadByte();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				GrappleGun val2 = (GrappleGun)(object)((physical is GrappleGun) ? physical : null);
				val2.m_curChamber = num2;
				FireArmRoundType roundType2 = val2.Chambers[num2].RoundType;
				val2.Chambers[num2].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[num2].SetRound(val, ((Component)val2.Chambers[num2]).transform.position, ((Component)val2.Chambers[num2]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[num2].RoundType = roundType2;
				val2.Fire();
			}
			ServerSend.GrappleGunFire(clientID, packet);
		}

		public static void HCBReleaseSled(int clientID, Packet packet)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				float num2 = packet.ReadFloat();
				FireHCBPatch.position = packet.ReadVector3();
				FireHCBPatch.direction = packet.ReadVector3();
				FireHCBPatch.overriden = true;
				FireHCBPatch.releaseSledSkip++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				HCB val = (HCB)(object)((physical is HCB) ? physical : null);
				if (num2 == -1f)
				{
					ChamberPatch.chamberSkip++;
					val.Chamber.SetRound((FVRFireArmRound)null, false);
					ChamberPatch.chamberSkip--;
				}
				else
				{
					val.m_cookedAmount = num2;
					if (!val.Chamber.IsFull)
					{
						ChamberPatch.chamberSkip++;
						val.Chamber.SetRound((FireArmRoundClass)1, ((Component)val.Chamber).transform.position, ((Component)val.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
				}
				val.ReleaseSled();
				FireHCBPatch.releaseSledSkip--;
			}
			ServerSend.HCBReleaseSled(clientID, packet);
		}

		public static void StingerLauncherFire(int clientID, Packet packet)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireStingerLauncherPatch.targetPos = packet.ReadVector3();
				FireStingerLauncherPatch.position = packet.ReadVector3();
				FireStingerLauncherPatch.rotation = packet.ReadQuaternion();
				FireStingerLauncherPatch.overriden = true;
				FireStingerLauncherPatch.skip++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				StingerLauncher val = (StingerLauncher)(object)((physical is StingerLauncher) ? physical : null);
				val.m_hasMissile = true;
				ProjectileFirePatch.skipBlast++;
				val.Fire();
				ProjectileFirePatch.skipBlast--;
				FireStingerLauncherPatch.skip--;
			}
			ServerSend.StingerLauncherFire(clientID, packet);
		}

		public static void LeverActionFirearmFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				bool flag = packet.ReadBool();
				FirePatch.positions = new List<Vector3>();
				FirePatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FirePatch.positions.Add(packet.ReadVector3());
					FirePatch.directions.Add(packet.ReadVector3());
				}
				FirePatch.overriden = true;
				Mod.skipNextFires++;
				Object dataObject = (Server.objects[num].physical as TrackedItem).dataObject;
				LeverActionFirearm val2 = (LeverActionFirearm)(object)((dataObject is LeverActionFirearm) ? dataObject : null);
				if (flag)
				{
					FireArmRoundType roundType2 = val2.Chamber.RoundType;
					val2.Chamber.RoundType = roundType;
					ChamberPatch.chamberSkip++;
					val2.Chamber.SetRound(val, ((Component)val2.Chamber).transform.position, ((Component)val2.Chamber).transform.rotation);
					ChamberPatch.chamberSkip--;
					val2.Chamber.RoundType = roundType2;
					val2.m_isHammerCocked = true;
					ProjectileFirePatch.skipBlast++;
					val2.Fire();
					ProjectileFirePatch.skipBlast--;
				}
				else
				{
					bool flag2 = false;
					if (val2.IsHammerCocked)
					{
						flag2 = true;
						val2.m_isHammerCocked = false;
					}
					bool flag3 = false;
					FireArmRoundClass val3 = (FireArmRoundClass)185;
					if ((Object)(object)val2.Chamber.GetRound() != (Object)null)
					{
						flag3 = true;
						val3 = val2.Chamber.GetRound().RoundClass;
						ChamberPatch.chamberSkip++;
						val2.Chamber.SetRound((FVRFireArmRound)null, false);
						ChamberPatch.chamberSkip--;
					}
					FireArmRoundType roundType3 = val2.Chamber.RoundType;
					val2.Chamber2.RoundType = roundType;
					ChamberPatch.chamberSkip++;
					val2.Chamber2.SetRound(val, ((Component)val2.Chamber2).transform.position, ((Component)val2.Chamber2).transform.rotation);
					ChamberPatch.chamberSkip--;
					val2.Chamber2.RoundType = roundType3;
					val2.m_isHammerCocked2 = true;
					ProjectileFirePatch.skipBlast++;
					val2.Fire();
					ProjectileFirePatch.skipBlast--;
					if (flag2)
					{
						val2.m_isHammerCocked = true;
					}
					if (flag3)
					{
						ChamberPatch.chamberSkip++;
						val2.Chamber.SetRound(val3, ((Component)val2.Chamber).transform.position, ((Component)val2.Chamber).transform.rotation);
						ChamberPatch.chamberSkip--;
					}
				}
			}
			ServerSend.LeverActionFirearmFire(clientID, packet);
		}

		public static void SosigWeaponFire(int clientID, Packet packet)
		{
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			if (packet == null)
			{
				Mod.LogError("SosigWeaponFire packet null");
				return;
			}
			int num = packet.ReadInt();
			float recoilMult = packet.ReadFloat();
			if (Server.objects[num] == null)
			{
				Mod.LogError("SosigWeaponFire object at " + num + " null");
				return;
			}
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				if ((Object)(object)(Server.objects[num].physical as TrackedItem) == (Object)null)
				{
					Mod.LogError("SosigWeaponFire physical not trackedItem");
					return;
				}
				Object dataObject = (Server.objects[num].physical as TrackedItem).dataObject;
				if (((dataObject is SosigWeaponPlayerInterface) ? dataObject : null) == (Object)null)
				{
					Mod.LogError("SosigWeaponFire physical item not SosigWeaponPlayerInterface");
					return;
				}
				Object dataObject2 = (Server.objects[num].physical as TrackedItem).dataObject;
				if (((dataObject2 is SosigWeaponPlayerInterface) ? dataObject2 : null) == (Object)null)
				{
					Mod.LogError("SosigWeaponFire physical item not SosigWeaponPlayerInterface");
					return;
				}
				Object dataObject3 = (Server.objects[num].physical as TrackedItem).dataObject;
				if ((Object)(object)((SosigWeaponPlayerInterface)((dataObject3 is SosigWeaponPlayerInterface) ? dataObject3 : null)).W == (Object)null)
				{
					Mod.LogError("SosigWeaponFire SosigWeaponPlayerInterface has no weapon");
					return;
				}
				FireSosigWeaponPatch.positions = new List<Vector3>();
				FireSosigWeaponPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireSosigWeaponPatch.positions.Add(packet.ReadVector3());
					FireSosigWeaponPatch.directions.Add(packet.ReadVector3());
				}
				FireSosigWeaponPatch.overriden = true;
				Mod.skipNextFires++;
				Object dataObject4 = (Server.objects[num].physical as TrackedItem).dataObject;
				SosigWeaponPlayerInterface val = (SosigWeaponPlayerInterface)(object)((dataObject4 is SosigWeaponPlayerInterface) ? dataObject4 : null);
				if (val.W.m_shotsLeft <= 0)
				{
					val.W.m_shotsLeft = 1;
				}
				val.W.MechaState = (SosigWeaponMechaState)0;
				(Server.objects[num].physical as TrackedItem).sosigWeaponfireFunc(recoilMult);
			}
			ServerSend.SosigWeaponFire(clientID, packet);
		}

		public static void AttachableFirearmFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass roundClass = (FireArmRoundClass)packet.ReadShort();
				bool firedFromInterface = packet.ReadBool();
				FireAttachableFirearmPatch.positions = new List<Vector3>();
				FireAttachableFirearmPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireAttachableFirearmPatch.positions.Add(packet.ReadVector3());
					FireAttachableFirearmPatch.directions.Add(packet.ReadVector3());
				}
				FireAttachableFirearmPatch.overriden = true;
				Mod.skipNextFires++;
				(Server.objects[num].physical as TrackedItem).attachableFirearmChamberRoundFunc(roundType, roundClass);
				ProjectileFirePatch.skipBlast++;
				(Server.objects[num].physical as TrackedItem).attachableFirearmFireFunc(firedFromInterface);
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.AttachableFirearmFire(clientID, packet);
		}

		public static void IntegratedFirearmFire(int clientID, Packet packet)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass roundClass = (FireArmRoundClass)packet.ReadShort();
				FireAttachableFirearmPatch.positions = new List<Vector3>();
				FireAttachableFirearmPatch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireAttachableFirearmPatch.positions.Add(packet.ReadVector3());
					FireAttachableFirearmPatch.directions.Add(packet.ReadVector3());
				}
				FireAttachableFirearmPatch.overriden = true;
				Mod.skipNextFires++;
				(Server.objects[num].physical as TrackedItem).attachableFirearmChamberRoundFunc(roundType, roundClass);
				ProjectileFirePatch.skipBlast++;
				(Server.objects[num].physical as TrackedItem).attachableFirearmFireFunc(firedFromInterface: false);
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.IntegratedFirearmFire(clientID, packet);
		}

		public static void LAPD2019Fire(int clientID, Packet packet)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				int curChamber = packet.ReadInt();
				FireArmRoundType roundType = (FireArmRoundType)packet.ReadShort();
				FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
				FireLAPD2019Patch.positions = new List<Vector3>();
				FireLAPD2019Patch.directions = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					FireLAPD2019Patch.positions.Add(packet.ReadVector3());
					FireLAPD2019Patch.directions.Add(packet.ReadVector3());
				}
				FireLAPD2019Patch.overriden = true;
				Mod.skipNextFires++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				LAPD2019 val2 = (LAPD2019)(object)((physical is LAPD2019) ? physical : null);
				val2.CurChamber = curChamber;
				FireArmRoundType roundType2 = val2.Chambers[val2.CurChamber].RoundType;
				val2.Chambers[val2.CurChamber].RoundType = roundType;
				ChamberPatch.chamberSkip++;
				val2.Chambers[val2.CurChamber].SetRound(val, ((Component)val2.Chambers[val2.CurChamber]).transform.position, ((Component)val2.Chambers[val2.CurChamber]).transform.rotation);
				ChamberPatch.chamberSkip--;
				val2.Chambers[val2.CurChamber].RoundType = roundType2;
				ProjectileFirePatch.skipBlast++;
				val2.Fire();
				ProjectileFirePatch.skipBlast--;
			}
			ServerSend.LAPD2019Fire(clientID, packet);
		}

		public static void LAPD2019LoadBattery(int clientID, Packet packet)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null && (Object)(object)Server.objects[num2].physical != (Object)null)
			{
				LAPD2019ActionPatch.loadBatterySkip++;
				((LAPD2019)Server.objects[num].physical.physical).LoadBattery((LAPD2019Battery)Server.objects[num2].physical.physical);
				LAPD2019ActionPatch.loadBatterySkip--;
			}
			ServerSend.LAPD2019LoadBattery(clientID, num, num2);
		}

		public static void LAPD2019ExtractBattery(int clientID, Packet packet)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				LAPD2019ActionPatch.extractBatterySkip++;
				((LAPD2019)Server.objects[num].physical.physical).ExtractBattery((FVRViveHand)null);
				LAPD2019ActionPatch.extractBatterySkip--;
			}
			ServerSend.LAPD2019ExtractBattery(clientID, num);
		}

		public static void SosigWeaponShatter(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				SosigWeaponShatterPatch.skip++;
				MonoBehaviour physical = Server.objects[num].physical.physical;
				((SosigWeaponPlayerInterface)((physical is SosigWeaponPlayerInterface) ? physical : null)).W.Shatter();
				SosigWeaponShatterPatch.skip--;
			}
			ServerSend.SosigWeaponShatter(clientID, num);
		}

		public static void AutoMeaterFirearmFireShot(int clientID, Packet packet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			if ((Object)(object)Server.objects[num].physical != (Object)null)
			{
				AutoMeaterFirearmFireShotPatch.muzzleAngles = val;
				AutoMeaterFirearmFireShotPatch.angleOverride = true;
				AutoMeaterFirearmFireShotPatch.skip++;
				(Server.objects[num].physical as TrackedAutoMeater).physicalAutoMeater.FireControl.Firearms[0].FireShot();
				AutoMeaterFirearmFireShotPatch.skip--;
			}
			ServerSend.AutoMeaterFirearmFireShot(clientID, num, val);
		}

		public static void PlayerDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			float damageMult = packet.ReadFloat();
			bool head = packet.ReadBool();
			Damage damage = packet.ReadDamage();
			if (num == 0)
			{
				GameManager.ProcessPlayerDamage(damageMult, head, damage);
			}
			else
			{
				ServerSend.PlayerDamage(num, damageMult, head, damage);
			}
		}

		public static void UberShatterableShatter(int clientID, Packet packet)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			TrackedObjectData trackedObjectData = Server.objects[num];
			if (trackedObjectData != null)
			{
				if ((Object)(object)trackedObjectData.physical != (Object)null)
				{
					trackedObjectData.physical.HandleShatter(null, packet.ReadVector3(), packet.ReadVector3(), packet.ReadFloat(), received: true, clientID, packet.ReadBytes(packet.ReadInt()));
				}
				ServerSend.UberShatterableShatter(clientID, packet);
			}
		}

		public static void SosigPickUpItem(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.inventory[(!flag) ? 1u : 0u] = num2;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					if (Server.objects[num2] == null)
					{
						Mod.LogError("SosigPickUpItem: item at " + num2 + " is missing item data!");
					}
					else if ((Object)(object)Server.objects[num2].physical == (Object)null)
					{
						(Server.objects[num2] as TrackedItemData).toPutInSosigInventory = new int[2]
						{
							num,
							(!flag) ? 1 : 0
						};
					}
					else
					{
						SosigPickUpPatch.skip++;
						if (flag)
						{
							trackedSosigData.physicalSosig.physicalSosig.Hand_Primary.PickUp(((Component)Server.objects[num2].physical).GetComponent<SosigWeapon>());
						}
						else
						{
							trackedSosigData.physicalSosig.physicalSosig.Hand_Secondary.PickUp(((Component)Server.objects[num2].physical).GetComponent<SosigWeapon>());
						}
						SosigPickUpPatch.skip--;
					}
				}
			}
			ServerSend.SosigPickUpItem(num, num2, flag, clientID);
		}

		public static void SosigPlaceItemIn(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			int num3 = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.inventory[num3 + 2] = num2;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					if (Server.objects[num2] == null)
					{
						Mod.LogError("SosigPickUpItem: item at " + num2 + " is missing item data!");
					}
					else if ((Object)(object)Server.objects[num2].physical == (Object)null)
					{
						(Server.objects[num2] as TrackedItemData).toPutInSosigInventory = new int[2]
						{
							num,
							num3 + 2
						};
					}
					else
					{
						SosigPlaceObjectInPatch.skip++;
						trackedSosigData.physicalSosig.physicalSosig.Inventory.Slots[num3].PlaceObjectIn(((Component)Server.objects[num2].physical).GetComponent<SosigWeapon>());
						SosigPlaceObjectInPatch.skip--;
					}
				}
			}
			ServerSend.SosigPlaceItemIn(num, num3, num2, clientID);
		}

		public static void SosigDropSlot(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.inventory[num2 + 2] = -1;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigSlotDetachPatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.Inventory.Slots[num2].DetachHeldObject();
					SosigSlotDetachPatch.skip--;
				}
			}
			ServerSend.SosigDropSlot(num, num2, clientID);
		}

		public static void SosigHandDrop(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.inventory[(!flag) ? 1u : 0u] = -1;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigHandDropPatch.skip++;
					if (flag)
					{
						trackedSosigData.physicalSosig.physicalSosig.Hand_Primary.DropHeldObject();
					}
					else
					{
						trackedSosigData.physicalSosig.physicalSosig.Hand_Secondary.DropHeldObject();
					}
					SosigHandDropPatch.skip--;
				}
			}
			ServerSend.SosigHandDrop(num, flag, clientID);
		}

		public static void SosigConfigure(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			SosigConfigTemplate val = packet.ReadSosigConfig();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.configTemplate = val;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigConfigurePatch.skipConfigure = true;
					trackedSosigData.physicalSosig.physicalSosig.Configure(val);
				}
			}
			ServerSend.SosigConfigure(num, val, clientID);
		}

		public static void SosigLinkRegisterWearable(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			string text = packet.ReadString();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				if (trackedSosigData.wearables == null)
				{
					trackedSosigData.wearables = new List<List<string>>();
					if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
					{
						foreach (SosigLink link in trackedSosigData.physicalSosig.physicalSosig.Links)
						{
							trackedSosigData.wearables.Add(new List<string>());
						}
					}
					else
					{
						while (trackedSosigData.wearables.Count <= b)
						{
							trackedSosigData.wearables.Add(new List<string>());
						}
					}
				}
				trackedSosigData.wearables[b].Add(text);
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					AnvilManager.Run(trackedSosigData.EquipWearable(b, text, skip: true));
				}
			}
			ServerSend.SosigLinkRegisterWearable(num, b, text, clientID);
		}

		public static void SosigLinkDeRegisterWearable(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			string text = packet.ReadString();
			if (num != -1 && Server.objects[num] is TrackedSosigData { wearables: not null } trackedSosigData)
			{
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					for (int i = 0; i < trackedSosigData.wearables[b].Count; i++)
					{
						if (trackedSosigData.wearables[b][i].Equals(text))
						{
							trackedSosigData.wearables[b].RemoveAt(i);
							if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
							{
								SosigLinkActionPatch.skipDeRegisterWearable++;
								trackedSosigData.physicalSosig.physicalSosig.Links[b].DeRegisterWearable(trackedSosigData.physicalSosig.physicalSosig.Links[b].m_wearables[i]);
								SosigLinkActionPatch.skipDeRegisterWearable--;
							}
							break;
						}
					}
				}
				else
				{
					trackedSosigData.wearables[b].Remove(text);
				}
			}
			ServerSend.SosigLinkDeRegisterWearable(num, b, text, clientID);
		}

		public static void SosigSetIFF(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte iFF = packet.ReadByte();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.IFF = iFF;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigIFFPatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.SetIFF((int)iFF);
					SosigIFFPatch.skip--;
				}
			}
			ServerSend.SosigSetIFF(num, iFF, clientID);
		}

		public static void SosigSetOriginalIFF(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.IFF = b;
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigIFFPatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.SetOriginalIFFTeam((int)b);
					SosigIFFPatch.skip--;
				}
			}
			ServerSend.SosigSetOriginalIFF(num, b, clientID);
		}

		public static void SosigLinkDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			if (trackedSosigData.controller == 0)
			{
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null && (Object)(object)trackedSosigData.physicalSosig.physicalSosig.Links[b] != (Object)null && !trackedSosigData.physicalSosig.physicalSosig.Links[b].IsExploded)
				{
					SosigLinkDamagePatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.Links[b].Damage(val);
					SosigLinkDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.SosigLinkDamage(trackedSosigData, b, val);
			}
		}

		public static void AutoMeaterDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData))
			{
				return;
			}
			if (trackedAutoMeaterData.controller == 0)
			{
				if ((Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
				{
					AutoMeaterDamagePatch.skip++;
					trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Damage(val);
					AutoMeaterDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.AutoMeaterDamage(trackedAutoMeaterData, val);
			}
		}

		public static void AutoMeaterHitZoneDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData))
			{
				return;
			}
			if (trackedAutoMeaterData.controller == 0)
			{
				if ((Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
				{
					AutoMeaterHitZoneDamagePatch.skip++;
					trackedAutoMeaterData.hitZones[(AMHitZoneType)b].Damage(val);
					AutoMeaterHitZoneDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.AutoMeaterHitZoneDamage(trackedAutoMeaterData, b, val);
			}
		}

		public static void EncryptionDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedEncryptionData trackedEncryptionData))
			{
				return;
			}
			if (trackedEncryptionData.controller == 0)
			{
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					EncryptionDamagePatch.skip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.Damage(val);
					EncryptionDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.EncryptionDamage(trackedEncryptionData, val);
			}
		}

		public static void AutoMeaterDamageData(int clientID, Packet packet)
		{
		}

		public static void SosigWearableDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			byte b2 = packet.ReadByte();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			if (trackedSosigData.controller == 0)
			{
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null && (Object)(object)trackedSosigData.physicalSosig.physicalSosig.Links[b] != (Object)null && !trackedSosigData.physicalSosig.physicalSosig.Links[b].IsExploded)
				{
					SosigWearableDamagePatch.skip++;
					trackedSosigData.physicalSosig.physicalSosig.Links[b].m_wearables[b2].Damage(val);
					SosigWearableDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.SosigWearableDamage(trackedSosigData, b, b2, val);
			}
		}

		public static void SosigDamageData(int clientID, Packet packet)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData { controller: not 0 } trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				Sosig physicalSosig = trackedSosigData.physicalSosig.physicalSosig;
				physicalSosig.m_isStunned = packet.ReadBool();
				physicalSosig.m_stunTimeLeft = packet.ReadFloat();
				physicalSosig.BodyState = (SosigBodyState)packet.ReadByte();
				physicalSosig.m_isOnOffMeshLink = packet.ReadBool();
				physicalSosig.Agent.autoTraverseOffMeshLink = packet.ReadBool();
				((Behaviour)physicalSosig.Agent).enabled = packet.ReadBool();
				List<CharacterJoint> joints = physicalSosig.m_joints;
				byte b = packet.ReadByte();
				for (int i = 0; i < joints.Count; i++)
				{
					if ((Object)(object)joints[i] != (Object)null)
					{
						SoftJointLimit val = joints[i].lowTwistLimit;
						((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
						joints[i].lowTwistLimit = val;
						val = joints[i].highTwistLimit;
						((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
						joints[i].highTwistLimit = val;
						val = joints[i].swing1Limit;
						((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
						joints[i].swing1Limit = val;
						val = joints[i].swing2Limit;
						((SoftJointLimit)(ref val)).limit = packet.ReadFloat();
						joints[i].swing2Limit = val;
					}
				}
				physicalSosig.m_isCountingDownToStagger = packet.ReadBool();
				physicalSosig.m_staggerAmountToApply = packet.ReadFloat();
				physicalSosig.m_recoveringFromBallisticState = packet.ReadBool();
				physicalSosig.m_recoveryFromBallisticLerp = packet.ReadFloat();
				physicalSosig.m_tickDownToWrithe = packet.ReadFloat();
				physicalSosig.m_recoveryFromBallisticTick = packet.ReadFloat();
				physicalSosig.m_lastIFFDamageSource = packet.ReadByte();
				physicalSosig.m_diedFromClass = (DamageClass)packet.ReadByte();
				physicalSosig.m_isBlinded = packet.ReadBool();
				physicalSosig.m_blindTime = packet.ReadFloat();
				physicalSosig.m_isFrozen = packet.ReadBool();
				physicalSosig.m_debuffTime_Freeze = packet.ReadFloat();
				physicalSosig.m_receivedHeadShot = packet.ReadBool();
				physicalSosig.m_timeSinceLastDamage = packet.ReadFloat();
				physicalSosig.m_isConfused = packet.ReadBool();
				physicalSosig.m_confusedTime = packet.ReadFloat();
				physicalSosig.m_storedShudder = packet.ReadFloat();
			}
			packet.readPos = 0;
			ServerSend.SosigLinkDamageData(packet);
		}

		public static void EncryptionDamageData(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedEncryptionData { controller: not 0 } trackedEncryptionData && (Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				trackedEncryptionData.physicalEncryption.physicalEncryption.m_numHitsLeft = packet.ReadInt();
			}
			packet.readPos = 0;
			ServerSend.EncryptionDamageData(packet);
		}

		public static void AutoMeaterHitZoneDamageData(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedAutoMeaterData { controller: not 0 } trackedAutoMeaterData && (Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
			{
				AutoMeaterHitZone val = trackedAutoMeaterData.hitZones[(AMHitZoneType)packet.ReadByte()];
				val.ArmorThreshold = packet.ReadFloat();
				val.LifeUntilFailure = packet.ReadFloat();
				if (packet.ReadBool())
				{
					val.BlowUp();
				}
			}
			packet.readPos = 0;
			ServerSend.AutoMeaterHitZoneDamageData(packet);
		}

		public static void SosigLinkExplodes(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				byte index = packet.ReadByte();
				SosigLinkActionPatch.skipLinkExplodes++;
				trackedSosigData.physicalSosig.physicalSosig.Links[index].LinkExplodes((DamageClass)packet.ReadByte());
				SosigLinkActionPatch.skipLinkExplodes--;
			}
			ServerSend.SosigLinkExplodes(packet, clientID);
		}

		public static void SosigDies(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				byte b = packet.ReadByte();
				byte b2 = packet.ReadByte();
				SosigPatch.sosigDiesSkip++;
				trackedSosigData.physicalSosig.physicalSosig.SosigDies((DamageClass)b, (SosigDeathType)b2);
				SosigPatch.sosigDiesSkip--;
			}
			ServerSend.SosigDies(packet, clientID);
		}

		public static void SosigClear(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				SosigPatch.sosigClearSkip++;
				trackedSosigData.physicalSosig.physicalSosig.ClearSosig();
				SosigPatch.sosigClearSkip--;
			}
			ServerSend.SosigClear(num, clientID);
		}

		public static void SosigSetBodyState(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			SosigBodyState val = (SosigBodyState)packet.ReadByte();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				SosigPatch.sosigSetBodyStateSkip++;
				trackedSosigData.physicalSosig.physicalSosig.SetBodyState(val);
				SosigPatch.sosigSetBodyStateSkip--;
			}
			ServerSend.SosigSetBodyState(num, val, clientID);
		}

		public static void PlaySosigFootStepSound(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FVRPooledAudioType val = (FVRPooledAudioType)packet.ReadByte();
			Vector3 val2 = packet.ReadVector3();
			Vector2 val3 = packet.ReadVector2();
			Vector2 val4 = packet.ReadVector2();
			float num2 = packet.ReadFloat();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				if (Mod.sosigFootstepAudioEvent == null)
				{
					Mod.sosigFootstepAudioEvent = (Server.objects[num].physical as TrackedSosig).physicalSosig.AudEvent_FootSteps;
				}
				SM.PlayCoreSoundDelayedOverrides(val, Mod.sosigFootstepAudioEvent, val2, val3, val4, num2);
			}
			ServerSend.PlaySosigFootStepSound(packet, clientID);
		}

		public static void SosigSpeakState(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected I4, but got Unknown
			int num = packet.ReadInt();
			SosigOrder val = (SosigOrder)packet.ReadByte();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null && (Object)(object)trackedSosigData.physicalSosig.physicalSosig.Speech != (Object)null)
			{
				SosigOrder val2 = val;
				SosigOrder val3 = val2;
				switch (val3 - 1)
				{
				case 0:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnWander);
					break;
				case 2:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnInvestigate);
					break;
				case 3:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnSearchingForGuns);
					break;
				case 4:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnTakingCover);
					break;
				case 5:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnWander);
					break;
				case 6:
					trackedSosigData.physicalSosig.physicalSosig.Speak_State(trackedSosigData.physicalSosig.physicalSosig.Speech.OnAssault);
					break;
				}
			}
			ServerSend.SosigSpeakState(num, val, clientID);
		}

		public static void SosigSetCurrentOrder(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected I4, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			SosigOrder val = (SosigOrder)packet.ReadByte();
			if (!(Server.objects[num] is TrackedSosigData trackedSosigData))
			{
				return;
			}
			trackedSosigData.currentOrder = val;
			SosigOrder val2 = val;
			SosigOrder val3 = val2;
			switch (val3 - 1)
			{
			case 0:
				trackedSosigData.guardPoint = packet.ReadVector3();
				trackedSosigData.guardDir = packet.ReadVector3();
				trackedSosigData.hardGuard = packet.ReadBool();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.CommandGuardPoint(trackedSosigData.guardPoint, trackedSosigData.hardGuard);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_guardDominantDirection = trackedSosigData.guardDir;
				}
				break;
			case 1:
				trackedSosigData.skirmishPoint = packet.ReadVector3();
				trackedSosigData.pathToPoint = packet.ReadVector3();
				trackedSosigData.assaultPoint = packet.ReadVector3();
				trackedSosigData.faceTowards = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_skirmishPoint = trackedSosigData.skirmishPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_pathToPoint = trackedSosigData.pathToPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_assaultPoint = trackedSosigData.assaultPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_faceTowards = trackedSosigData.faceTowards;
				}
				break;
			case 2:
				trackedSosigData.guardPoint = packet.ReadVector3();
				trackedSosigData.hardGuard = packet.ReadBool();
				trackedSosigData.faceTowards = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.UpdateGuardPoint(trackedSosigData.guardPoint);
					trackedSosigData.physicalSosig.physicalSosig.m_hardGuard = trackedSosigData.hardGuard;
					trackedSosigData.physicalSosig.physicalSosig.m_faceTowards = trackedSosigData.faceTowards;
				}
				break;
			case 3:
			case 5:
				trackedSosigData.wanderPoint = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_wanderPoint = trackedSosigData.wanderPoint;
				}
				break;
			case 6:
				trackedSosigData.assaultPoint = packet.ReadVector3();
				trackedSosigData.assaultSpeed = (SosigMoveSpeed)packet.ReadByte();
				trackedSosigData.faceTowards = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.CommandAssaultPoint(trackedSosigData.assaultPoint);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_faceTowards = trackedSosigData.faceTowards;
					trackedSosigData.physicalSosig.physicalSosig.SetAssaultSpeed(trackedSosigData.assaultSpeed);
				}
				break;
			case 8:
				trackedSosigData.idleToPoint = packet.ReadVector3();
				trackedSosigData.idleDominantDir = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.CommandIdle(trackedSosigData.idleToPoint, trackedSosigData.idleDominantDir);
					SosigPatch.sosigSetCurrentOrderSkip--;
				}
				break;
			case 9:
				trackedSosigData.pathToPoint = packet.ReadVector3();
				trackedSosigData.pathToLookDir = packet.ReadVector3();
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
					trackedSosigData.physicalSosig.physicalSosig.m_pathToPoint = trackedSosigData.pathToPoint;
					trackedSosigData.physicalSosig.physicalSosig.m_pathToLookDir = trackedSosigData.pathToLookDir;
				}
				break;
			default:
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					SosigPatch.sosigSetCurrentOrderSkip++;
					trackedSosigData.physicalSosig.physicalSosig.SetCurrentOrder(val);
					SosigPatch.sosigSetCurrentOrderSkip--;
				}
				break;
			}
			ServerSend.SosigSetCurrentOrder(trackedSosigData, val, clientID);
		}

		public static void SosigVaporize(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				SosigPatch.sosigVaporizeSkip++;
				trackedSosigData.physicalSosig.physicalSosig.Vaporize(trackedSosigData.physicalSosig.physicalSosig.DamageFX_Vaporize, (int)b);
				SosigPatch.sosigVaporizeSkip--;
			}
			ServerSend.SosigVaporize(num, b, clientID);
		}

		public static void SosigRequestHitDecal(int clientID, Packet packet)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				Vector3 val = packet.ReadVector3();
				Vector3 val2 = packet.ReadVector3();
				Vector3 val3 = packet.ReadVector3();
				float num2 = packet.ReadFloat();
				byte index = packet.ReadByte();
				SosigPatch.sosigRequestHitDecalSkip++;
				trackedSosigData.physicalSosig.physicalSosig.RequestHitDecal(val, val2, val3, num2, trackedSosigData.physicalSosig.physicalSosig.Links[index]);
				SosigPatch.sosigRequestHitDecalSkip--;
			}
			ServerSend.SosigRequestHitDecal(packet, clientID);
		}

		public static void SosigLinkBreak(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			bool flag = packet.ReadBool();
			byte b2 = packet.ReadByte();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				SosigLinkActionPatch.sosigLinkBreakSkip++;
				trackedSosigData.physicalSosig.physicalSosig.Links[b].BreakJoint(flag, (DamageClass)b2);
				SosigLinkActionPatch.sosigLinkBreakSkip--;
			}
			ServerSend.SosigLinkBreak(num, b, flag, b2, clientID);
		}

		public static void SosigLinkSever(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			byte b2 = packet.ReadByte();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				SosigLinkActionPatch.sosigLinkSeverSkip++;
				trackedSosigData.physicalSosig.physicalSosig.Links[b].SeverJoint((DamageClass)b2, flag);
				SosigLinkActionPatch.sosigLinkSeverSkip--;
			}
			ServerSend.SosigLinkSever(num, b, b2, flag, clientID);
		}

		public static void UpToDateObjects(int clientID, Packet packet)
		{
			bool flag = packet.ReadBool();
			int num = packet.ReadInt();
			TrackedObjectData trackedObjectData = Server.objects[num];
			if (trackedObjectData == null)
			{
				Mod.LogWarning("Server received up to date object at " + num + " but we do not have data.");
				return;
			}
			trackedObjectData.UpdateFromPacket(packet, full: true);
			if (flag && (Object)(object)trackedObjectData.physical == (Object)null && !trackedObjectData.awaitingInstantiation && trackedObjectData.scene.Equals(GameManager.scene) && trackedObjectData.instance == GameManager.instance && trackedObjectData.IsIdentifiable())
			{
				trackedObjectData.awaitingInstantiation = true;
				AnvilManager.Run(trackedObjectData.Instantiate());
			}
		}

		public static void DoneLoadingScene(int clientID, Packet packet)
		{
			if (!Server.loadingClientsWaitingFrom.TryGetValue(clientID, out var value))
			{
				return;
			}
			bool flag = false;
			foreach (int item in value)
			{
				if (Server.clientsWaitingUpDate.TryGetValue(item, out var value2) && value2.Contains(clientID))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Server.clients[clientID].SendRelevantTrackedObjects();
			}
			Server.loadingClientsWaitingFrom.Remove(clientID);
		}

		public static void DoneSendingUpToDateObjects(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!Server.clientsWaitingUpDate.TryGetValue(clientID, out var value))
			{
				return;
			}
			if (num == 0)
			{
				value.Remove(num);
				if (value.Count == 0)
				{
					Server.clientsWaitingUpDate.Remove(clientID);
				}
				if (!Server.loadingClientsWaitingFrom.TryGetValue(num, out var value2))
				{
					return;
				}
				value2.Remove(clientID);
				if (value2.Count != 0)
				{
					return;
				}
				Server.loadingClientsWaitingFrom.Remove(num);
				if (!GameManager.objectsByInstanceByScene.TryGetValue(GameManager.scene, out var value3) || !value3.TryGetValue(GameManager.instance, out var value4))
				{
					return;
				}
				for (int i = 0; i < value4.Count; i++)
				{
					TrackedObjectData trackedObjectData = Server.objects[value4[i]];
					if (trackedObjectData != null && (Object)(object)trackedObjectData.physical == (Object)null && !trackedObjectData.awaitingInstantiation)
					{
						trackedObjectData.awaitingInstantiation = true;
						AnvilManager.Run(trackedObjectData.Instantiate());
					}
				}
				return;
			}
			Server.clients[num].SendRelevantTrackedObjects(clientID);
			value.Remove(num);
			if (value.Count == 0)
			{
				Server.clientsWaitingUpDate.Remove(clientID);
			}
			if (Server.loadingClientsWaitingFrom.TryGetValue(num, out var value5))
			{
				value5.Remove(clientID);
				if (value5.Count == 0)
				{
					Server.loadingClientsWaitingFrom.Remove(num);
					Server.clients[num].SendRelevantTrackedObjects();
				}
			}
		}

		public static void AddTNHCurrentlyPlaying(int clientID, Packet packet)
		{
			int key = packet.ReadInt();
			Mod.LogInfo("ServerHandle: Received AddTNHCurrentlyPlaying for instance: " + key + " to add " + clientID, debug: false);
			if (GameManager.TNHInstances == null || !GameManager.TNHInstances.ContainsKey(key))
			{
				Mod.LogError("ServerHandle: Received AddTNHCurrentlyPlaying packet with missing instance");
			}
			else
			{
				GameManager.TNHInstances[key].AddCurrentlyPlaying(send: true, clientID, fromServer: true);
			}
		}

		public static void RemoveTNHCurrentlyPlaying(int clientID, Packet packet)
		{
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.RemoveCurrentlyPlaying(send: true, clientID, fromServer: true);
			}
		}

		public static void SetTNHProgression(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].progressionTypeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.progressionSkip++;
				Mod.currentTNHUIManager.OBS_Progression.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_Progression(num);
				GM.TNHOptions.ProgressionTypeSetting = (TNHSetting_ProgressionType)num;
				TNH_UIManagerPatch.progressionSkip--;
			}
			ServerSend.SetTNHProgression(num, num2, clientID);
		}

		public static void SetTNHEquipment(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].equipmentModeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.equipmentSkip++;
				Mod.currentTNHUIManager.OBS_Progression.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_EquipmentMode(num);
				GM.TNHOptions.EquipmentModeSetting = (TNHSetting_EquipmentMode)num;
				TNH_UIManagerPatch.equipmentSkip--;
			}
			ServerSend.SetTNHEquipment(num, num2, clientID);
		}

		public static void SetTNHHealthMode(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].healthModeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.healthModeSkip++;
				Mod.currentTNHUIManager.OBS_HealthMode.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_HealthMode(num);
				GM.TNHOptions.HealthModeSetting = (TNHSetting_HealthMode)num;
				TNH_UIManagerPatch.healthModeSkip--;
			}
			ServerSend.SetTNHHealthMode(num, num2, clientID);
		}

		public static void SetTNHTargetMode(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].targetModeSetting = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.targetSkip++;
				Mod.currentTNHUIManager.OBS_TargetMode.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_TargetMode(num);
				GM.TNHOptions.TargetModeSetting = (TNHSetting_TargetMode)num;
				TNH_UIManagerPatch.targetSkip--;
			}
			ServerSend.SetTNHTargetMode(num, num2, clientID);
		}

		public static void SetTNHAIDifficulty(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].AIDifficultyModifier = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.AIDifficultySkip++;
				Mod.currentTNHUIManager.OBS_AIDifficulty.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_AIDifficulty(num);
				GM.TNHOptions.AIDifficultyModifier = (TNHModifier_AIDifficulty)num;
				TNH_UIManagerPatch.AIDifficultySkip--;
			}
			ServerSend.SetTNHAIDifficulty(num, num2, clientID);
		}

		public static void SetTNHRadarMode(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].radarModeModifier = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.radarSkip++;
				Mod.currentTNHUIManager.OBS_AIRadarMode.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_AIRadarMode(num);
				GM.TNHOptions.RadarModeModifier = (TNHModifier_RadarMode)num;
				TNH_UIManagerPatch.radarSkip--;
			}
			ServerSend.SetTNHRadarMode(num, num2, clientID);
		}

		public static void SetTNHItemSpawnerMode(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].itemSpawnerMode = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.itemSpawnerSkip++;
				Mod.currentTNHUIManager.OBS_ItemSpawner.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_ItemSpawner(num);
				GM.TNHOptions.ItemSpawnerMode = (TNH_ItemSpawnerMode)num;
				TNH_UIManagerPatch.itemSpawnerSkip--;
			}
			ServerSend.SetTNHItemSpawnerMode(num, num2, clientID);
		}

		public static void SetTNHBackpackMode(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].backpackMode = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.backpackSkip++;
				Mod.currentTNHUIManager.OBS_Backpack.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_Backpack(num);
				GM.TNHOptions.BackpackMode = (TNH_BackpackMode)num;
				TNH_UIManagerPatch.backpackSkip--;
			}
			ServerSend.SetTNHBackpackMode(num, num2, clientID);
		}

		public static void SetTNHHealthMult(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].healthMult = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.healthMultSkip++;
				Mod.currentTNHUIManager.OBS_HealthMult.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_HealthMult(num);
				GM.TNHOptions.HealthMult = (TNH_HealthMult)num;
				TNH_UIManagerPatch.healthMultSkip--;
			}
			ServerSend.SetTNHHealthMult(num, num2, clientID);
		}

		public static void SetTNHSosigGunReload(int clientID, Packet packet)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].sosiggunShakeReloading = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.sosigGunReloadSkip++;
				Mod.currentTNHUIManager.OBS_SosiggunReloading.SetSelectedButton(num);
				Mod.currentTNHUIManager.SetOBS_SosiggunShakeReloading(num);
				GM.TNHOptions.SosiggunShakeReloading = (TNH_SosiggunShakeReloading)num;
				TNH_UIManagerPatch.sosigGunReloadSkip--;
			}
			ServerSend.SetTNHSosigGunReload(num, num2, clientID);
		}

		public static void SetTNHSeed(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			GameManager.TNHInstances[num2].TNHSeed = num;
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num2 && (Object)(object)Mod.currentTNHUIManager != (Object)null)
			{
				TNH_UIManagerPatch.seedSkip++;
				Mod.currentTNHUIManager.OBS_RunSeed.SetSelectedButton(num + 1);
				Mod.currentTNHUIManager.SetOBS_RunSeed(num);
				GM.TNHOptions.TNHSeed = num;
				TNH_UIManagerPatch.seedSkip--;
			}
			ServerSend.SetTNHSeed(num, num2, clientID);
		}

		public static void SetTNHLevelID(int clientID, Packet packet)
		{
			string text = packet.ReadString();
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.levelID = text;
				if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num && (Object)(object)Mod.currentTNHUIManager != (Object)null)
				{
					bool flag = false;
					for (int i = 0; i < Mod.currentTNHUIManager.Levels.Count; i++)
					{
						if (Mod.currentTNHUIManager.Levels[i].LevelID.Equals(text))
						{
							flag = true;
							Mod.currentTNHUIManager._currentLevelIndex = i;
							Mod.currentTNHUIManager.CurrentLevel.LevelID = text;
							Mod.currentTNHUIManager.UpdateLevelSelectUi();
							Mod.currentTNHUIManager.UpdateTableBasedOnOptions();
							Mod.currentTNHUIManager.PlayButtonSound(2);
							((Component)Mod.currentTNHSceneLoader).gameObject.SetActive(true);
							break;
						}
					}
					if (!flag)
					{
						((Component)Mod.currentTNHSceneLoader).gameObject.SetActive(false);
						Mod.LogError("Missing TNH level: " + text + "! Make sure you have it installed.");
					}
				}
			}
			ServerSend.SetTNHLevelID(text, num, clientID);
		}

		public static void SetTNHController(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			Mod.LogInfo("Server received order to set TNH instance: " + num + " controller to: " + num2, debug: false);
			GameManager.TNHInstances[num].controller = num2;
			ServerSend.SetTNHController(num, num2, clientID);
		}

		public static void TNHPlayerDied(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			TNHInstance tNHInstance = GameManager.TNHInstances[num];
			tNHInstance.dead.Add(num2);
			bool flag = true;
			for (int i = 0; i < tNHInstance.currentlyPlaying.Count; i++)
			{
				if (!tNHInstance.dead.Contains(tNHInstance.currentlyPlaying[i]))
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				foreach (int item in tNHInstance.dead)
				{
					if (GameManager.players.TryGetValue(item, out var value))
					{
						value.SetVisible(visible: true);
					}
				}
				tNHInstance.Reset();
			}
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num && Mod.currentlyPlayingTNH)
			{
				PlayerManager value2;
				if (flag)
				{
					Mod.currentTNHInstance.manager.m_patrolSquads.Clear();
				}
				else if (GameManager.players.TryGetValue(num2, out value2))
				{
					value2.SetVisible(visible: false);
					if (Mod.currentTNHInstance != null && (Object)(object)Mod.currentTNHInstance.manager != (Object)null && (Object)(object)Mod.currentTNHInstance.manager.TAHReticle != (Object)null && (Object)(object)value2.reticleContact != (Object)null)
					{
						for (int j = 0; j < Mod.currentTNHInstance.manager.TAHReticle.Contacts.Count; j++)
						{
							if ((Object)(object)Mod.currentTNHInstance.manager.TAHReticle.Contacts[j] == (Object)(object)value2.reticleContact)
							{
								GM.TNH_Manager.TAHReticle.m_trackedTransforms.Remove(GM.TNH_Manager.TAHReticle.Contacts[j].TrackedTransform);
								Object.Destroy((Object)(object)((Component)Mod.currentTNHInstance.manager.TAHReticle.Contacts[j]).gameObject);
								Mod.currentTNHInstance.manager.TAHReticle.Contacts.RemoveAt(j);
								value2.reticleContact = null;
								break;
							}
						}
					}
				}
			}
			ServerSend.TNHPlayerDied(num, num2, clientID);
		}

		public static void TNHAddTokens(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.tokenCount += num2;
				if ((Object)(object)value.manager != (Object)null && !value.dead.Contains(GameManager.ID))
				{
					TNH_ManagerPatch.addTokensSkip++;
					value.manager.AddTokens(num2, false);
					TNH_ManagerPatch.addTokensSkip--;
				}
			}
			ServerSend.TNHAddTokens(num, num2, clientID);
		}

		public static void AutoMeaterSetState(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			byte b = packet.ReadByte();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				AutoMeaterSetStatePatch.skip++;
				(Server.objects[num].physical as TrackedAutoMeater).physicalAutoMeater.SetState((AutoMeaterState)b);
				AutoMeaterSetStatePatch.skip--;
			}
			ServerSend.AutoMeaterSetState(num, b, clientID);
		}

		public static void AutoMeaterSetBladesActive(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData && (Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
			{
				if (flag)
				{
					for (int i = 0; i < trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades.Count; i++)
					{
						trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades[i].Reactivate();
					}
				}
				else
				{
					for (int j = 0; j < trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades.Count; j++)
					{
						trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.Blades[j].ShutDown();
					}
				}
			}
			ServerSend.AutoMeaterSetBladesActive(num, flag, clientID);
		}

		public static void AutoMeaterFirearmFireAtWill(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			bool flag = packet.ReadBool();
			float num3 = packet.ReadFloat();
			if (Server.objects[num] is TrackedAutoMeaterData trackedAutoMeaterData && (Object)(object)trackedAutoMeaterData.physicalAutoMeater != (Object)null)
			{
				AutoMeaterFirearmFireAtWillPatch.skip++;
				trackedAutoMeaterData.physicalAutoMeater.physicalAutoMeater.FireControl.Firearms[num2].SetFireAtWill(flag, num3);
				AutoMeaterFirearmFireAtWillPatch.skip--;
			}
			ServerSend.AutoMeaterFirearmFireAtWill(num, num2, flag, num3, clientID);
		}

		public static void TNHSosigKill(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num && (Object)(object)Mod.currentTNHInstance.manager != (Object)null && Server.objects[num2] is TrackedSosigData trackedSosigData && (Object)(object)trackedSosigData.physicalSosig != (Object)null)
			{
				TNH_ManagerPatch.sosigKillSkip++;
				Mod.currentTNHInstance.manager.OnSosigKill(trackedSosigData.physicalSosig.physicalSosig);
				TNH_ManagerPatch.sosigKillSkip--;
			}
			ServerSend.TNHSosigKill(num, num2, clientID);
		}

		public static void TNHHoldPointSystemNode(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			int num3 = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.curHoldIndex = num3;
				value.level = num2;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.manager.SetLevel(num2);
				}
			}
			ServerSend.TNHHoldPointSystemNode(num, num2, num3, clientID);
		}

		public static void TNHHoldBeginChallenge(int clientID, Packet packet)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			Mod.LogInfo("TNHHoldBeginChallenge server handle from " + clientID + " which is controller?: " + flag + ", for instance: " + num, debug: false);
			if (flag)
			{
				if (GameManager.TNHInstances.TryGetValue(num, out var value))
				{
					value.holdOngoing = true;
					Mod.currentTNHInstance.holdState = (HoldState)0;
					if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
					{
						TNH_HoldPointPatch.beginHoldSendSkip++;
						Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasActivated = true;
						Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasInitiatedHold = true;
						Mod.currentTNHInstance.manager.m_curHoldPoint.BeginHoldChallenge();
						TNH_HoldPointPatch.beginHoldSendSkip--;
						if (!value.dead.Contains(GameManager.ID) || Mod.TNHOnDeathSpectate)
						{
							GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.m_curHoldPoint.SpawnPoint_SystemNode.position, true);
						}
					}
				}
				Mod.LogInfo("\tRelaying to all", debug: false);
				ServerSend.TNHHoldBeginChallenge(num, controller: true, toAll: true, clientID);
			}
			else
			{
				if (!GameManager.TNHInstances.TryGetValue(num, out var value2))
				{
					return;
				}
				if (value2.controller == GameManager.ID)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasActivated = true;
					Mod.currentTNHInstance.manager.m_curHoldPoint.m_systemNode.m_hasInitiatedHold = true;
					Mod.currentTNHInstance.manager.m_curHoldPoint.BeginHoldChallenge();
					if (!value2.dead.Contains(GameManager.ID) || Mod.TNHOnDeathSpectate)
					{
						GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.m_curHoldPoint.SpawnPoint_SystemNode.position, true);
					}
				}
				else
				{
					Mod.LogInfo("\tRelaying to controller: " + value2.controller, debug: false);
					ServerSend.TNHHoldBeginChallenge(num, controller: false, toAll: false, value2.controller);
				}
			}
		}

		public static void TNHHoldPointRaiseBarriers(int clientID, Packet packet)
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				int num = packet.ReadInt();
				value.raisedBarriers = new List<int>();
				value.raisedBarrierPrefabIndices = new List<int>();
				for (int i = 0; i < num; i++)
				{
					value.raisedBarriers.Add(packet.ReadInt());
				}
				for (int j = 0; j < num; j++)
				{
					value.raisedBarrierPrefabIndices.Add(packet.ReadInt());
				}
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					for (int k = 0; k < value.raisedBarriers.Count; k++)
					{
						TNH_DestructibleBarrierPoint val = value.manager.m_curHoldPoint.BarrierPoints[value.raisedBarriers[k]];
						BarrierDataSet val2 = val.BarrierDataSets[value.raisedBarrierPrefabIndices[k]];
						GameObject val3 = Object.Instantiate<GameObject>(val2.BarrierPrefab, ((Component)val).transform.position, ((Component)val).transform.rotation);
						TNH_DestructibleBarrier val4 = (val.m_curBarrier = val3.GetComponent<TNH_DestructibleBarrier>());
						val4.InitToPlace(((Component)val).transform.position, ((Component)val).transform.forward);
						val4.SetBarrierPoint(val);
						val.SetCoverPointData(value.raisedBarrierPrefabIndices[k]);
					}
				}
			}
			ServerSend.TNHHoldPointRaiseBarriers(clientID, packet);
		}

		public static void ShatterableCrateSetHoldingHealth(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] != null)
			{
				TrackedItemData trackedItemData = Server.objects[num] as TrackedItemData;
				if (trackedItemData.additionalData.Length == 40)
				{
					trackedItemData.additionalData[37] = 1;
					if ((Object)(object)trackedItemData.physical != (Object)null)
					{
						Object dataObject = trackedItemData.physicalItem.dataObject;
						UberShatterable val = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
						if ((Object)(object)val != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
						{
							val.SpawnOnShatter.Clear();
							val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
							val.SpawnOnShatterPoints.Add(((Component)val).transform);
							val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
							val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_HealthMinor);
							val.SpawnOnShatterPoints.Add(((Component)val).transform);
							val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)2);
						}
					}
				}
				else
				{
					trackedItemData.additionalData[3] = 1;
					if ((Object)(object)trackedItemData.physical != (Object)null)
					{
						TNH_ShatterableCrateSetHoldingHealthPatch.skip++;
						((Component)trackedItemData.physical).GetComponent<TNH_ShatterableCrate>().SetHoldingHealth(GM.TNH_Manager);
						TNH_ShatterableCrateSetHoldingHealthPatch.skip--;
					}
				}
			}
			ServerSend.ShatterableCrateSetHoldingHealth(num, clientID);
		}

		public static void ShatterableCrateSetHoldingToken(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] != null)
			{
				TrackedItemData trackedItemData = Server.objects[num] as TrackedItemData;
				if (trackedItemData.additionalData.Length == 40)
				{
					trackedItemData.additionalData[38] = 1;
					if ((Object)(object)trackedItemData.physical != (Object)null)
					{
						Object dataObject = trackedItemData.physicalItem.dataObject;
						UberShatterable val = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
						if ((Object)(object)val != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
						{
							val.SpawnOnShatter.Clear();
							val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
							val.SpawnOnShatterPoints.Add(((Component)val).transform);
							val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
							val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Token);
							val.SpawnOnShatterPoints.Add(((Component)val).transform);
							val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)2);
						}
					}
				}
				else
				{
					trackedItemData.additionalData[4] = 1;
					if ((Object)(object)trackedItemData.physical != (Object)null)
					{
						TNH_ShatterableCrateSetHoldingTokenPatch.skip++;
						((Component)trackedItemData.physical).GetComponent<TNH_ShatterableCrate>().SetHoldingToken(GM.TNH_Manager);
						TNH_ShatterableCrateSetHoldingTokenPatch.skip--;
					}
				}
			}
			ServerSend.ShatterableCrateSetHoldingToken(num, clientID);
		}

		public static void ShatterableCrateSetUsesLoot(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] != null)
			{
				TrackedItemData trackedItemData = Server.objects[num] as TrackedItemData;
				if (trackedItemData.additionalData.Length == 40)
				{
					trackedItemData.additionalData[39] = 1;
					if ((Object)(object)trackedItemData.physical != (Object)null)
					{
						Object dataObject = trackedItemData.physicalItem.dataObject;
						UberShatterable val = (UberShatterable)(object)((dataObject is UberShatterable) ? dataObject : null);
						if ((Object)(object)val != (Object)null && (Object)(object)GM.TNH_Manager != (Object)null)
						{
							val.SpawnOnShatter.Clear();
							val.SpawnOnShatter.Add(GM.TNH_Manager.ResourceLib.Prefab_Crate_Full);
							val.SpawnOnShatterPoints.Add(((Component)val).transform);
							val.SpawnOnShatterRotTypes.Add((SpawnOnShatterRotationType)1);
							val.SetUsesLoot();
						}
					}
				}
				else
				{
					trackedItemData.additionalData[5] = 1;
					if ((Object)(object)trackedItemData.physical != (Object)null)
					{
						TNH_ShatterableCrateSetHoldingTokenPatch.skip++;
						((Component)trackedItemData.physical).GetComponent<TNH_ShatterableCrate>().SetUsesLoot(GM.TNH_Manager);
						TNH_ShatterableCrateSetHoldingTokenPatch.skip--;
					}
				}
			}
			ServerSend.ShatterableCrateSetUsesLoot(num, clientID);
		}

		public static void ShatterableCrateDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] == null)
			{
				return;
			}
			if (Server.objects[num].controller == GameManager.ID)
			{
				if ((Object)(object)Server.objects[num].physical != (Object)null)
				{
					TNH_ShatterableCrateDamagePatch.skip++;
					((Component)Server.objects[num].physical).GetComponent<TNH_ShatterableCrate>().Damage(packet.ReadDamage());
					TNH_ShatterableCrateDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.ShatterableCrateDamage(num, packet.ReadDamage());
			}
		}

		public static void ShatterableCrateDestroy(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				TNH_ShatterableCrate componentInChildren = ((Component)Server.objects[num].physical).GetComponentInChildren<TNH_ShatterableCrate>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					Mod.LogError("Received order to destroy shatterable crate for which we have physObj but it has not crate script!");
				}
				else
				{
					TNH_ShatterableCrateDestroyPatch.skip++;
					componentInChildren.Destroy(val);
					TNH_ShatterableCrateDestroyPatch.skip--;
				}
			}
			ServerSend.ShatterableCrateDestroy(num, val, clientID);
		}

		public static void TNHSetLevel(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int level = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.level = level;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.level = level;
					value.manager.m_level = level;
					value.manager.SetLevel(level);
				}
			}
			ServerSend.TNHSetLevel(num, level, clientID);
		}

		public static void TNHSetPhaseTake(int clientID, Packet packet)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			int num3 = packet.ReadInt();
			List<int> list = new List<int>();
			for (int i = 0; i < num3; i++)
			{
				list.Add(packet.ReadInt());
			}
			bool flag = packet.ReadBool();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.curHoldIndex = num2;
				value.phase = (TNH_Phase)0;
				value.activeSupplyPointIndices = list;
				if (!flag && (Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.SetPhase_Take();
				}
			}
			ServerSend.TNHSetPhaseTake(num, num2, list, flag, clientID);
		}

		public static void TNHSetPhaseHold(int clientID, Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.phase = (TNH_Phase)1;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.SetPhase_Hold();
				}
			}
			ServerSend.TNHSetPhaseHold(num, clientID);
		}

		public static void TNHHoldCompletePhase(int clientID, Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.holdState = (HoldState)3;
				value.raisedBarriers = null;
				value.raisedBarrierPrefabIndices = null;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.CompletePhase();
				}
			}
			ServerSend.TNHHoldCompletePhase(num, clientID);
		}

		public static void TNHHoldPointFailOut(int clientID, Packet packet)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.holdOngoing = false;
				value.holdState = (HoldState)0;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.FailOut();
				}
			}
			ServerSend.TNHHoldPointFailOut(num, clientID);
		}

		public static void TNHHoldPointBeginPhase(int clientID, Packet packet)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.holdOngoing = true;
				value.holdState = (HoldState)0;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.BeginPhase();
				}
			}
			ServerSend.TNHHoldPointBeginPhase(num, clientID);
		}

		public static void TNHHoldPointCompleteHold(int clientID, Packet packet)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.holdOngoing = false;
				value.holdState = (HoldState)0;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					Mod.currentTNHInstance.manager.m_curHoldPoint.CompleteHold();
				}
			}
			ServerSend.TNHHoldPointCompleteHold(num, clientID);
		}

		public static void TNHSetPhaseComplete(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				if ((Object)(object)value.manager != (Object)null)
				{
					Mod.currentTNHInstance.manager.SetPhase_Completed();
				}
				value.Reset();
			}
			ServerSend.TNHSetPhaseComplete(num, clientID);
		}

		public static void TNHSetPhase(int clientID, Packet packet)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			short num2 = packet.ReadShort();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.phase = (TNH_Phase)num2;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					value.manager.Phase = (TNH_Phase)num2;
				}
			}
			ServerSend.TNHSetPhase(num, num2, clientID);
		}

		public static void EncryptionRespawnSubTarg(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.subTargsActive[num2] = true;
				if ((Object)(object)trackedEncryptionData.physical != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[num2].SetActive(true);
					TNH_EncryptionTarget physicalEncryption = trackedEncryptionData.physicalEncryption.physicalEncryption;
					physicalEncryption.m_numSubTargsLeft++;
				}
			}
			ServerSend.EncryptionRespawnSubTarg(num, num2, clientID);
		}

		public static void EncryptionRespawnSubTargGeo(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.subTargGeosActive[num2] = true;
				trackedEncryptionData.subTargsActive[num2] = true;
				if ((Object)(object)trackedEncryptionData.physical != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[num2].SetActive(true);
					((Component)trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargGeo[num2]).gameObject.SetActive(true);
					TNH_EncryptionTarget physicalEncryption = trackedEncryptionData.physicalEncryption.physicalEncryption;
					physicalEncryption.m_numSubTargsLeft++;
				}
			}
			ServerSend.EncryptionRespawnSubTarg(num, num2, clientID);
		}

		public static void EncryptionSpawnGrowth(int clientID, Packet packet)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.subTargsActive[num2] = true;
				if ((Object)(object)trackedEncryptionData.physical != (Object)null)
				{
					Vector3 val2 = val - trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].transform.position;
					EncryptionSpawnGrowthPatch.skip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.SpawnGrowth(num2, val);
					EncryptionSpawnGrowthPatch.skip--;
					trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].transform.localScale = new Vector3(0.2f, 0.2f, ((Vector3)(ref val2)).magnitude * trackedEncryptionData.physicalEncryption.physicalEncryption.TendrilFloats[num2]);
				}
			}
			ServerSend.EncryptionSpawnGrowth(num, num2, val, clientID);
		}

		public static void EncryptionInit(int clientID, Packet packet)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			List<int> list = new List<int>();
			for (int i = 0; i < num2; i++)
			{
				list.Add(packet.ReadInt());
			}
			Vector3 initialPos = packet.ReadVector3();
			int num3 = packet.ReadInt();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				for (int j = 0; j < num2; j++)
				{
					trackedEncryptionData.subTargsActive[list[j]] = true;
				}
				if ((Object)(object)trackedEncryptionData.physical != (Object)null)
				{
					EncryptionSpawnGrowthPatch.skip++;
					for (int k = 0; k < num2; k++)
					{
						trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[list[k]].SetActive(true);
					}
					EncryptionSpawnGrowthPatch.skip--;
					trackedEncryptionData.physicalEncryption.physicalEncryption.m_numSubTargsLeft = num2;
				}
				trackedEncryptionData.initialPos = initialPos;
				if ((Object)(object)trackedEncryptionData.physical != (Object)null && trackedEncryptionData.physicalEncryption.physicalEncryption.UseReturnToSpawnForce)
				{
					if ((Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.m_returnToSpawnLine != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)trackedEncryptionData.physicalEncryption.physicalEncryption.m_returnToSpawnLine).gameObject);
					}
					trackedEncryptionData.physicalEncryption.physicalEncryption.initialPos = initialPos;
					GameObject val = Object.Instantiate<GameObject>(trackedEncryptionData.physicalEncryption.physicalEncryption.ReturnToSpawnLineGO, ((Component)trackedEncryptionData.physicalEncryption).transform.position, Quaternion.identity);
					trackedEncryptionData.physicalEncryption.physicalEncryption.m_returnToSpawnLine = val.transform;
					trackedEncryptionData.physicalEncryption.physicalEncryption.UpdateLine();
				}
				trackedEncryptionData.numHitsLeft = num3;
				if ((Object)(object)trackedEncryptionData.physical != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.m_numHitsLeft = num3;
					if (trackedEncryptionData.physicalEncryption.physicalEncryption.UsesMultipleDisplay && trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList.Count > num3 && (Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList[num3] != (Object)null)
					{
						EncryptionPatch.updateDisplaySkip++;
						trackedEncryptionData.physicalEncryption.physicalEncryption.UpdateDisplay();
						EncryptionPatch.updateDisplaySkip--;
					}
				}
			}
			ServerSend.EncryptionInit(clientID, num, list, initialPos, num3);
		}

		public static void EncryptionResetGrowth(int clientID, Packet packet)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				Vector3 val2 = val - trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].transform.position;
				EncryptionResetGrowthPatch.skip++;
				trackedEncryptionData.physicalEncryption.physicalEncryption.ResetGrowth(num2, val);
				EncryptionResetGrowthPatch.skip--;
			}
			ServerSend.EncryptionResetGrowth(num, num2, val, clientID);
		}

		public static void EncryptionDisableSubtarg(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.subTargsActive[num2] = false;
				if (trackedEncryptionData.subTargGeosActive != null && trackedEncryptionData.subTargGeosActive.Length > num2)
				{
					trackedEncryptionData.subTargGeosActive[num2] = false;
				}
				if ((Object)(object)trackedEncryptionData.physical != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[num2].SetActive(false);
					if (trackedEncryptionData.physicalEncryption.physicalEncryption.UsesRegeneratingSubtargs)
					{
						((Component)trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargGeo[num2]).gameObject.SetActive(false);
					}
					if (trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils != null && trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils.Count > num2)
					{
						trackedEncryptionData.physicalEncryption.physicalEncryption.Tendrils[num2].SetActive(false);
					}
					TNH_EncryptionTarget physicalEncryption = trackedEncryptionData.physicalEncryption.physicalEncryption;
					physicalEncryption.m_numSubTargsLeft--;
				}
			}
			ServerSend.EncryptionDisableSubtarg(num, num2, clientID);
		}

		public static void EncryptionSubDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int index = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedEncryptionData trackedEncryptionData))
			{
				return;
			}
			if (trackedEncryptionData.controller == 0)
			{
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					EncryptionSubDamagePatch.skip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.SubTargs[index].GetComponent<TNH_EncryptionTarget_SubTarget>().Damage(val);
					EncryptionSubDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.EncryptionSubDamage(trackedEncryptionData, index, val);
			}
		}

		public static void SosigWeaponDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					SosigWeaponDamagePatch.skip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((SosigWeaponPlayerInterface)((physicalItem is SosigWeaponPlayerInterface) ? physicalItem : null)).W.Damage(val);
					SosigWeaponDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.SosigWeaponDamage(trackedItemData, val);
			}
		}

		public static void RemoteMissileDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					RemoteMissile missile = ((RemoteMissileLauncher)((physicalItem is RemoteMissileLauncher) ? physicalItem : null)).m_missile;
					if ((Object)(object)missile != (Object)null)
					{
						RemoteMissileDamagePatch.skip++;
						missile.Damage(packet.ReadDamage());
						RemoteMissileDamagePatch.skip--;
					}
				}
			}
			else
			{
				ServerSend.RemoteMissileDamage(trackedItemData, packet);
			}
		}

		public static void StingerMissileDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					StingerMissile stingerMissile = trackedItemData.physicalItem.stingerMissile;
					if ((Object)(object)stingerMissile != (Object)null)
					{
						StingerMissileDamagePatch.skip++;
						stingerMissile.Damage(packet.ReadDamage());
						StingerMissileDamagePatch.skip--;
					}
				}
			}
			else
			{
				ServerSend.StingerMissileDamage(trackedItemData, packet);
			}
		}

		public static void TNHHoldPointBeginAnalyzing(int clientID, Packet packet)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			int key = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(key, out var value))
			{
				value.tickDownToID = packet.ReadFloat();
				value.holdState = (HoldState)1;
				value.warpInData = new List<Vector3>();
				byte b = packet.ReadByte();
				for (int i = 0; i < b; i++)
				{
					value.warpInData.Add(packet.ReadVector3());
				}
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					GM.TNH_Manager.m_curHoldPoint.BeginAnalyzing();
					for (int j = 0; j < b; j += 2)
					{
						GM.TNH_Manager.m_curHoldPoint.m_warpInTargets.Add(Object.Instantiate<GameObject>(GM.TNH_Manager.m_curHoldPoint.M.Prefab_TargetWarpingIn, value.warpInData[j], Quaternion.Euler(value.warpInData[j + 1])));
					}
				}
			}
			ServerSend.TNHHoldPointBeginAnalyzing(clientID, packet);
		}

		public static void TNHHoldIdentifyEncryption(int clientID, Packet packet)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.holdState = (HoldState)2;
				value.tickDownToFailure = 120f;
				if ((Object)(object)value.manager != (Object)null && value.manager.m_hasInit)
				{
					TNH_HoldPoint curHoldPoint = GM.TNH_Manager.m_curHoldPoint;
					curHoldPoint.IdentifyEncryption();
				}
			}
			ServerSend.TNHHoldIdentifyEncryption(clientID, num);
		}

		public static void SosigPriorityIFFChart(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (Server.objects[num] is TrackedSosigData trackedSosigData)
			{
				trackedSosigData.IFFChart = SosigTargetPrioritySystemPatch.IntToBoolArr(num2);
				if ((Object)(object)trackedSosigData.physicalSosig != (Object)null)
				{
					trackedSosigData.physicalSosig.physicalSosig.Priority.IFFChart = SosigTargetPrioritySystemPatch.IntToBoolArr(num2);
				}
			}
			ServerSend.SosigPriorityIFFChart(clientID, num, num2);
		}

		public static void RemoteMissileDetonate(int clientID, Packet packet)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				MonoBehaviour physical = Server.objects[num].physical.physical;
				RemoteMissile missile = ((RemoteMissileLauncher)((physical is RemoteMissileLauncher) ? physical : null)).m_missile;
				if ((Object)(object)missile != (Object)null)
				{
					RemoteMissileDetonatePatch.overriden = true;
					((Component)missile).transform.position = packet.ReadVector3();
					missile.Detonante();
				}
			}
			ServerSend.RemoteMissileDetonate(clientID, packet);
		}

		public static void StingerMissileExplode(int clientID, Packet packet)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				StingerMissile stingerMissile = (Server.objects[num].physical as TrackedItem).stingerMissile;
				if ((Object)(object)stingerMissile != (Object)null)
				{
					StingerMissileExplodePatch.overriden = true;
					((Component)stingerMissile).transform.position = packet.ReadVector3();
					stingerMissile.Explode();
				}
			}
			ServerSend.StingerMissileExplode(clientID, packet);
		}

		public static void PinnedGrenadeExplode(int clientID, Packet packet)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (num == -1 || num >= Server.objects.Length)
			{
				Mod.LogError("Server received order to explode pinned grenade with tracked ID: " + num + " but items array is not large enough to hold this ID!");
			}
			else if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				MonoBehaviour physical = Server.objects[num].physical.physical;
				PinnedGrenade val = (PinnedGrenade)(object)((physical is PinnedGrenade) ? physical : null);
				if ((Object)(object)val != (Object)null)
				{
					PinnedGrenadePatch.ExplodePinnedGrenade(val, packet.ReadVector3());
				}
			}
			ServerSend.PinnedGrenadeExplode(clientID, packet);
		}

		public static void PinnedGrenadePullPin(int clientID, Packet packet)
		{
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (num == -1 || num >= Server.objects.Length)
			{
				Mod.LogError("Server received order to pull pin on pinned grenade with tracked ID: " + num + " but items array is not large enough to hold this ID!");
			}
			else if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				TrackedItemData trackedItemData = Server.objects[num] as TrackedItemData;
				MonoBehaviour physical = trackedItemData.physical.physical;
				PinnedGrenade val = (PinnedGrenade)(object)((physical is PinnedGrenade) ? physical : null);
				if ((Object)(object)val != (Object)null)
				{
					for (int i = 0; i < val.m_rings.Count; i++)
					{
						if (!val.m_rings[i].HasPinDetached())
						{
							val.m_rings[i].m_hasPinDetached = true;
							val.m_rings[i].Pin.RootRigidbody = ((Component)val.m_rings[i].Pin).gameObject.AddComponent<Rigidbody>();
							val.m_rings[i].Pin.RootRigidbody.mass = 0.02f;
							((FVRInteractiveObject)val.m_rings[i]).ForceBreakInteraction();
							((Component)val.m_rings[i]).transform.SetParent(((Component)val.m_rings[i].Pin).transform);
							((Behaviour)val.m_rings[i].Pin).enabled = true;
							SM.PlayCoreSound((FVRPooledAudioType)10, val.m_rings[i].G.AudEvent_Pinpull, ((Component)val.m_rings[i]).transform.position);
							((Component)val.m_rings[i]).GetComponent<Collider>().enabled = false;
							((Behaviour)val.m_rings[i]).enabled = false;
						}
					}
					if (trackedItemData.controller == GameManager.ID && trackedItemData.physicalItem.physicalItem.m_isSpawnLock)
					{
						FVRQuickBeltSlot quickbeltSlot = trackedItemData.physicalItem.physicalItem.QuickbeltSlot;
						trackedItemData.physicalItem.physicalItem.ClearQuickbeltState();
						GameObject val2 = trackedItemData.physicalItem.physicalItem.DuplicateFromSpawnLock((FVRViveHand)null);
						FVRPhysicalObject component = val2.GetComponent<FVRPhysicalObject>();
						component.SetQuickBeltSlot(quickbeltSlot);
						component.ToggleQuickbeltState();
					}
				}
			}
			ServerSend.PinnedGrenadePullPin(num, clientID);
		}

		public static void FVRGrenadeExplode(int clientID, Packet packet)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				MonoBehaviour physical = Server.objects[num].physical.physical;
				FVRGrenade val = (FVRGrenade)(object)((physical is FVRGrenade) ? physical : null);
				if ((Object)(object)val != (Object)null)
				{
					FVRGrenadePatch.ExplodeGrenade(val, packet.ReadVector3());
				}
			}
			ServerSend.FVRGrenadeExplode(clientID, packet);
		}

		public static void ClientDisconnect(int clientID, Packet packet)
		{
			if (Server.clients[clientID].connected && Server.clients[clientID].tcp.openTime < packet.ReadLong())
			{
				Server.clients[clientID].Disconnect(2);
			}
		}

		public static void BangSnapSplode(int clientID, Packet packet)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				MonoBehaviour physical = Server.objects[num].physical.physical;
				BangSnap val = (BangSnap)(object)((physical is BangSnap) ? physical : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					BangSnapPatch.skip++;
					val.Splode();
					BangSnapPatch.skip--;
				}
			}
			ServerSend.BangSnapSplode(clientID, packet);
		}

		public static void C4Detonate(int clientID, Packet packet)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				MonoBehaviour physical = Server.objects[num].physical.physical;
				C4 val = (C4)(object)((physical is C4) ? physical : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					C4DetonatePatch.skip++;
					val.Detonate();
					C4DetonatePatch.skip--;
				}
			}
			ServerSend.C4Detonate(clientID, packet);
		}

		public static void ClaymoreMineDetonate(int clientID, Packet packet)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				MonoBehaviour physical = Server.objects[num].physical.physical;
				ClaymoreMine val = (ClaymoreMine)(object)((physical is ClaymoreMine) ? physical : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					ClaymoreMineDetonatePatch.skip++;
					val.Detonate();
					ClaymoreMineDetonatePatch.skip--;
				}
			}
			ServerSend.ClaymoreMineDetonate(clientID, packet);
		}

		public static void SLAMDetonate(int clientID, Packet packet)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] != null && (Object)(object)Server.objects[num].physical != (Object)null)
			{
				MonoBehaviour physical = Server.objects[num].physical.physical;
				SLAM val = (SLAM)(object)((physical is SLAM) ? physical : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.position = packet.ReadVector3();
					SLAMDetonatePatch.skip++;
					val.Detonate();
					SLAMDetonatePatch.skip--;
				}
			}
			ServerSend.SLAMDetonate(clientID, packet);
		}

		public static void SpectatorHost(int clientID, Packet packet)
		{
			bool flag = packet.ReadBool();
			if (flag)
			{
				if (!GameManager.spectatorHosts.Contains(clientID))
				{
					GameManager.spectatorHosts.Add(clientID);
					Server.availableSpectatorHosts.Add(clientID);
				}
			}
			else
			{
				GameManager.spectatorHosts.Remove(clientID);
				Server.availableSpectatorHosts.Remove(clientID);
				if (Server.spectatorHostControllers.TryGetValue(clientID, out var value))
				{
					Server.spectatorHostControllers.Remove(clientID);
					Server.spectatorHostByController.Remove(value);
					ServerSend.GiveUpSpectatorHost(value);
				}
			}
			GameManager.UpdatePlayerHidden(GameManager.players[clientID]);
			GameManager.OnSpectatorHostsChangedInvoke();
			ServerSend.SpectatorHost(clientID, flag);
		}

		public static void ResetTNH(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value) && value.controller == clientID)
			{
				value.Reset();
				if ((Object)(object)value.manager != (Object)null)
				{
					value.ResetManager();
				}
				ServerSend.ResetTNH(num);
			}
		}

		public static void ReviveTNHPlayer(int clientID, Packet packet)
		{
			int iD = packet.ReadInt();
			int num = packet.ReadInt();
			if (GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				value.RevivePlayer(iD, received: true);
				ServerSend.ReviveTNHPlayer(iD, num, clientID);
			}
		}

		public static void PlayerColor(int clientID, Packet packet)
		{
			int iD = packet.ReadInt();
			int index = packet.ReadInt();
			GameManager.SetPlayerColor(iD, index, received: true, clientID);
		}

		public static void RequestTNHInitialization(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Mod.LogInfo("TNH Initializion requested by " + clientID + " for " + num);
			if (GameManager.TNHInstances.TryGetValue(num, out var value) && value.initializer == -1)
			{
				Mod.LogInfo("\tNo initializer yet, granting init");
				value.initializer = clientID;
				value.initializationRequested = true;
				ServerSend.TNHInitializer(num, clientID, only: true);
			}
		}

		public static void TNHInitializer(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Mod.LogInfo("Received TNH Initializion by " + clientID + " for " + num);
			if (!GameManager.TNHInstances.TryGetValue(num, out var value))
			{
				return;
			}
			if (value.initializer == clientID)
			{
				Mod.LogInfo("\tThey were initializer, relaying");
				value.initializationRequested = false;
				ServerSend.TNHInitializer(num, clientID);
				if (Mod.currentTNHInstance == value && Mod.waitingForTNHGameStart)
				{
					Mod.currentTNHSceneLoader.Load();
				}
			}
			else
			{
				Mod.LogError("Server received signal that " + clientID + " init TNH " + num + " but they aren't the initializer!");
			}
		}

		public static void FuseIgnite(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.physicalItem is FVRFusedThrowable)
			{
				FusePatch.igniteSkip++;
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((FVRFusedThrowable)((physicalItem is FVRFusedThrowable) ? physicalItem : null)).Fuse.Ignite(0f);
				FusePatch.igniteSkip--;
			}
			ServerSend.FuseIgnite(num, clientID);
		}

		public static void FuseBoom(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.physicalItem is FVRFusedThrowable)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				((FVRFusedThrowable)((physicalItem is FVRFusedThrowable) ? physicalItem : null)).Fuse.Boom();
			}
			ServerSend.FuseBoom(num, clientID);
		}

		public static void MolotovShatter(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedItemData trackedItemData && (Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.physicalItem is Molotov)
			{
				FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
				Molotov val = (Molotov)(object)((physicalItem is Molotov) ? physicalItem : null);
				if (flag && !val.Igniteable.IsOnFire())
				{
					val.RemoteIgnite();
				}
				MolotovPatch.shatterSkip++;
				val.Shatter();
				MolotovPatch.shatterSkip--;
			}
			ServerSend.MolotovShatter(num, flag, clientID);
		}

		public static void MolotovDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == 0)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					MolotovPatch.damageSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((Molotov)((physicalItem is Molotov) ? physicalItem : null)).Damage(val);
					MolotovPatch.damageSkip--;
				}
			}
			else
			{
				ServerSend.MolotovDamage(trackedItemData, val);
			}
		}

		public static void MagazineAddRound(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == 0)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					MagazinePatch.addRoundSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((FVRFireArmMagazine)((physicalItem is FVRFireArmMagazine) ? physicalItem : null)).AddRound(val, true, true);
					MagazinePatch.addRoundSkip--;
				}
			}
			else
			{
				ServerSend.MagazineAddRound(trackedItemData.trackedID, val, clientID);
			}
		}

		public static void ClipAddRound(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == 0)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					ClipPatch.addRoundSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((FVRFireArmClip)((physicalItem is FVRFireArmClip) ? physicalItem : null)).AddRound(val, true, true);
					ClipPatch.addRoundSkip--;
				}
			}
			else
			{
				ServerSend.ClipAddRound(trackedItemData.trackedID, val, clientID);
			}
		}

		public static void SpeedloaderChamberLoad(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
			int index = packet.ReadByte();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == 0)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					SpeedloaderChamberPatch.loadSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((Speedloader)((physicalItem is Speedloader) ? physicalItem : null)).Chambers[index].Load(val, true);
					SpeedloaderChamberPatch.loadSkip--;
				}
			}
			else
			{
				ServerSend.SpeedloaderChamberLoad(trackedItemData.trackedID, val, clientID);
			}
		}

		public static void RemoteGunChamber(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FireArmRoundClass val = (FireArmRoundClass)packet.ReadShort();
			FireArmRoundType val2 = (FireArmRoundType)packet.ReadShort();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == 0)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null)
				{
					FVRFireArmRound component = ((AnvilAsset)AM.GetRoundSelfPrefab(val2, val)).GetGameObject().GetComponent<FVRFireArmRound>();
					RemoteGunPatch.chamberSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((RemoteGun)((physicalItem is RemoteGun) ? physicalItem : null)).ChamberCartridge(component);
					RemoteGunPatch.chamberSkip--;
				}
			}
			else
			{
				ServerSend.RemoteGunChamber(trackedItemData.trackedID, val, val2, clientID);
			}
		}

		public static void ChamberRound(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			FireArmRoundClass roundClass = (FireArmRoundClass)packet.ReadShort();
			int chamberIndex = packet.ReadByte();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == 0)
			{
				if ((Object)(object)trackedItemData.physicalItem != (Object)null && trackedItemData.physicalItem.chamberRound != null)
				{
					trackedItemData.physicalItem.chamberRound(roundClass, (FireArmRoundType)(-1), chamberIndex);
				}
			}
			else
			{
				ServerSend.ChamberRound(trackedItemData.trackedID, roundClass, clientID);
			}
		}

		public static void MagazineLoad(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			short num3 = packet.ReadShort();
			TrackedItemData trackedItemData = Server.objects[num] as TrackedItemData;
			TrackedItemData trackedItemData2 = Server.objects[num2] as TrackedItemData;
			if (trackedItemData != null && trackedItemData2 != null)
			{
				if (trackedItemData2.controller == 0)
				{
					if ((Object)(object)trackedItemData2.physicalItem != (Object)null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						if (num3 == -1)
						{
							MagazinePatch.loadSkip++;
							FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
							? val = ((physicalItem is FVRFireArmMagazine) ? physicalItem : null);
							FVRPhysicalObject physicalItem2 = trackedItemData2.physicalItem.physicalItem;
							((FVRFireArmMagazine)val).Load((FVRFireArm)(object)((physicalItem2 is FVRFireArm) ? physicalItem2 : null));
							MagazinePatch.loadSkip--;
						}
						else
						{
							MagazinePatch.loadSkip++;
							FVRPhysicalObject physicalItem3 = trackedItemData.physicalItem.physicalItem;
							? val2 = ((physicalItem3 is FVRFireArmMagazine) ? physicalItem3 : null);
							FVRPhysicalObject physicalItem4 = trackedItemData2.physicalItem.physicalItem;
							((FVRFireArmMagazine)val2).LoadIntoSecondary((FVRFireArm)(object)((physicalItem4 is FVRFireArm) ? physicalItem4 : null), (int)num3);
							MagazinePatch.loadSkip--;
						}
					}
				}
				else
				{
					ServerSend.MagazineLoad(num, num2, num3, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to load mag " + num + " into firearm " + num2 + " but we are missing item data!");
			}
		}

		public static void MagazineLoadAttachable(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			TrackedItemData trackedItemData = Server.objects[num] as TrackedItemData;
			TrackedItemData trackedItemData2 = Server.objects[num2] as TrackedItemData;
			if (trackedItemData != null && trackedItemData2 != null)
			{
				if (trackedItemData2.controller == 0)
				{
					if ((Object)(object)trackedItemData2.physicalItem != (Object)null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						MagazinePatch.loadSkip++;
						FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
						? val = ((physicalItem is FVRFireArmMagazine) ? physicalItem : null);
						Object dataObject = trackedItemData2.physicalItem.dataObject;
						((FVRFireArmMagazine)val).Load((AttachableFirearm)(object)((dataObject is AttachableFirearm) ? dataObject : null));
						MagazinePatch.loadSkip--;
					}
				}
				else
				{
					ServerSend.MagazineLoadAttachable(num, num2, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to load mag " + num + " into attachable firearm " + num2 + " but we are missing item data!");
			}
		}

		public static void ClipLoad(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			TrackedItemData trackedItemData = Server.objects[num] as TrackedItemData;
			TrackedItemData trackedItemData2 = Server.objects[num2] as TrackedItemData;
			if (trackedItemData != null && trackedItemData2 != null)
			{
				if (trackedItemData2.controller == 0)
				{
					if ((Object)(object)trackedItemData2.physicalItem != (Object)null && (Object)(object)trackedItemData.physicalItem != (Object)null)
					{
						ClipPatch.loadSkip++;
						FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
						? val = ((physicalItem is FVRFireArmClip) ? physicalItem : null);
						FVRPhysicalObject physicalItem2 = trackedItemData2.physicalItem.physicalItem;
						((FVRFireArmClip)val).Load((FVRFireArm)(object)((physicalItem2 is FVRFireArm) ? physicalItem2 : null));
						ClipPatch.loadSkip--;
					}
				}
				else
				{
					ServerSend.ClipLoad(num, num2, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to load clip " + num + " into firearm " + num2 + " but we are missing item data!");
			}
		}

		public static void RevolverCylinderLoad(int clientID, Packet packet)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				int num2 = packet.ReadByte();
				List<short> list = new List<short>();
				for (int i = 0; i < num2; i++)
				{
					list.Add(packet.ReadShort());
				}
				if (trackedItemData.controller == 0)
				{
					if (!((Object)(object)trackedItemData.physicalItem != (Object)null))
					{
						return;
					}
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					Revolver val = (Revolver)(object)((physicalItem is Revolver) ? physicalItem : null);
					ChamberPatch.chamberSkip++;
					for (int j = 0; j < val.Chambers.Length; j++)
					{
						if (list[j] != -1)
						{
							val.Chambers[j].SetRound((FireArmRoundClass)list[j], ((Component)val.Chambers[j]).transform.position, ((Component)val.Chambers[j]).transform.rotation);
						}
					}
					ChamberPatch.chamberSkip--;
				}
				else
				{
					ServerSend.RevolverCylinderLoad(num, null, list, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to load revolver cylinder " + num + " with speedloader but we are missing item data!");
			}
		}

		public static void RevolvingShotgunLoad(int clientID, Packet packet)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				int num2 = packet.ReadByte();
				List<short> list = new List<short>();
				for (int i = 0; i < num2; i++)
				{
					list.Add(packet.ReadShort());
				}
				if (trackedItemData.controller == 0)
				{
					if (!((Object)(object)trackedItemData.physicalItem != (Object)null))
					{
						return;
					}
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					RevolvingShotgun val = (RevolvingShotgun)(object)((physicalItem is RevolvingShotgun) ? physicalItem : null);
					if (val.CylinderLoaded)
					{
						return;
					}
					val.CylinderLoaded = true;
					((Component)val.ProxyCylinder).gameObject.SetActive(true);
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
					val.CurChamber = 0;
					val.ProxyCylinder.localRotation = val.GetLocalRotationFromCylinder(0);
					ChamberPatch.chamberSkip++;
					for (int j = 0; j < val.Chambers.Length; j++)
					{
						if (list[j] == -1)
						{
							val.Chambers[j].Unload();
						}
						else
						{
							val.Chambers[j].Autochamber((FireArmRoundClass)list[j]);
						}
						val.Chambers[j].UpdateProxyDisplay();
					}
					ChamberPatch.chamberSkip--;
				}
				else
				{
					ServerSend.RevolvingShotgunLoad(num, null, list, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to load revolving shotgun " + num + " with speedloader but we are missing item data!");
			}
		}

		public static void GrappleGunLoad(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				int num2 = packet.ReadByte();
				List<short> list = new List<short>();
				for (int i = 0; i < num2; i++)
				{
					list.Add(packet.ReadShort());
				}
				if (trackedItemData.controller == 0)
				{
					if (!((Object)(object)trackedItemData.physicalItem != (Object)null))
					{
						return;
					}
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					GrappleGun val = (GrappleGun)(object)((physicalItem is GrappleGun) ? physicalItem : null);
					if (val.IsMagLoaded)
					{
						return;
					}
					val.IsMagLoaded = true;
					val.ProxyMag.gameObject.SetActive(true);
					((FVRFireArm)val).PlayAudioEvent((FirearmAudioEventType)20, 1f);
					val.m_curChamber = 0;
					ChamberPatch.chamberSkip++;
					for (int j = 0; j < val.Chambers.Length; j++)
					{
						if (list[j] == -1)
						{
							val.Chambers[j].Unload();
						}
						else
						{
							val.Chambers[j].Autochamber((FireArmRoundClass)list[j]);
						}
						val.Chambers[j].UpdateProxyDisplay();
					}
					ChamberPatch.chamberSkip--;
				}
				else
				{
					ServerSend.GrappleGunLoad(num, null, list, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to load revolving shotgun " + num + " with speedloader but we are missing item data!");
			}
		}

		public static void CarlGustafLatchSate(int clientID, Packet packet)
		{
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Invalid comparison between Unknown and I4
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Invalid comparison between Unknown and I4
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				byte b = packet.ReadByte();
				byte b2 = packet.ReadByte();
				if (trackedItemData.controller == 0)
				{
					if (!((Object)(object)trackedItemData.physicalItem != (Object)null))
					{
						return;
					}
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					CarlGustafLatch val = ((CarlGustaf)((physicalItem is CarlGustaf) ? physicalItem : null)).TailLatch;
					if (b == 1)
					{
						val = val.RestrictingLatch;
					}
					CarlGustafLatchPatch.skip++;
					if (b2 == 0)
					{
						if ((int)val.LState > 0)
						{
							float num2 = (val.m_tarRot = (val.m_curRot = (val.IsMinOpen ? val.RotMax : val.RotMin)));
							((Component)val).transform.localEulerAngles = new Vector3(0f, num2, 0f);
							val.LState = (CGLatchState)0;
						}
					}
					else if ((int)val.LState != 2)
					{
						float num3 = (val.m_tarRot = (val.m_curRot = (val.IsMinOpen ? val.RotMin : val.RotMax)));
						((Component)val).transform.localEulerAngles = new Vector3(0f, num3, 0f);
						val.LState = (CGLatchState)2;
					}
					CarlGustafLatchPatch.skip--;
				}
				else
				{
					ServerSend.CarlGustafLatchSate(num, (CGLatchType)b, (CGLatchState)b2, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to set latch state of CG " + num + " but we are missing item data!");
			}
		}

		public static void CarlGustafShellSlideSate(int clientID, Packet packet)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Invalid comparison between Unknown and I4
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Invalid comparison between Unknown and I4
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				byte b = packet.ReadByte();
				if (trackedItemData.controller == 0)
				{
					if (!((Object)(object)trackedItemData.physicalItem != (Object)null))
					{
						return;
					}
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					CarlGustaf val = (CarlGustaf)(object)((physicalItem is CarlGustaf) ? physicalItem : null);
					CarlGustafShellInsertEjectPatch.skip++;
					if (b == 0)
					{
						if ((int)val.ShellInsertEject.CSState > 0)
						{
							val.ShellInsertEject.m_curZ = val.ShellInsertEject.ChamberPoint_Forward.localPosition.z;
							val.ShellInsertEject.m_tarZ = val.ShellInsertEject.ChamberPoint_Forward.localPosition.z;
							((Component)val.Chamber).transform.localPosition = new Vector3(((Component)val.Chamber).transform.localPosition.x, ((Component)val.Chamber).transform.localPosition.y, val.ShellInsertEject.ChamberPoint_Forward.localPosition.z);
							val.ShellInsertEject.CSState = (ChamberSlideState)0;
						}
					}
					else if ((int)val.ShellInsertEject.CSState != 2)
					{
						val.ShellInsertEject.m_curZ = val.ShellInsertEject.ChamberPoint_Back.localPosition.z;
						val.ShellInsertEject.m_tarZ = val.ShellInsertEject.ChamberPoint_Back.localPosition.z;
						((Component)val.Chamber).transform.localPosition = new Vector3(((Component)val.Chamber).transform.localPosition.x, ((Component)val.Chamber).transform.localPosition.y, val.ShellInsertEject.ChamberPoint_Back.localPosition.z);
						val.ShellInsertEject.CSState = (ChamberSlideState)2;
					}
					CarlGustafShellInsertEjectPatch.skip--;
				}
				else
				{
					ServerSend.CarlGustafShellSlideSate(num, (ChamberSlideState)b, clientID);
				}
			}
			else
			{
				Mod.LogError("Server got order to set shell slide state of CG " + num + " but we are missing item data!");
			}
		}

		public static void TNHHostStartHold(int clientID, Packet packet)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Mod.currentTNHInstance != null && Mod.currentTNHInstance.instance == num && Mod.currentTNHInstance.controller == GameManager.ID)
			{
				if ((Object)(object)Mod.currentTNHInstance.manager != (Object)null && !Mod.currentTNHInstance.holdOngoing)
				{
					GM.CurrentMovementManager.TeleportToPoint(Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].SpawnPoint_SystemNode.position, true);
					Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasActivated = true;
					Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].m_systemNode.m_hasInitiatedHold = true;
					Mod.currentTNHInstance.manager.HoldPoints[Mod.currentTNHInstance.curHoldIndex].BeginHoldChallenge();
				}
			}
			else
			{
				ServerSend.TNHHostStartHold(Mod.currentTNHInstance.instance, clientID);
			}
		}

		public static void GrappleAttached(int clientID, Packet packet)
		{
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			byte[] array = packet.ReadBytes(packet.ReadShort());
			if (!(Server.objects[num] is TrackedItemData trackedItemData) || trackedItemData.controller == GameManager.ID)
			{
				return;
			}
			trackedItemData.additionalData = array;
			if ((Object)(object)trackedItemData.physical != (Object)null)
			{
				MonoBehaviour physical = trackedItemData.physical.physical;
				GrappleThrowable val = (GrappleThrowable)(object)((physical is GrappleThrowable) ? physical : null);
				((FVRPhysicalObject)val).RootRigidbody.isKinematic = true;
				val.m_isRopeFree = true;
				val.BundledRope.SetActive(false);
				val.m_hasBeenThrown = true;
				val.m_hasLanded = true;
				if (val.m_ropeLengths.Count > 0)
				{
					for (int num2 = val.m_ropeLengths.Count - 1; num2 >= 0; num2--)
					{
						Object.Destroy((Object)(object)val.m_ropeLengths[num2]);
					}
					val.m_ropeLengths.Clear();
				}
				val.finalRopePoints.Clear();
				val.FakeRopeLength.SetActive(false);
				int num3 = trackedItemData.additionalData[1];
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(BitConverter.ToSingle(trackedItemData.additionalData, 2), BitConverter.ToSingle(trackedItemData.additionalData, 6), BitConverter.ToSingle(trackedItemData.additionalData, 10));
				Vector3 val3 = default(Vector3);
				for (int i = 1; i < num3; i++)
				{
					((Vector3)(ref val3))..ctor(BitConverter.ToSingle(trackedItemData.additionalData, i * 12 + 2), BitConverter.ToSingle(trackedItemData.additionalData, i * 12 + 6), BitConverter.ToSingle(trackedItemData.additionalData, i * 12 + 10));
					Vector3 val4 = val3 - val2;
					GameObject val5 = Object.Instantiate<GameObject>(val.RopeLengthPrefab, val3, Quaternion.LookRotation(-val4, Vector3.up));
					val5.transform.localScale = new Vector3(1f, 1f, ((Vector3)(ref val4)).magnitude);
					FVRHandGrabPoint val6 = null;
					if (val.m_ropeLengths.Count > 0)
					{
						val6 = val.m_ropeLengths[val.m_ropeLengths.Count - 1].GetComponent<FVRHandGrabPoint>();
					}
					FVRHandGrabPoint component = val5.GetComponent<FVRHandGrabPoint>();
					val.m_ropeLengths.Add(val5);
					if ((Object)(object)val6 != (Object)null && (Object)(object)component != (Object)null)
					{
						val6.ConnectedGrabPoint_Base = component;
						component.ConnectedGrabPoint_End = val6;
					}
					val.finalRopePoints.Add(val3);
					val2 = val3;
				}
			}
			ServerSend.GrappleAttached(num, array, clientID);
		}

		public static void RegisterCustomPacketType(int clientID, Packet packet)
		{
			Server.RegisterCustomPacketType(packet.ReadString(), clientID);
		}

		public static void BreakableGlassDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedBreakableGlassData trackedBreakableGlassData))
			{
				return;
			}
			if (trackedBreakableGlassData.controller == 0)
			{
				if ((Object)(object)trackedBreakableGlassData.damager != (Object)null)
				{
					BreakableGlassDamagerPatch.damageSkip++;
					trackedBreakableGlassData.damager.Damage(val);
					BreakableGlassDamagerPatch.damageSkip--;
				}
			}
			else
			{
				ServerSend.BreakableGlassDamage(packet, trackedBreakableGlassData.controller);
			}
		}

		public static void WindowShatterSound(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int mode = packet.ReadByte();
			if (Server.objects[num] is TrackedBreakableGlassData trackedBreakableGlassData)
			{
				if ((Object)(object)trackedBreakableGlassData.physicalBreakableGlass != (Object)null)
				{
					trackedBreakableGlassData.physicalBreakableGlass.PlayerShatterAudio(mode);
				}
				ServerSend.WindowShatterSound(num, mode, clientID);
			}
		}

		public static void RequestSpectatorHost(int clientID, Packet packet)
		{
			int num = -1;
			if (Server.availableSpectatorHosts.Count > 0)
			{
				num = Server.availableSpectatorHosts[Server.availableSpectatorHosts.Count - 1];
				Server.spectatorHostByController.Add(clientID, num);
				Server.spectatorHostControllers.Add(num, clientID);
				Server.availableSpectatorHosts.RemoveAt(Server.availableSpectatorHosts.Count - 1);
				if (num == 0)
				{
					GameManager.spectatorHostControlledBy = clientID;
				}
			}
			ServerSend.SpectatorHostAssignment(num, clientID);
		}

		public static void UnassignSpectatorHost(int clientID, Packet packet)
		{
			if (!Server.spectatorHostByController.TryGetValue(clientID, out var value))
			{
				return;
			}
			Server.spectatorHostByController.Remove(clientID);
			Server.spectatorHostControllers.Remove(value);
			if (GameManager.spectatorHosts.Contains(value))
			{
				Server.availableSpectatorHosts.Add(value);
			}
			if (value == GameManager.ID)
			{
				GameManager.spectatorHostControlledBy = -1;
				if (!GameManager.sceneLoading)
				{
					if (!GameManager.scene.Equals("MainMenu3"))
					{
						SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
					}
				}
				else
				{
					GameManager.resetSpectatorHost = true;
				}
			}
			else
			{
				ServerSend.UnassignSpectatorHost(value);
			}
		}

		public static void SpectatorHostOrderTNHHost(int clientID, Packet packet)
		{
			if (Server.spectatorHostByController.TryGetValue(clientID, out var value))
			{
				if (value == GameManager.ID)
				{
					if (GameManager.sceneLoading)
					{
						Mod.spectatorHostWaitingForTNHSetup = true;
						Mod.TNHRequestHostOnDeathSpectate = packet.ReadBool();
					}
					else if (GameManager.scene.Equals("TakeAndHold_Lobby_2"))
					{
						Mod.OnTNHHostClicked();
						Mod.TNHOnDeathSpectate = packet.ReadBool();
						Mod.OnTNHHostConfirmClicked();
						ServerSend.TNHSpectatorHostReady(clientID, GameManager.instance);
						Mod.spectatorHostWaitingForTNHSetup = false;
					}
					else if (GameManager.scene.Equals("MainMenu3"))
					{
						SteamVR_LoadLevel.Begin("TakeAndHold_Lobby_2", false, 0.5f, 0f, 0f, 0f, 1f);
						Mod.spectatorHostWaitingForTNHSetup = true;
					}
					else
					{
						SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
						Mod.spectatorHostWaitingForTNHSetup = true;
					}
				}
				else
				{
					ServerSend.SpectatorHostOrderTNHHost(value, packet.ReadBool());
				}
			}
			else
			{
				ServerSend.GiveUpSpectatorHost(clientID);
			}
		}

		public static void TNHSpectatorHostReady(int clientID, Packet packet)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!Server.spectatorHostControllers.TryGetValue(clientID, out var value))
			{
				return;
			}
			int num = packet.ReadInt();
			if (value == GameManager.ID)
			{
				if (Mod.waitingForTNHHost)
				{
					if ((Object)(object)Mod.TNHMenu != (Object)null)
					{
						Mod.TNHHostedInstance = num;
						Mod.TNHMenuPages[6].SetActive(false);
						Mod.TNHMenuPages[2].SetActive(true);
						Mod.TNHStatusText.text = "Setting up as Client";
						((Graphic)Mod.TNHStatusText).color = Color.blue;
					}
					else
					{
						Mod.waitingForTNHHost = false;
					}
				}
			}
			else
			{
				ServerSend.TNHSpectatorHostReady(value, num);
			}
		}

		public static void SpectatorHostStartTNH(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!Server.spectatorHostControllers.TryGetValue(num, out var _))
			{
				return;
			}
			if (num == GameManager.ID)
			{
				if (GameManager.spectatorHost && !GameManager.sceneLoading && GameManager.scene.Equals("TakeAndHold_Lobby_2") && Mod.currentTNHInstance != null && Mod.currentTNHInstance.playerIDs.Count > 0 && Mod.currentTNHInstance.playerIDs[0] == GameManager.ID && (Object)(object)Mod.currentTNHSceneLoader != (Object)null)
				{
					Mod.currentTNHSceneLoader.Load();
				}
			}
			else
			{
				ServerSend.SpectatorHostStartTNH(num);
			}
		}

		public static void ReassignSpectatorHost(int clientID, Packet packet)
		{
			List<int> list = new List<int>();
			int num = packet.ReadInt();
			for (int i = 0; i < num; i++)
			{
				list.Add(packet.ReadInt());
			}
			GameManager.ReassignSpectatorHost(clientID, list);
		}

		public static void ReactiveSteelTargetDamage(int clientID, Packet packet)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int index = packet.ReadInt();
			float num2 = packet.ReadInt();
			float num3 = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			Vector3 val2 = packet.ReadVector3();
			bool flag = packet.ReadBool();
			Vector3 val3 = Vector3.zero;
			Quaternion val4 = Quaternion.identity;
			float num4 = 0f;
			if (flag)
			{
				val3 = packet.ReadVector3();
				val4 = packet.ReadQuaternion();
				num4 = packet.ReadFloat();
			}
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if ((Object)(object)trackedItemData.physicalItem != (Object)null)
			{
				object obj = trackedItemData.physicalItem.getSecondary(index);
				ReactiveSteelTarget val5 = (ReactiveSteelTarget)((obj is ReactiveSteelTarget) ? obj : null);
				if ((Object)(object)val5 != (Object)null)
				{
					if (val5.BulletHolePrefabs.Length != 0 && flag)
					{
						if (val5.m_currentHoles.Count > val5.MaxHoles)
						{
							val5.holeindex++;
							if (val5.holeindex > val5.MaxHoles - 1)
							{
								val5.holeindex = 0;
							}
							val5.m_currentHoles[val5.holeindex].transform.position = val3;
							val5.m_currentHoles[val5.holeindex].transform.rotation = val4;
							val5.m_currentHoles[val5.holeindex].transform.localScale = new Vector3(num4, num4, num4);
						}
						else
						{
							GameObject val6 = Object.Instantiate<GameObject>(val5.BulletHolePrefabs[Random.Range(0, val5.BulletHolePrefabs.Length)], val3, val4);
							val6.transform.SetParent(((Component)val5).transform);
							val6.transform.localScale = new Vector3(num4, num4, num4);
							val5.m_currentHoles.Add(val6);
						}
					}
					if (trackedItemData.controller == GameManager.ID && val5.m_hasRB && val5.AddForceJuice)
					{
						float num5 = Mathf.Clamp(num3 * 0.01f, 0f, val5.MaxForceImpulse);
						Debug.DrawLine(val, val + val2 * num5, Color.red, 40f);
						val5.rb.AddForceAtPosition(val2 * num5, val, (ForceMode)1);
					}
					val5.PlayHitSound(Mathf.Clamp(num2 * 0.0025f, 0.05f, 1f));
				}
			}
			ServerSend.ReactiveSteelTargetDamage(packet, clientID);
		}

		public static void MTUTest(int clientID, Packet packet)
		{
			Mod.LogWarning("Received MTU test packet from client");
		}

		public static void IDConfirm(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Mod.LogInfo("Server received IDConfirm for " + num);
			if (Server.availableIndexBufferClients.TryGetValue(clientID, out var value))
			{
				value.Remove(num);
				if (value.Count == 0)
				{
					Server.availableIndexBufferClients.Remove(clientID);
				}
			}
			if (Server.availableIndexBufferWaitingFor.TryGetValue(num, out var value2))
			{
				value2.Remove(clientID);
				if (value2.Count == 0)
				{
					Server.availableIndexBufferWaitingFor.Remove(num);
					Server.availableObjectIndices.Add(num);
				}
			}
		}

		public static void ObjectScene(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			string text = packet.ReadString();
			TrackedObjectData trackedObjectData = (TrackedObjectData)Activator.CreateInstance(Mod.trackedObjectTypesByName[text], packet, text, num);
			if (Server.objects[num] != null)
			{
				Server.objects[num].SetScene(trackedObjectData.scene, send: false);
				ServerSend.ObjectScene(trackedObjectData, clientID);
			}
		}

		public static void ObjectInstance(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			string text = packet.ReadString();
			TrackedObjectData trackedObjectData = (TrackedObjectData)Activator.CreateInstance(Mod.trackedObjectTypesByName[text], packet, text, num);
			if (Server.objects[num] != null)
			{
				Server.objects[num].SetInstance(trackedObjectData.instance, send: false);
				ServerSend.ObjectInstance(trackedObjectData, clientID);
			}
		}

		public static void UpdateEncryptionDisplay(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			if (!(Server.objects[num] is TrackedEncryptionData trackedEncryptionData))
			{
				return;
			}
			trackedEncryptionData.numHitsLeft = num2;
			if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				trackedEncryptionData.physicalEncryption.physicalEncryption.m_numHitsLeft = num2;
				if (trackedEncryptionData.physicalEncryption.physicalEncryption.UsesMultipleDisplay && trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList.Count > num2 && (Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.DisplayList[num2] != (Object)null)
				{
					EncryptionPatch.updateDisplaySkip++;
					trackedEncryptionData.physicalEncryption.physicalEncryption.UpdateDisplay();
					EncryptionPatch.updateDisplaySkip--;
				}
			}
			ServerSend.UpdateEncryptionDisplay(num, num2, clientID);
		}

		public static void RoundDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			Damage val = packet.ReadDamage();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((FVRFireArmRound)((physicalItem is FVRFireArmRound) ? physicalItem : null)).Damage(val);
				}
			}
			else
			{
				ServerSend.RoundDamage(num, val, trackedItemData.controller);
			}
		}

		public static void RoundSplode(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				float num2 = packet.ReadFloat();
				bool flag = packet.ReadBool();
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					RoundPatch.splodeSkip++;
					FVRPhysicalObject physicalItem = trackedItemData.physicalItem.physicalItem;
					((FVRFireArmRound)((physicalItem is FVRFireArmRound) ? physicalItem : null)).Splode(num2, flag, false);
					RoundPatch.splodeSkip--;
				}
				ServerSend.RoundSplode(num, num2, flag, clientID);
			}
		}

		public static void SightFlipperState(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			bool flag = packet.ReadBool();
			TrackedObjectData trackedObjectData = Server.objects[num];
			if (trackedObjectData == null)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)trackedObjectData.physical))
			{
				AR15HandleSightFlipper[] componentsInChildren = ((Component)trackedObjectData.physical).GetComponentsInChildren<AR15HandleSightFlipper>();
				if (componentsInChildren.Length > num2)
				{
					componentsInChildren[num2].m_isLargeAperture = flag;
				}
			}
			ServerSend.SightFlipperState(num, num2, flag, clientID);
		}

		public static void SightRaiserState(int clientID, Packet packet)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected I4, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			int num2 = packet.ReadInt();
			SightHeights val = (SightHeights)packet.ReadByte();
			TrackedObjectData trackedObjectData = Server.objects[num];
			if (trackedObjectData == null)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)trackedObjectData.physical))
			{
				AR15HandleSightRaiser[] componentsInChildren = ((Component)trackedObjectData.physical).GetComponentsInChildren<AR15HandleSightRaiser>();
				if (componentsInChildren.Length > num2)
				{
					SightHeights val2 = val;
					SightHeights val3 = val2;
					switch ((int)val3)
					{
					case 1:
						componentsInChildren[num2].height = (SightHeights)1;
						componentsInChildren[num2].m_sightHeight = 0.25f;
						break;
					case 2:
						componentsInChildren[num2].height = (SightHeights)2;
						componentsInChildren[num2].m_sightHeight = 0.5f;
						break;
					case 3:
						componentsInChildren[num2].height = (SightHeights)3;
						componentsInChildren[num2].m_sightHeight = 0.75f;
						break;
					case 4:
						componentsInChildren[num2].height = (SightHeights)4;
						componentsInChildren[num2].m_sightHeight = 1f;
						break;
					case 0:
						componentsInChildren[num2].height = (SightHeights)0;
						componentsInChildren[num2].m_sightHeight = 0f;
						break;
					}
				}
			}
			ServerSend.SightRaiserState(num, num2, val, clientID);
		}

		public static void GatlingGunFire(int clientID, Packet packet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			Quaternion val2 = packet.ReadQuaternion();
			Vector3 val3 = packet.ReadVector3();
			TrackedObjectData trackedObjectData = Server.objects[num];
			if (trackedObjectData == null)
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)trackedObjectData.physical))
			{
				wwGatlingGun physicalGatlingGun = (trackedObjectData as TrackedGatlingGunData).physicalGatlingGun.physicalGatlingGun;
				MuzzleFireType val4 = physicalGatlingGun.MuzzleFX[physicalGatlingGun.AmmoType];
				for (int i = 0; i < val4.MuzzleFires.Length; i++)
				{
					val4.MuzzleFires[i].Emit(val4.MuzzleFireAmounts[i]);
				}
				physicalGatlingGun.m_pool_shot.PlayClip(physicalGatlingGun.AudioClipSet.Shots_Main, physicalGatlingGun.MuzzlePos.position, (AudioMixerGroup)null);
				physicalGatlingGun.m_pool_mechanics.PlayClip(physicalGatlingGun.AudioClipSet.HammerHit, physicalGatlingGun.MuzzlePos.position, (AudioMixerGroup)null);
				physicalGatlingGun.m_pool_tail.PlayClipPitchOverride(SM.GetTailSet(physicalGatlingGun.TailClass, GM.CurrentPlayerBody.GetCurrentSoundEnvironment()), physicalGatlingGun.MuzzlePos.position, physicalGatlingGun.AudioClipSet.TailPitchMod_Main, (AudioMixerGroup)null);
				GameObject val5 = Object.Instantiate<GameObject>(val4.ProjectilePrefab, val, val2);
				val5.GetComponent<BallisticProjectile>().Fire(val3, (FVRFireArm)null);
			}
			ServerSend.GatlingGunFire(num, val, val2, val3, clientID);
		}

		public static void GasCuboidGout(int clientID, Packet packet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			Vector3 val2 = packet.ReadVector3();
			if (Server.objects[num] is TrackedItemData trackedItemData && trackedItemData.additionalData[0] < byte.MaxValue)
			{
				byte[] additionalData = trackedItemData.additionalData;
				trackedItemData.additionalData = new byte[additionalData.Length + 24];
				for (int i = 0; i < additionalData.Length; i++)
				{
					trackedItemData.additionalData[i] = additionalData[i];
				}
				trackedItemData.additionalData[1]++;
				if (Object.op_Implicit((Object)(object)trackedItemData.physical))
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val3 = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					val3.hasGeneratedGoutYet = false;
					GasCuboidPatch.generateGoutSkip++;
					val3.GenerateGout(val, val2);
					GasCuboidPatch.generateGoutSkip--;
				}
				ServerSend.GasCuboidGout(num, val, val2, clientID);
			}
		}

		public static void GasCuboidDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					GasCuboidDamagePatch.skip++;
					Object dataObject = trackedItemData.physicalItem.dataObject;
					((Brut_GasCuboid)((dataObject is Brut_GasCuboid) ? dataObject : null)).Damage(packet.ReadDamage());
					GasCuboidDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.GasCuboidDamage(packet, trackedItemData.controller);
			}
		}

		public static void GasCuboidHandleDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			if (trackedItemData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					GasCuboidHandleDamagePatch.skip++;
					Object dataObject = trackedItemData.physicalItem.dataObject;
					((Brut_GasCuboid)((dataObject is Brut_GasCuboid) ? dataObject : null)).Handle.GetComponent<Brut_GasCuboidHandle>().Damage(packet.ReadDamage());
					GasCuboidHandleDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.GasCuboidHandleDamage(packet, trackedItemData.controller);
			}
		}

		public static void GasCuboidDamageHandle(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				trackedItemData.additionalData[0] = 1;
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					val.m_isHandleBrokenOff = true;
					val.Handle.SetActive(false);
				}
				ServerSend.GasCuboidDamageHandle(num, clientID);
			}
		}

		public static void GasCuboidExplode(int clientID, Packet packet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			Vector3 val2 = packet.ReadVector3();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val3 = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					GasCuboidPatch.explodeSkip++;
					val3.Explode(val, val2, flag);
					GasCuboidPatch.explodeSkip--;
				}
				ServerSend.GasCuboidExplode(num, val, val2, flag, clientID);
			}
		}

		public static void GasCuboidShatter(int clientID, Packet packet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			Vector3 val = packet.ReadVector3();
			Vector3 val2 = packet.ReadVector3();
			if (Server.objects[num] is TrackedItemData trackedItemData)
			{
				if ((Object)(object)trackedItemData.physical != (Object)null)
				{
					Object dataObject = trackedItemData.physicalItem.dataObject;
					Brut_GasCuboid val3 = (Brut_GasCuboid)(object)((dataObject is Brut_GasCuboid) ? dataObject : null);
					GasCuboidPatch.shatterSkip++;
					val3.Shatter(val, val2);
					GasCuboidPatch.shatterSkip--;
				}
				ServerSend.GasCuboidShatter(num, val, val2, clientID);
			}
		}

		public static void FloaterDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedFloaterData trackedFloaterData))
			{
				return;
			}
			if (trackedFloaterData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedFloaterData.physical != (Object)null)
				{
					FloaterDamagePatch.skip++;
					trackedFloaterData.physicalFloater.physicalFloater.Damage(packet.ReadDamage());
					FloaterDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.FloaterDamage(packet, trackedFloaterData.controller);
			}
		}

		public static void FloaterCoreDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedFloaterData trackedFloaterData))
			{
				return;
			}
			if (trackedFloaterData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedFloaterData.physical != (Object)null)
				{
					FloaterCoreDamagePatch.skip++;
					((Component)trackedFloaterData.physicalFloater).GetComponentInChildren<Construct_Floater_Core>().Damage(packet.ReadDamage());
					FloaterCoreDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.FloaterCoreDamage(packet, trackedFloaterData.controller);
			}
		}

		public static void FloaterBeginExploding(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedFloaterData trackedFloaterData)
			{
				if (flag)
				{
					FloaterPatch.beginExplodingOverride = true;
					trackedFloaterData.physicalFloater.physicalFloater.BeginExploding();
					FloaterPatch.beginExplodingOverride = false;
					ServerSend.FloaterBeginExploding(num, fromController: true, trackedFloaterData.controller);
				}
				else if (trackedFloaterData.controller == GameManager.ID)
				{
					trackedFloaterData.physicalFloater.physicalFloater.BeginExploding();
				}
				else
				{
					ServerSend.FloaterBeginExploding(num, fromController: false, trackedFloaterData.controller);
				}
			}
		}

		public static void FloaterBeginDefusing(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedFloaterData trackedFloaterData)
			{
				if (flag)
				{
					FloaterPatch.beginExplodingOverride = true;
					trackedFloaterData.physicalFloater.physicalFloater.BeginDefusing();
					FloaterPatch.beginExplodingOverride = false;
					ServerSend.FloaterBeginDefusing(num, fromController: true, trackedFloaterData.controller);
				}
				else if (trackedFloaterData.controller == GameManager.ID)
				{
					trackedFloaterData.physicalFloater.physicalFloater.BeginDefusing();
				}
				else
				{
					ServerSend.FloaterBeginDefusing(num, fromController: false, trackedFloaterData.controller);
				}
			}
		}

		public static void FloaterExplode(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedFloaterData trackedFloaterData)
			{
				if ((Object)(object)trackedFloaterData.physicalFloater != (Object)null)
				{
					trackedFloaterData.physicalFloater.physicalFloater.isExplosionDefuse = flag;
					FloaterPatch.explodeSkip++;
					trackedFloaterData.physicalFloater.physicalFloater.BeginExploding();
					FloaterPatch.explodeSkip--;
				}
				ServerSend.FloaterExplode(num, flag, clientID);
			}
		}

		public static void IrisShatter(int clientID, Packet packet)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedIrisData trackedIrisData)
			{
				if ((Object)(object)trackedIrisData.physicalIris != (Object)null)
				{
					byte index = packet.ReadByte();
					Vector3 val = packet.ReadVector3();
					Vector3 val2 = packet.ReadVector3();
					float num2 = packet.ReadFloat();
					UberShatterableShatterPatch.skip++;
					trackedIrisData.physicalIris.physicalIris.Rings[index].Shatter(val, val2, num2);
					UberShatterableShatterPatch.skip--;
				}
				ServerSend.IrisShatter(packet, clientID);
			}
		}

		public static void IrisSetState(int clientID, Packet packet)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			IrisState state = (IrisState)packet.ReadByte();
			if (Server.objects[num] is TrackedIrisData trackedIrisData)
			{
				trackedIrisData.state = state;
				if ((Object)(object)trackedIrisData.physicalIris != (Object)null)
				{
					IrisPatch.stateSkip++;
					trackedIrisData.physicalIris.physicalIris.SetState(state);
					IrisPatch.stateSkip--;
				}
				ServerSend.IrisSetState(num, state, clientID);
			}
		}

		public static void BrutBlockSystemStart(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			bool flag = packet.ReadBool();
			if (Server.objects[num] is TrackedBrutBlockSystemData trackedBrutBlockSystemData)
			{
				if ((Object)(object)trackedBrutBlockSystemData.physicalBrutBlockSystem != (Object)null)
				{
					trackedBrutBlockSystemData.physicalBrutBlockSystem.physicalBrutBlockSystem.isNextBlock0 = flag;
					BrutBlockSystemPatch.startSkip++;
					trackedBrutBlockSystemData.physicalBrutBlockSystem.physicalBrutBlockSystem.TryToStartBlock();
					BrutBlockSystemPatch.startSkip--;
				}
				ServerSend.BrutBlockSystemStart(num, flag, clientID);
			}
		}

		public static void BatchedPackets(int clientID, Packet packet)
		{
			while (packet.UnreadLength() > 0)
			{
				int length = packet.ReadInt();
				byte[] data = packet.ReadBytes(length);
				using Packet packet2 = new Packet(data);
				int num = packet2.ReadInt();
				Server.packetHandlers[num](clientID, packet2);
			}
		}

		public static void NodeInit(int clientID, Packet packet)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedNodeData trackedNodeData))
			{
				return;
			}
			trackedNodeData.points = new List<Vector3>();
			int num2 = packet.ReadByte();
			for (int i = 0; i < num2; i++)
			{
				trackedNodeData.points.Add(packet.ReadVector3());
			}
			trackedNodeData.ups = new List<Vector3>();
			int num3 = packet.ReadByte();
			for (int j = 0; j < num3; j++)
			{
				trackedNodeData.ups.Add(packet.ReadVector3());
			}
			if ((Object)(object)trackedNodeData.physicalNode != (Object)null)
			{
				trackedNodeData.physicalNode.physicalNode.initialPos = trackedNodeData.position;
				trackedNodeData.physicalNode.physicalNode.m_center = trackedNodeData.position;
				for (int k = 0; k < trackedNodeData.physicalNode.physicalNode.Cages.Count; k++)
				{
					trackedNodeData.physicalNode.physicalNode.Cages[k].SetParent((Transform)null);
				}
				trackedNodeData.physicalNode.physicalNode.UpdateCageStems();
			}
			ServerSend.NodeInit(num, trackedNodeData.points, trackedNodeData.ups, clientID);
		}

		public static void NodeFire(int clientID, Packet packet)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedNodeData trackedNodeData)
			{
				float num2 = packet.ReadFloat();
				Vector3 val = packet.ReadVector3();
				if ((Object)(object)trackedNodeData.physicalNode != (Object)null)
				{
					GameObject val2 = Object.Instantiate<GameObject>(trackedNodeData.physicalNode.physicalNode.ProjPrefab, ((Component)trackedNodeData.physicalNode.physicalNode).transform.position, Quaternion.LookRotation(val));
					BallisticProjectile component = val2.GetComponent<BallisticProjectile>();
					component.Fire(300f * num2, val, (FVRFireArm)null, false);
					component.SetSource_IFF(0);
					trackedNodeData.physicalNode.physicalNode.UpdateCageStems();
				}
				ServerSend.NodeFire(num, num2, val, clientID);
			}
		}

		public static void HazeDamage(int clientID, Packet packet)
		{
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedHazeData trackedHazeData))
			{
				return;
			}
			if (trackedHazeData.controller == GameManager.ID)
			{
				if ((Object)(object)trackedHazeData.physical != (Object)null)
				{
					HazeDamagePatch.skip++;
					trackedHazeData.physicalHaze.physicalHaze.Damage(packet.ReadDamage());
					HazeDamagePatch.skip--;
				}
			}
			else
			{
				ServerSend.HazeDamage(packet, trackedHazeData.controller);
			}
		}

		public static void EncryptionFireGun(int clientID, Packet packet)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedEncryptionData trackedEncryptionData))
			{
				return;
			}
			if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
			{
				List<float> list = new List<float>();
				int num2 = packet.ReadByte();
				for (int i = 0; i < num2; i++)
				{
					list.Add(packet.ReadFloat());
				}
				List<Vector3> list2 = new List<Vector3>();
				int num3 = packet.ReadByte();
				for (int j = 0; j < num3; j++)
				{
					list2.Add(packet.ReadVector3());
				}
				for (int k = 0; k < trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles.Count; k++)
				{
					Vector3 position = trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles[k].position;
					GameObject val = Object.Instantiate<GameObject>(trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveProjectile, position, trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles[k].rotation);
					BallisticProjectile component = val.GetComponent<BallisticProjectile>();
					component.FlightVelocityMultiplier = 0.04f;
					component.Fire(list[k], list2[k], (FVRFireArm)null, true);
				}
				if ((Object)(object)trackedEncryptionData.physicalEncryption.physicalEncryption.GunShotProfile != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.PlayShotEvent(trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveMuzzles[0].position);
				}
			}
			ServerSend.EncryptionFireGun(clientID, packet);
		}

		public static void EncryptionNextPos(int clientID, Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.refractivePreviewPos = packet.ReadVector3();
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.RefractivePreview.position = trackedEncryptionData.refractivePreviewPos;
				}
				ServerSend.EncryptionNextPos(num, trackedEncryptionData.refractivePreviewPos, clientID);
			}
		}

		public static void EncryptionShieldRot(int clientID, Packet packet)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (Server.objects[num] is TrackedEncryptionData trackedEncryptionData)
			{
				trackedEncryptionData.refractiveShieldRot = packet.ReadQuaternion();
				if ((Object)(object)trackedEncryptionData.physicalEncryption != (Object)null)
				{
					trackedEncryptionData.physicalEncryption.physicalEncryption.RefractiveShield.rotation = trackedEncryptionData.refractiveShieldRot;
				}
				ServerSend.EncryptionShieldRot(num, trackedEncryptionData.refractiveShieldRot, clientID);
			}
		}

		public static void SentinelInit(int clientID, Packet packet)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedSentinelData trackedSentinelData))
			{
				return;
			}
			if (trackedSentinelData.patrolPoints == null)
			{
				trackedSentinelData.patrolPoints = new List<Vector3>();
			}
			else
			{
				trackedSentinelData.patrolPoints.Clear();
			}
			int num2 = packet.ReadByte();
			for (int i = 0; i < num2; i++)
			{
				trackedSentinelData.patrolPoints.Add(packet.ReadVector3());
			}
			trackedSentinelData.currentPointIndex = packet.ReadByte();
			trackedSentinelData.targetPointIndex = packet.ReadByte();
			trackedSentinelData.isMovingUpIndicies = packet.ReadBool();
			if ((Object)(object)trackedSentinelData.physical != (Object)null)
			{
				if (trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints == null)
				{
					trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints = new List<Transform>();
				}
				else
				{
					for (int j = 0; j < trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints.Count; j++)
					{
						Object.Destroy((Object)(object)((Component)trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints[j]).gameObject);
					}
					trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints.Clear();
				}
				for (int k = 0; k < trackedSentinelData.patrolPoints.Count; k++)
				{
					GameObject val = new GameObject("Sentinel " + num + " patrol point " + k);
					val.transform.position = trackedSentinelData.patrolPoints[k];
					trackedSentinelData.physicalSentinel.physicalSentinel.PatrolPoints.Add(val.transform);
				}
				trackedSentinelData.physicalSentinel.physicalSentinel.curPointIndex = trackedSentinelData.currentPointIndex;
				trackedSentinelData.physicalSentinel.physicalSentinel.tarPointIndex = trackedSentinelData.targetPointIndex;
				trackedSentinelData.physicalSentinel.physicalSentinel.isMovingUpIndicies = trackedSentinelData.isMovingUpIndicies;
			}
			ServerSend.SentinelInit(num, trackedSentinelData.patrolPoints, trackedSentinelData.currentPointIndex, trackedSentinelData.targetPointIndex, trackedSentinelData.isMovingUpIndicies, clientID);
		}

		public static void AlertSosigs(int clientID, Packet packet)
		{
		}

		public static void SetModulWeaponPart(int clientID, Packet packet)
		{
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Expected O, but got Unknown
			int num = packet.ReadInt();
			if (!(Server.objects[num] is TrackedItemData trackedItemData))
			{
				return;
			}
			string text = packet.ReadString();
			string text2 = packet.ReadString();
			string text3 = null;
			if (packet.ReadBool())
			{
				text3 = packet.ReadString();
			}
			if ((Object)(object)trackedItemData.physical == (Object)null)
			{
				List<byte> list = new List<byte>();
				int num2 = 0;
				int num3 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
				num2 += 4;
				for (int i = 0; i < num3; i++)
				{
					int num4 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					num2 += 4;
					string text4 = Encoding.ASCII.GetString(trackedItemData.additionalData, num2, num4);
					num2 += num4;
					int num5 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					num2 += 4;
					string s = Encoding.ASCII.GetString(trackedItemData.additionalData, num2, num5);
					num2 += num5;
					int num6 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					num2 += 4;
					string s2 = null;
					if (num6 > 0)
					{
						s2 = Encoding.ASCII.GetString(trackedItemData.additionalData, num2, num5);
						num2 += num6;
					}
					list.AddRange(BitConverter.GetBytes(num4));
					list.AddRange(Encoding.ASCII.GetBytes(text4));
					if (text4.Equals(text))
					{
						list.AddRange(BitConverter.GetBytes(text2.Length));
						list.AddRange(Encoding.ASCII.GetBytes(text2));
						list.AddRange(BitConverter.GetBytes(text3?.Length ?? 0));
						if (text3 != null)
						{
							list.AddRange(Encoding.ASCII.GetBytes(text3));
						}
					}
					else
					{
						list.AddRange(BitConverter.GetBytes(num5));
						list.AddRange(Encoding.ASCII.GetBytes(s));
						list.AddRange(BitConverter.GetBytes(num6));
						if (num6 > 0)
						{
							list.AddRange(Encoding.ASCII.GetBytes(s2));
						}
					}
					int num7 = BitConverter.ToInt32(trackedItemData.additionalData, num2);
					for (int j = 0; j < num7; j++)
					{
						list.Add(trackedItemData.additionalData[j + num2]);
					}
					num2 += num7;
					num2 += 4;
				}
				trackedItemData.additionalData = list.ToArray();
			}
			else
			{
				IDictionary dictionary = PatchController.MW_IModularWeapon_get_AllAttachmentPoints.Invoke(trackedItemData.physicalItem.dataObject, null) as IDictionary;
				ModularWeaponPartPatch.skip++;
				PatchController.MW_IModularWeapon_ConfigureModularWeaponPart.Invoke(trackedItemData.physicalItem.dataObject, new object[3]
				{
					dictionary[text],
					text2,
					false
				});
				if (text3 != null)
				{
					PatchController.MW_IModularWeapon_ApplySkin.Invoke(trackedItemData.physicalItem.dataObject, new object[2] { text, text3 });
				}
				ModularWeaponPartPatch.skip--;
				List<byte> list2 = new List<byte>();
				list2.AddRange(BitConverter.GetBytes(dictionary.Count));
				foreach (DictionaryEntry item in dictionary)
				{
					string text5 = (string)item.Key;
					string text6 = (string)PatchController.MW_ModularWeaponPartsAttachmentPoint_SelectedModularWeaponPart.GetValue(item.Value);
					list2.AddRange(BitConverter.GetBytes(text5.Length));
					list2.AddRange(Encoding.ASCII.GetBytes(text5));
					list2.AddRange(BitConverter.GetBytes(text6.Length));
					list2.AddRange(Encoding.ASCII.GetBytes(text6));
					Transform val = (Transform)PatchController.MW_ModularWeaponPartsAttachmentPoint_ModularPartPoint.GetValue(item.Value);
					MonoBehaviour[] components = ((Component)val).GetComponents<MonoBehaviour>();
					MonoBehaviour val2 = null;
					for (int k = 0; k < components.Length; k++)
					{
						if ((object)((object)components[k]).GetType() == PatchController.MW_ModularWeaponPart || ((object)components[k]).GetType().IsSubclassOf(PatchController.MW_ModularWeaponPart))
						{
							val2 = components[k];
							break;
						}
					}
					if ((Object)(object)val2 == (Object)null)
					{
						list2.AddRange(BitConverter.GetBytes(0));
					}
					else
					{
						string text7 = (string)PatchController.MW_ModularWeaponPart_SelectedModularWeaponPartSkinID.GetValue(val2);
						list2.AddRange(BitConverter.GetBytes(text7.Length));
						list2.AddRange(Encoding.ASCII.GetBytes(text7));
					}
					List<byte> list3 = new List<byte>();
					TrackedItem.AddModulPartDataInvoke(list3, text5, text6, dictionary, trackedItemData.physicalItem);
					list2.AddRange(BitConverter.GetBytes(list3.Count));
					list2.AddRange(list3);
				}
				trackedItemData.additionalData = list2.ToArray();
			}
			ServerSend.SetModulWeaponPart(num, text, text2, text3, clientID);
		}
	}
	public enum ServerPackets
	{
		welcome,
		spawnPlayer,
		playerState,
		playerScene,
		addNonSyncScene,
		shatterableCrateSetHoldingHealth,
		giveObjectControl,
		objectParent,
		connectSync,
		weaponFire,
		playerDamage,
		sosigPickUpItem,
		sosigPlaceItemIn,
		sosigDropSlot,
		sosigHandDrop,
		sosigConfigure,
		sosigLinkRegisterWearable,
		sosigLinkDeRegisterWearable,
		sosigSetIFF,
		sosigSetOriginalIFF,
		sosigLinkDamage,
		sosigDamageData,
		sosigWearableDamage,
		sosigLinkExplodes,
		sosigDies,
		sosigClear,
		sosigSetBodyState,
		playSosigFootStepSound,
		sosigSpeakState,
		sosigSetCurrentOrder,
		sosigVaporize,
		sosigRequestHitDecal,
		sosigLinkBreak,
		sosigLinkSever,
		updateRequest,
		playerInstance,
		addTNHInstance,
		addTNHCurrentlyPlaying,
		removeTNHCurrentlyPlaying,
		setTNHProgression,
		setTNHEquipment,
		setTNHHealthMode,
		setTNHTargetMode,
		setTNHAIDifficulty,
		setTNHRadarMode,
		setTNHItemSpawnerMode,
		setTNHBackpackMode,
		setTNHHealthMult,
		setTNHSosigGunReload,
		setTNHSeed,
		setTNHLevelID,
		addInstance,
		setTNHController,
		spectatorHost,
		TNHPlayerDied,
		TNHAddTokens,
		TNHSetLevel,
		autoMeaterSetState,
		autoMeaterSetBladesActive,
		autoMeaterDamage,
		autoMeaterFireShot,
		autoMeaterFirearmFireAtWill,
		autoMeaterHitZoneDamage,
		autoMeaterHitZoneDamageData,
		TNHSosigKill,
		TNHHoldPointSystemNode,
		TNHHoldBeginChallenge,
		TNHSetPhaseTake,
		TNHHoldCompletePhase,
		TNHHoldPointFailOut,
		TNHSetPhaseComplete,
		TNHSetPhase,
		encryptionDamage,
		encryptionDamageData,
		encryptionRespawnSubTarg,
		encryptionSpawnGrowth,
		encryptionInit,
		encryptionResetGrowth,
		encryptionDisableSubtarg,
		encryptionSubDamage,
		shatterableCrateDamage,
		shatterableCrateDestroy,
		initTNHInstances,
		sosigWeaponFire,
		sosigWeaponShatter,
		sosigWeaponDamage,
		LAPD2019Fire,
		LAPD2019LoadBattery,
		LAPD2019ExtractBattery,
		minigunFire,
		attachableFirearmFire,
		breakActionWeaponFire,
		playerIFF,
		uberShatterableShatter,
		TNHHoldPointBeginAnalyzing,
		TNHHoldPointRaiseBarriers,
		TNHHoldIdentifyEncryption,
		TNHHoldPointBeginPhase,
		TNHHoldPointCompleteHold,
		sosigPriorityIFFChart,
		leverActionFirearmFire,
		revolvingShotgunFire,
		derringerFire,
		flintlockWeaponBurnOffOuter,
		flintlockWeaponFire,
		grappleGunFire,
		HCBReleaseSled,
		remoteMissileDetonate,
		remoteMissileDamage,
		revolverFire,
		singleActionRevolverFire,
		stingerLauncherFire,
		stingerMissileDamage,
		stingerMissileExplode,
		pinnedGrenadeExplode,
		FVRGrenadeExplode,
		clientDisconnect,
		serverClosed,
		initConnectionData,
		bangSnapSplode,
		C4Detonate,
		claymoreMineDetonate,
		SLAMDetonate,
		ping,
		TNHSetPhaseHold,
		shatterableCrateSetHoldingToken,
		resetTNH,
		reviveTNHPlayer,
		playerColor,
		colorByIFF,
		nameplateMode,
		radarMode,
		radarColor,
		TNHInitializer,
		maxHealth,
		fuseIgnite,
		fuseBoom,
		molotovShatter,
		molotovDamage,
		pinnedGrenadePullPin,
		magazineAddRound,
		clipAddRound,
		speedloaderChamberLoad,
		remoteGunChamber,
		chamberRound,
		magazineLoad,
		magazineLoadAttachable,
		clipLoad,
		revolverCylinderLoad,
		revolvingShotgunLoad,
		grappleGunLoad,
		carlGustafLatchSate,
		carlGustafShellSlideSate,
		TNHHostStartHold,
		integratedFirearmFire,
		grappleAttached,
		trackedObject,
		trackedObjects,
		objectUpdate,
		destroyObject,
		registerCustomPacketType,
		breakableGlassDamage,
		windowShatterSound,
		spectatorHostAssignment,
		giveUpSpectatorHost,
		spectatorHostOrderTNHHost,
		TNHSpectatorHostReady,
		spectatorHostStartTNH,
		unassignSpectatorHost,
		reactiveSteelTargetDamage,
		MTUTest,
		IDConfirm,
		enforcePlayerModels,
		objectScene,
		objectInstance,
		updateEncryptionDisplay,
		encryptionRespawnSubTargGeo,
		roundDamage,
		roundSplode,
		connectionComplete,
		sightFlipperState,
		sightRaiserState,
		gatlingGunFire,
		punchThrough,
		gasCuboidGout,
		gasCuboidDamage,
		gasCuboidHandleDamage,
		gasCuboidDamageHandle,
		gasCuboidExplode,
		gasCuboidShatter,
		floaterDamage,
		floaterCoreDamage,
		floaterBeginExploding,
		floaterExplode,
		irisShatter,
		irisSetState,
		brutBlockSystemStart,
		floaterBeginDefusing,
		batchedPacket,
		nodeInit,
		nodeFire,
		hazeDamage,
		encryptionFireGun,
		encryptionNextPos,
		encryptionShieldRot,
		sentinelInit,
		alertSosigs,
		SetModulWeaponPart,
		shatterableCrateSetUsesLoot
	}
	public enum ClientPackets
	{
		grappleAttached,
		welcomeReceived,
		playerState,
		playerScene,
		addNonSyncScene,
		destroyObject,
		objectUpdate,
		shatterableCrateSetHoldingHealth,
		giveObjectControl,
		trackedObjects,
		objectParent,
		weaponFire,
		playerDamage,
		remoteGunChamber,
		chamberRound,
		integratedFirearmFire,
		trackedObject,
		sosigPickupItem,
		sosigPlaceItemIn,
		sosigDropSlot,
		sosigHandDrop,
		sosigConfigure,
		sosigLinkRegisterWearable,
		sosigLinkDeRegisterWearable,
		sosigSetIFF,
		sosigSetOriginalIFF,
		sosigLinkDamage,
		sosigDamageData,
		sosigWearableDamage,
		sosigLinkExplodes,
		sosigDies,
		sosigClear,
		sosigSetBodyState,
		playSosigFootStepSound,
		sosigSpeakState,
		sosigSetCurrentOrder,
		sosigVaporize,
		sosigRequestHitDecal,
		sosigLinkBreak,
		sosigLinkSever,
		updateObjectRequest,
		speedloaderChamberLoad,
		playerInstance,
		addTNHInstance,
		addTNHCurrentlyPlaying,
		removeTNHCurrentlyPlaying,
		setTNHProgression,
		setTNHEquipment,
		setTNHHealthMode,
		setTNHTargetMode,
		setTNHAIDifficulty,
		setTNHRadarMode,
		setTNHItemSpawnerMode,
		setTNHBackpackMode,
		setTNHHealthMult,
		setTNHSosigGunReload,
		setTNHSeed,
		setTNHLevelID,
		addInstance,
		setTNHController,
		spectatorHost,
		TNHPlayerDied,
		TNHAddTokens,
		TNHSetLevel,
		revolvingShotgunLoad,
		grappleGunLoad,
		carlGustafLatchSate,
		carlGustafShellSlideSate,
		TNHHostStartHold,
		autoMeaterSetState,
		autoMeaterSetBladesActive,
		autoMeaterDamage,
		autoMeaterDamageData,
		autoMeaterFireShot,
		autoMeaterFirearmFireAtWill,
		autoMeaterHitZoneDamage,
		autoMeaterHitZoneDamageData,
		TNHSosigKill,
		TNHHoldPointSystemNode,
		TNHHoldBeginChallenge,
		shatterableCrateDamage,
		TNHSetPhaseTake,
		TNHHoldCompletePhase,
		TNHHoldPointFailOut,
		TNHSetPhaseComplete,
		TNHSetPhase,
		magazineLoad,
		magazineLoadAttachable,
		clipLoad,
		revolverCylinderLoad,
		encryptionDamage,
		encryptionDamageData,
		encryptionRespawnSubTarg,
		encryptionSpawnGrowth,
		encryptionInit,
		encryptionResetGrowth,
		encryptionDisableSubtarg,
		encryptionSubDamage,
		shatterableCrateDestroy,
		registerCustomPacketType,
		DoneLoadingScene,
		DoneSendingUpdaToDateObjects,
		sosigWeaponFire,
		sosigWeaponShatter,
		sosigWeaponDamage,
		LAPD2019Fire,
		LAPD2019LoadBattery,
		LAPD2019ExtractBattery,
		minigunFire,
		attachableFirearmFire,
		breakActionWeaponFire,
		playerIFF,
		uberShatterableShatter,
		TNHHoldPointBeginAnalyzing,
		TNHHoldPointRaiseBarriers,
		TNHHoldIdentifyEncryption,
		TNHHoldPointBeginPhase,
		TNHHoldPointCompleteHold,
		sosigPriorityIFFChart,
		leverActionFirearmFire,
		revolvingShotgunFire,
		derringerFire,
		flintlockWeaponBurnOffOuter,
		flintlockWeaponFire,
		grappleGunFire,
		HCBReleaseSled,
		remoteMissileDetonate,
		remoteMissileDamage,
		revolverFire,
		singleActionRevolverFire,
		stingerLauncherFire,
		stingerMissileDamage,
		stingerMissileExplode,
		pinnedGrenadeExplode,
		FVRGrenadeExplode,
		clientDisconnect,
		bangSnapSplode,
		C4Detonate,
		claymoreMineDetonate,
		SLAMDetonate,
		ping,
		TNHSetPhaseHold,
		shatterableCrateSetHoldingToken,
		resetTNH,
		reviveTNHPlayer,
		playerColor,
		requestTNHInit,
		TNHInit,
		fuseIgnite,
		fuseBoom,
		molotovShatter,
		molotovDamage,
		pinnedGrenadePullPin,
		magazineAddRound,
		clipAddRound,
		breakableGlassDamage,
		windowShatterSound,
		requestSpectatorHost,
		unassignSpectatorHost,
		spectatorHostOrderTNHHost,
		TNHSpectatorHostReady,
		spectatorHostStartTNH,
		reassignSpectatorHost,
		reactiveSteelTargetDamage,
		MTUTest,
		IDConfirm,
		objectScene,
		objectInstance,
		updateEncryptionDisplay,
		encryptionRespawnSubTargGeo,
		roundDamage,
		roundSplode,
		sightFlipperState,
		sightRaiserState,
		gatlingGunFire,
		gasCuboidGout,
		gasCuboidDamage,
		gasCuboidHandleDamage,
		gasCuboidDamageHandle,
		gasCuboidExplode,
		gasCuboidShatter,
		floaterDamage,
		floaterCoreDamage,
		floaterBeginExploding,
		floaterExplode,
		irisShatter,
		irisSetState,
		brutBlockSystemStart,
		floaterBeginDefusing,
		batchedPacket,
		nodeInit,
		nodeFire,
		hazeDamage,
		encryptionFireGun,
		encryptionNextPos,
		encryptionShieldRot,
		sentinelInit,
		alertSosigs,
		setModulWeaponPart,
		shatterableCrateSetUsesLoot
	}
	public class Packet : IDisposable
	{
		public List<byte> buffer;

		public byte[] readableBuffer;

		public int readPos;

		private bool disposed = false;

		public Packet()
		{
			buffer = new List<byte>();
			readPos = 0;
		}

		public Packet(int _id)
		{
			buffer = new List<byte>();
			readPos = 0;
			Write(_id);
		}

		public Packet(byte[] _data)
		{
			buffer = new List<byte>();
			readPos = 0;
			SetBytes(_data);
		}

		public void SetBytes(byte[] _data)
		{
			Write(_data);
			readableBuffer = buffer.ToArray();
		}

		public void WriteLength()
		{
			buffer.InsertRange(0, BitConverter.GetBytes(buffer.Count));
		}

		public void InsertInt(int _value)
		{
			buffer.InsertRange(0, BitConverter.GetBytes(_value));
		}

		public byte[] ToArray()
		{
			readableBuffer = buffer.ToArray();
			return readableBuffer;
		}

		public int Length()
		{
			return buffer.Count;
		}

		public int UnreadLength()
		{
			return Length() - readPos;
		}

		public void Reset(bool _shouldReset = true)
		{
			if (_shouldReset)
			{
				buffer.Clear();
				readableBuffer = null;
				readPos = 0;
			}
			else
			{
				readPos -= 4;
			}
		}

		public void Write(byte _value)
		{
			buffer.Add(_value);
		}

		public void Write(byte[] _value)
		{
			buffer.AddRange(_value);
		}

		public void Write(short _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(ushort _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(int _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(uint _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(long _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(float _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(double _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(bool _value)
		{
			buffer.AddRange(BitConverter.GetBytes(_value));
		}

		public void Write(string _value)
		{
			Write(_value.Length);
			buffer.AddRange(Encoding.ASCII.GetBytes(_value));
		}

		public void Write(Vector3 _value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Write(_value.x);
			Write(_value.y);
			Write(_value.z);
		}

		public void Write(Vector2 _value)
		{
			//IL_0002: 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)
			Write(_value.x);
			Write(_value.y);
		}

		public void Write(Quaternion _value)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Write(_value.x);
			Write(_value.y);
			Write(_value.z);
			Write(_value.w);
		}

		public void Write(Damage damage)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			Write(damage.point);
			Write(damage.Source_IFF);
			Write(damage.Source_Point);
			Write(damage.Dam_Blunt);
			Write(damage.Dam_Piercing);
			Write(damage.Dam_Cutting);
			Write(damage.Dam_TotalKinetic);
			Write(damage.Dam_Thermal);
			Write(damage.Dam_Chilling);
			Write(damage.Dam_EMP);
			Write(damage.Dam_TotalEnergetic);
			Write(damage.Dam_Stunning);
			Write(damage.Dam_Blinding);
			Write(damage.hitNormal);
			Write(damage.strikeDir);
			Write(damage.edgeNormal);
			Write(damage.damageSize);
			Write((byte)damage.Class);
		}

		public void Write(SosigConfigTemplate config)
		{
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			Write(config.AppliesDamageResistToIntegrityLoss);
			Write(config.DoesDropWeaponsOnBallistic);
			Write(config.TotalMustard);
			Write(config.BleedDamageMult);
			Write(config.BleedRateMultiplier);
			Write(config.BleedVFXIntensity);
			Write(config.SearchExtentsModifier);
			Write(config.ShudderThreshold);
			Write(config.ConfusionThreshold);
			Write(config.ConfusionMultiplier);
			Write(config.ConfusionTimeMax);
			Write(config.StunThreshold);
			Write(config.StunMultiplier);
			Write(config.StunTimeMax);
			Write(config.HasABrain);
			Write(config.HasNightVision);
			Write(config.RegistersPassiveThreats);
			Write(config.CanBeKnockedOut);
			Write(config.MaxUnconsciousTime);
			Write(config.IgnoresNeedForWeapons);
			Write(config.AssaultPointOverridesSkirmishPointWhenFurtherThan);
			Write(config.ViewDistance);
			Write(config.HearingDistance);
			Write(config.MaxFOV);
			Write(config.StateSightRangeMults);
			Write(config.StateHearingRangeMults);
			Write(config.StateFOVMults);
			Write(config.CanPickup_Ranged);
			Write(config.CanPickup_Melee);
			Write(config.CanPickup_Other);
			Write(config.MaxThreatingIFFReactionRange_Visual);
			Write(config.MaxThreatingIFFReactionRange_Sonic);
			Write(config.AggroSensitivityMultiplier);
			Write(config.EntityRecognitionSpeedMultiplier);
			Write(config.CombatTargetIdentificationSpeedMultiplier);
			Write(config.DoesJointBreakKill_Head);
			Write(config.DoesJointBreakKill_Upper);
			Write(config.DoesJointBreakKill_Lower);
			Write(config.DoesSeverKill_Head);
			Write(config.DoesSeverKill_Upper);
			Write(config.DoesSeverKill_Lower);
			Write(config.DoesExplodeKill_Head);
			Write(config.DoesExplodeKill_Upper);
			Write(config.DoesExplodeKill_Lower);
			Write(config.CrawlSpeed);
			Write(config.SneakSpeed);
			Write(config.WalkSpeed);
			Write(config.RunSpeed);
			Write(config.TurnSpeed);
			Write(config.MovementRotMagnitude);
			Write(config.DamMult_Projectile);
			Write(config.DamMult_Explosive);
			Write(config.DamMult_Melee);
			Write(config.DamMult_Piercing);
			Write(config.DamMult_Blunt);
			Write(config.DamMult_Cutting);
			Write(config.DamMult_Thermal);
			Write(config.DamMult_Chilling);
			Write(config.DamMult_EMP);
			Write(config.CanBeSurpressed);
			Write(config.SuppressionMult);
			Write(config.CanBeGrabbed);
			Write(config.CanBeSevered);
			Write(config.CanBeStabbed);
			Write(config.MaxJointLimit);
			if (config.LinkDamageMultipliers == null || config.LinkDamageMultipliers.Count == 0)
			{
				Write((byte)0);
			}
			else
			{
				Write((byte)config.LinkDamageMultipliers.Count);
				foreach (float linkDamageMultiplier in config.LinkDamageMultipliers)
				{
					Write(linkDamageMultiplier);
				}
			}
			if (config.LinkStaggerMultipliers == null || config.LinkStaggerMultipliers.Count == 0)
			{
				Write((byte)0);
			}
			else
			{
				Write((byte)config.LinkStaggerMultipliers.Count);
				foreach (float linkStaggerMultiplier in config.LinkStaggerMultipliers)
				{
					Write(linkStaggerMultiplier);
				}
			}
			if (config.StartingLinkIntegrity == null || config.StartingLinkIntegrity.Count == 0)
			{
				Write((byte)0);
			}
			else
			{
				Write((byte)config.StartingLinkIntegrity.Count);
				foreach (Vector2 item in config.StartingLinkIntegrity)
				{
					Write(item);
				}
			}
			if (config.StartingChanceBrokenJoint == null || config.StartingChanceBrokenJoint.Count == 0)
			{
				Write((byte)0);
			}
			else
			{
				Write((byte)config.StartingChanceBrokenJoint.Count);
				foreach (float item2 in config.StartingChanceBrokenJoint)
				{
					Write(item2);
				}
			}
			if (config.LinkSpawnChance == null || config.LinkSpawnChance.Count == 0)
			{
				Write((byte)0);
			}
			else
			{
				Write((byte)config.LinkSpawnChance.Count);
				foreach (float item3 in config.LinkSpawnChance)
				{
					Write(item3);
				}
			}
			Write(config.TargetCapacity);
			Write(config.TargetTrackingTime);
			Write(config.NoFreshTargetTime);
			Write(config.DoesAggroOnFriendlyFire);
			Write(config.UsesLinkSpawns);
			Write(config.TimeInSkirmishToAlert);
		}

		public void Write(TNHInstance instance, bool full = false)
		{
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			Write(instance.instance);
			Write(instance.letPeopleJoin);
			Write(instance.progressionTypeSetting);
			Write(instance.healthModeSetting);
			Write(instance.equipmentModeSetting);
			Write(instance.targetModeSetting);
			Write(instance.AIDifficultyModifier);
			Write(instance.radarModeModifier);
			Write(instance.itemSpawnerMode);
			Write(instance.backpackMode);
			Write(instance.healthMult);
			Write(instance.sosiggunShakeReloading);
			Write(instance.TNHSeed);
			Write(instance.levelID);
			if (instance.playerIDs == null || instance.playerIDs.Count == 0)
			{
				Write(0);
			}
			else
			{
				Write(instance.playerIDs.Count);
				for (int i = 0; i < instance.playerIDs.Count; i++)
				{
					Write(instance.playerIDs[i]);
				}
			}
			Write(instance.initializer);
			Write(instance.controller);
			if (!full)
			{
				return;
			}
			if (instance.currentlyPlaying == null || instance.currentlyPlaying.Count == 0)
			{
				Write(0);
			}
			else
			{
				Write(instance.currentlyPlaying.Count);
				foreach (int item in instance.currentlyPlaying)
				{
					Write(item);
				}
			}
			if (instance.played == null || instance.played.Count == 0)
			{
				Write(0);
			}
			else
			{
				Write(instance.played.Count);
				foreach (int item2 in instance.played)
				{
					Write(item2);
				}
			}
			if (instance.dead == null || instance.dead.Count == 0)
			{
				Write(0);
			}
			else
			{
				Write(instance.dead.Count);
				foreach (int item3 in instance.dead)
				{
					Write(item3);
				}
			}
			Write(instance.tokenCount);
			Write(instance.holdOngoing);
			Write(instance.curHoldIndex);
			Write(instance.level);
			Write((short)instance.phase);
			if (instance.activeSupplyPointIndices == null || instance.activeSupplyPointIndices.Count == 0)
			{
				Write(0);
			}
			else
			{
				Write(instance.activeSupplyPointIndices.Count);
				foreach (int activeSupplyPointIndex in instance.activeSupplyPointIndices)
				{
					Write(activeSupplyPointIndex);
				}
			}
			if (instance.raisedBarriers == null || instance.raisedBarriers.Count == 0)
			{
				Write(0);
			}
			else
			{
				Write(instance.raisedBarriers.Count);
				foreach (int raisedBarrier in instance.raisedBarriers)
				{
					Write(raisedBarrier);
				}
			}
			if (instance.raisedBarrierPrefabIndices == null || instance.raisedBarrierPrefabIndices.Count == 0)
			{
				Write(0);
				return;
			}
			Write(instance.raisedBarrierPrefabIndices.Count);
			foreach (int raisedBarrierPrefabIndex in instance.raisedBarrierPrefabIndices)
			{
				Write(raisedBarrierPrefabIndex);
			}
		}

		public void Write(SosigPatrolSquad patrol)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			Write(patrol.Squad.Count);
			for (int i = 0; i < patrol.Squad.Count; i++)
			{
				Write(((Component)patrol.Squad[i]).GetComponent<TrackedSosig>().data.trackedID);
			}
			Write(patrol.PatrolPoints.Count);
			for (int j = 0; j < patrol.PatrolPoints.Count; j++)
			{
				Write(patrol.PatrolPoints[j]);
			}
			Write(patrol.CurPatrolPointIndex);
			Write(patrol.IsPatrollingUp);
		}

		public byte ReadByte(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				byte result = readableBuffer[readPos];
				if (_moveReadPos)
				{
					readPos++;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'byte'!");
		}

		public byte[] ReadBytes(int _length, bool _moveReadPos = true)
		{
			if (_length == 0)
			{
				return null;
			}
			if (buffer.Count > readPos)
			{
				byte[] result = buffer.GetRange(readPos, _length).ToArray();
				if (_moveReadPos)
				{
					readPos += _length;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'byte[]'!");
		}

		public short ReadShort(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				short result = BitConverter.ToInt16(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos += 2;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'short'!");
		}

		public ushort ReadUShort(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				ushort result = BitConverter.ToUInt16(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos += 2;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'ushort'!");
		}

		public int ReadInt(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				int result = BitConverter.ToInt32(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos += 4;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'int'!");
		}

		public uint ReadUInt(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				uint result = BitConverter.ToUInt32(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos += 4;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'uint'!");
		}

		public long ReadLong(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				long result = BitConverter.ToInt64(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos += 8;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'long'!");
		}

		public float ReadFloat(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				float result = BitConverter.ToSingle(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos += 4;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'float'!");
		}

		public double ReadDouble(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				double result = BitConverter.ToDouble(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos += 8;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'double'!");
		}

		public bool ReadBool(bool _moveReadPos = true)
		{
			if (buffer.Count > readPos)
			{
				bool result = BitConverter.ToBoolean(readableBuffer, readPos);
				if (_moveReadPos)
				{
					readPos++;
				}
				return result;
			}
			throw new Exception("Could not read value of type 'bool'!");
		}

		public string ReadString(bool _moveReadPos = true)
		{
			try
			{
				int num = ReadInt();
				string text = Encoding.ASCII.GetString(readableBuffer, readPos, num);
				if (_moveReadPos && text.Length > 0)
				{
					readPos += num;
				}
				return text;
			}
			catch
			{
				throw new Exception("Could not read value of type 'string'!");
			}
		}

		public Vector3 ReadVector3(bool _moveReadPos = true)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(ReadFloat(_moveReadPos), ReadFloat(_moveReadPos), ReadFloat(_moveReadPos));
		}

		public Vector2 ReadVector2(bool _moveReadPos = true)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(ReadFloat(_moveReadPos), ReadFloat(_moveReadPos));
		}

		public Quaternion ReadQuaternion(bool _moveReadPos = true)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(ReadFloat(_moveReadPos), ReadFloat(_moveReadPos), ReadFloat(_moveReadPos), ReadFloat(_moveReadPos));
		}

		public SosigConfigTemplate ReadSosigConfig(bool full = false, bool _moveReadPos = true)
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			SosigConfigTemplate val = ScriptableObject.CreateInstance<SosigConfigTemplate>();
			val.AppliesDamageResistToIntegrityLoss = ReadBool();
			val.DoesDropWeaponsOnBallistic = ReadBool();
			val.TotalMustard = ReadFloat();
			val.BleedDamageMult = ReadFloat();
			val.BleedRateMultiplier = ReadFloat();
			val.BleedVFXIntensity = ReadFloat();
			val.SearchExtentsModifier = ReadFloat();
			val.ShudderThreshold = ReadFloat();
			val.ConfusionThreshold = ReadFloat();
			val.ConfusionMultiplier = ReadFloat();
			val.ConfusionTimeMax = ReadFloat();
			val.StunThreshold = ReadFloat();
			val.StunMultiplier = ReadFloat();
			val.StunTimeMax = ReadFloat();
			val.HasABrain = ReadBool();
			val.HasNightVision = ReadBool();
			val.RegistersPassiveThreats = ReadBool();
			val.CanBeKnockedOut = ReadBool();
			val.MaxUnconsciousTime = ReadFloat();
			val.IgnoresNeedForWeapons = ReadBool();
			val.AssaultPointOverridesSkirmishPointWhenFurtherThan = ReadFloat();
			val.ViewDistance = ReadFloat();
			val.HearingDistance = ReadFloat();
			val.MaxFOV = ReadFloat();
			val.StateSightRangeMults = ReadVector3();
			val.StateHearingRangeMults = ReadVector3();
			val.StateFOVMults = ReadVector3();
			val.CanPickup_Ranged = ReadBool();
			val.CanPickup_Melee = ReadBool();
			val.CanPickup_Other = ReadBool();
			val.MaxThreatingIFFReactionRange_Visual = ReadFloat();
			val.MaxThreatingIFFReactionRange_Sonic = ReadFloat();
			val.AggroSensitivityMultiplier = ReadFloat();
			val.EntityRecognitionSpeedMultiplier = ReadFloat();
			val.CombatTargetIdentificationSpeedMultiplier = ReadFloat();
			val.DoesJointBreakKill_Head = ReadBool();
			val.DoesJointBreakKill_Upper = ReadBool();
			val.DoesJointBreakKill_Lower = ReadBool();
			val.DoesSeverKill_Head = ReadBool();
			val.DoesSeverKill_Upper = ReadBool();
			val.DoesSeverKill_Lower = ReadBool();
			val.DoesExplodeKill_Head = ReadBool();
			val.DoesExplodeKill_Upper = ReadBool();
			val.DoesExplodeKill_Lower = ReadBool();
			val.CrawlSpeed = ReadFloat();
			val.SneakSpeed = ReadFloat();
			val.WalkSpeed = ReadFloat();
			val.RunSpeed = ReadFloat();
			val.TurnSpeed = ReadFloat();
			val.MovementRotMagnitude = ReadFloat();
			val.DamMult_Projectile = ReadFloat();
			val.DamMult_Explosive = ReadFloat();
			val.DamMult_Melee = ReadFloat();
			val.DamMult_Piercing = ReadFloat();
			val.DamMult_Blunt = ReadFloat();
			val.DamMult_Cutting = ReadFloat();
			val.DamMult_Thermal = ReadFloat();
			val.DamMult_Chilling = ReadFloat();
			val.DamMult_EMP = ReadFloat();
			val.CanBeSurpressed = ReadBool();
			val.SuppressionMult = ReadFloat();
			val.CanBeGrabbed = ReadBool();
			val.CanBeSevered = ReadBool();
			val.CanBeStabbed = ReadBool();
			val.MaxJointLimit = ReadFloat();
			byte b = ReadByte();
			if (b > 0)
			{
				val.LinkDamageMultipliers = new List<float>();
				for (int i = 0; i < b; i++)
				{
					val.LinkDamageMultipliers.Add(ReadFloat());
				}
			}
			byte b2 = ReadByte();
			if (b2 > 0)
			{
				val.LinkStaggerMultipliers = new List<float>();
				for (int j = 0; j < b2; j++)
				{
					val.LinkStaggerMultipliers.Add(ReadFloat());
				}
			}
			byte b3 = ReadByte();
			if (b3 > 0)
			{
				val.StartingLinkIntegrity = new List<Vector2>();
				for (int k = 0; k < b3; k++)
				{
					val.StartingLinkIntegrity.Add(ReadVector2());
				}
			}
			byte b4 = ReadByte();
			if (b4 > 0)
			{
				val.StartingChanceBrokenJoint = new List<float>();
				for (int l = 0; l < b4; l++)
				{
					val.StartingChanceBrokenJoint.Add(ReadFloat());
				}
			}
			byte b5 = ReadByte();
			if (b5 > 0)
			{
				val.LinkSpawnChance = new List<float>();
				for (int m = 0; m < b5; m++)
				{
					val.LinkSpawnChance.Add(ReadFloat());
				}
			}
			val.TargetCapacity = ReadInt();
			val.TargetTrackingTime = ReadFloat();
			val.NoFreshTargetTime = ReadFloat();
			val.DoesAggroOnFriendlyFire = ReadBool();
			val.UsesLinkSpawns = ReadBool();
			val.TimeInSkirmishToAlert = ReadFloat();
			return val;
		}

		public Damage ReadDamage(bool _moveReadPos = true)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			Damage val = new Damage();
			val.point = ReadVector3();
			val.Source_IFF = ReadInt();
			val.Source_Point = ReadVector3();
			val.Dam_Blunt = ReadFloat();
			val.Dam_Piercing = ReadFloat();
			val.Dam_Cutting = ReadFloat();
			val.Dam_TotalKinetic = ReadFloat();
			val.Dam_Thermal = ReadFloat();
			val.Dam_Chilling = ReadFloat();
			val.Dam_EMP = ReadFloat();
			val.Dam_TotalEnergetic = ReadFloat();
			val.Dam_Stunning = ReadFloat();
			val.Dam_Blinding = ReadFloat();
			val.hitNormal = ReadVector3();
			val.strikeDir = ReadVector3();
			val.edgeNormal = ReadVector3();
			val.damageSize = ReadFloat();
			val.Class = (DamageClass)ReadByte();
			return val;
		}

		public TNHInstance ReadTNHInstance(bool full = false, bool _moveReadPos = true)
		{
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			int instance = ReadInt();
			bool letPeopleJoin = ReadBool();
			int progressionTypeSetting = ReadInt();
			int healthModeSetting = ReadInt();
			int equipmentModeSetting = ReadInt();
			int targetModeSetting = ReadInt();
			int aIDifficultyModifier = ReadInt();
			int radarModeModifier = ReadInt();
			int itemSpawnerMode = ReadInt();
			int backpackMode = ReadInt();
			int healthMult = ReadInt();
			int sosiggunShakeReloading = ReadInt();
			int tNHSeed = ReadInt();
			string levelID = ReadString();
			int num = ReadInt();
			int hostID = ReadInt();
			TNHInstance tNHInstance = new TNHInstance(instance, hostID, letPeopleJoin, progressionTypeSetting, healthModeSetting, equipmentModeSetting, targetModeSetting, aIDifficultyModifier, radarModeModifier, itemSpawnerMode, backpackMode, healthMult, sosiggunShakeReloading, tNHSeed, levelID);
			for (int i = 1; i < num; i++)
			{
				int item = ReadInt();
				if (tNHInstance.playerIDs.Contains(item))
				{
					Mod.LogWarning("ReadTNHInstance player ID: " + item + " already in TNH instance " + instance + ":\n" + Environment.StackTrace);
				}
				else
				{
					tNHInstance.playerIDs.Add(item);
				}
			}
			tNHInstance.initializer = ReadInt();
			tNHInstance.controller = ReadInt();
			if (full)
			{
				int num2 = ReadInt();
				for (int j = 0; j < num2; j++)
				{
					tNHInstance.currentlyPlaying.Add(ReadInt());
				}
				int num3 = ReadInt();
				for (int k = 0; k < num3; k++)
				{
					tNHInstance.played.Add(ReadInt());
				}
				int num4 = ReadInt();
				for (int l = 0; l < num4; l++)
				{
					tNHInstance.dead.Add(ReadInt());
				}
				tNHInstance.tokenCount = ReadInt();
				tNHInstance.holdOngoing = ReadBool();
				tNHInstance.curHoldIndex = ReadInt();
				tNHInstance.level = ReadInt();
				tNHInstance.phase = (TNH_Phase)ReadShort();
				int num5 = ReadInt();
				if (num5 > 0)
				{
					tNHInstance.activeSupplyPointIndices = new List<int>();
				}
				for (int m = 0; m < num5; m++)
				{
					tNHInstance.activeSupplyPointIndices.Add(ReadInt());
				}
				int num6 = ReadInt();
				if (num6 > 0)
				{
					tNHInstance.raisedBarriers = new List<int>();
				}
				for (int n = 0; n < num6; n++)
				{
					tNHInstance.raisedBarriers.Add(ReadInt());
				}
				int num7 = ReadInt();
				if (num7 > 0)
				{
					tNHInstance.raisedBarrierPrefabIndices = new List<int>();
				}
				for (int num8 = 0; num8 < num7; num8++)
				{
					tNHInstance.raisedBarrierPrefabIndices.Add(ReadInt());
				}
			}
			return tNHInstance;
		}

		protected virtual void Dispose(bool _disposing)
		{
			if (!disposed)
			{
				if (_disposing)
				{
					buffer = null;
					readableBuffer = null;
					readPos = 0;
				}
				disposed = true;
			}
		}

		public void Dispose()
		{
			Dispose(_disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class ServerSend
	{
		private static void ConvertToCustomID(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(BitConverter.ToInt32(new byte[4]
			{
				packet.buffer[0],
				packet.buffer[1],
				packet.buffer[2],
				packet.buffer[3]
			}, 0) * -1 - 2);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
		}

		public static void SendTCPData(int toClient, Packet packet, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendTCPData: " + BitConverter.ToInt32(packet.ToArray(), 0));
			}
			packet.WriteLength();
			Server.clients[toClient].tcp.SendData(packet);
		}

		public static void SendTCPData(List<int> toClients, Packet packet, int exclude = -1, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendTCPData multiple: " + BitConverter.ToInt32(packet.ToArray(), 0));
			}
			packet.WriteLength();
			for (int i = 0; i < toClients.Count; i++)
			{
				if (exclude == -1 || toClients[i] != exclude)
				{
					Server.clients[toClients[i]].tcp.SendData(packet);
				}
			}
		}

		public static void SendUDPData(List<int> toClients, Packet packet, int exclude = -1, bool custom = false, object key = null)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (key == null)
			{
				key = new object();
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendUDPData multiple: " + BitConverter.ToInt32(packet.ToArray(), 0) + " with length " + packet.buffer.Count);
			}
			packet.WriteLength();
			for (int i = 0; i < toClients.Count; i++)
			{
				if (exclude == -1 || toClients[i] != exclude)
				{
					lock (Server.clients[toClients[i]].queuedPackets)
					{
						Server.clients[toClients[i]].queuedPackets[key] = packet.ToArray();
					}
				}
			}
		}

		public static void SendAllBatchedUDPData()
		{
			foreach (ServerClient value in Server.clients.Values)
			{
				SendBatchedPackets(value);
			}
		}

		public static void SendBatchedPackets(ServerClient client)
		{
			List<byte[]> list = new List<byte[]>();
			lock (client.queuedPackets)
			{
				list.AddRange(client.queuedPackets.Values);
				client.queuedPackets.Clear();
			}
			Packet packet = new Packet(198);
			foreach (byte[] item in list)
			{
				int num = packet.Length();
				if (num > 0 && num + item.Length > 1300)
				{
					packet.WriteLength();
					client.udp.SendData(packet);
					packet.Dispose();
					packet = new Packet(198);
				}
				packet.Write(item);
			}
			if (packet.Length() > 0)
			{
				packet.WriteLength();
				client.udp.SendData(packet);
			}
			packet.Dispose();
		}

		public static void SendTCPDataToAll(Packet packet, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendTCPDataToAll: " + BitConverter.ToInt32(packet.ToArray(), 0));
			}
			packet.WriteLength();
			for (int i = 1; i <= Server.maxClientCount; i++)
			{
				Server.clients[i].tcp.SendData(packet);
			}
		}

		public static void SendUDPDataToClients(Packet packet, List<int> clientIDs, int excluding = -1, bool custom = false, object key = null)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (key == null)
			{
				key = new object();
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendUDPDataToClients: " + BitConverter.ToInt32(packet.ToArray(), 0) + ", size " + packet.buffer.Count);
			}
			packet.WriteLength();
			foreach (int clientID in clientIDs)
			{
				if (excluding == -1 || clientID != excluding)
				{
					lock (Server.clients[clientID].queuedPackets)
					{
						Server.clients[clientID].queuedPackets[key] = packet.ToArray();
					}
				}
			}
		}

		public static void SendTCPDataToClients(Packet packet, List<int> clientIDs, int excluding = -1, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendTCPDataToClients: " + BitConverter.ToInt32(packet.ToArray(), 0));
			}
			packet.WriteLength();
			foreach (int clientID in clientIDs)
			{
				if (excluding == -1 || clientID != excluding)
				{
					Server.clients[clientID].tcp.SendData(packet);
				}
			}
		}

		public static void SendTCPDataToAll(int exceptClient, Packet packet, bool custom = false)
		{
			if (custom)
			{
				ConvertToCustomID(packet);
			}
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("SendTCPDataToAll: " + BitConverter.ToInt32(packet.ToArray(), 0));
			}
			packet.WriteLength();
			for (int i = 1; i <= Server.maxClientCount; i++)
			{
				if (i != exceptClient)
				{
					Server.clients[i].tcp.SendData(packet);
				}
			}
		}

		public static void Welcome(int toClient, string msg, bool colorByIFF, int nameplateMode, int radarMode, bool radarColor, Dictionary<string, Dictionary<int, KeyValuePair<float, int>>> maxHealthEntries)
		{
			using Packet packet = new Packet(0);
			packet.Write(msg);
			packet.Write(toClient);
			packet.Write((byte)(int)Mod.config["TickRate"]);
			packet.Write(colorByIFF);
			packet.Write(nameplateMode);
			packet.Write(radarMode);
			packet.Write(radarColor);
			packet.Write(maxHealthEntries.Count);
			foreach (KeyValuePair<string, Dictionary<int, KeyValuePair<float, int>>> maxHealthEntry in maxHealthEntries)
			{
				packet.Write(maxHealthEntry.Key);
				packet.Write(maxHealthEntry.Value.Count);
				foreach (KeyValuePair<int, KeyValuePair<float, int>> item in maxHealthEntry.Value)
				{
					packet.Write(item.Key);
					packet.Write(item.Value.Key);
					packet.Write(item.Value.Value);
				}
			}
			packet.Write(Mod.registeredCustomPacketIDs.Count);
			foreach (KeyValuePair<string, int> registeredCustomPacketID in Mod.registeredCustomPacketIDs)
			{
				packet.Write(registeredCustomPacketID.Key);
				packet.Write(registeredCustomPacketID.Value);
			}
			packet.Write(GameManager.spectatorHosts.Count);
			for (int i = 0; i < GameManager.spectatorHosts.Count; i++)
			{
				packet.Write(GameManager.spectatorHosts[i]);
			}
			SendTCPData(toClient, packet);
		}

		public static void Ping(int toClient, long time)
		{
			using Packet packet = new Packet(123);
			packet.Write(time);
			SendTCPData(toClient, packet);
		}

		public static void SpawnPlayer(int clientID, Player player, string scene, int instance, int IFF, int colorIndex, bool join = false)
		{
			SpawnPlayer(clientID, player.ID, player.username, scene, instance, IFF, colorIndex, join);
		}

		public static void SpawnPlayer(int clientID, int ID, string username, string scene, int instance, int IFF, int colorIndex, bool join = false)
		{
			Mod.LogInfo("Server sending SpawnPlayer order to " + clientID + ": ID: " + ID + ", username: " + username + ", scene: " + scene + ", instance: " + instance, debug: false);
			using Packet packet = new Packet(1);
			packet.Write(ID);
			packet.Write(username);
			packet.Write(scene);
			packet.Write(instance);
			packet.Write(IFF);
			packet.Write(colorIndex);
			packet.Write(join);
			SendTCPData(clientID, packet);
		}

		public static void ConnectSync(int clientID, bool inControl)
		{
			using Packet packet = new Packet(8);
			packet.Write(inControl);
			SendTCPData(clientID, packet);
		}

		public static void PlayerState(Player player, string scene, int instance)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			PlayerState(player.ID, player.position, player.rotation, player.headPos, player.headRot, player.torsoPos, player.torsoRot, player.leftHandPos, player.leftHandRot, player.leftHandPos, player.leftHandRot, player.health, player.maxHealth, scene, instance);
		}

		public static void PlayerState(int ID, Vector3 position, Quaternion rotation, Vector3 headPos, Quaternion headRot, Vector3 torsoPos, Quaternion torsoRot, Vector3 leftHandPos, Quaternion leftHandRot, Vector3 rightHandPos, Quaternion rightHandRot, float health, int maxHealth, string scene, int instance)
		{
			//IL_005b: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (!GameManager.playersByInstanceByScene.TryGetValue(scene, out var value) || !value.TryGetValue(instance, out var value2) || value2.Count <= 0 || (value2.Count <= 1 && value2[0] == ID))
			{
				return;
			}
			using Packet packet = new Packet(2);
			packet.Write(ID);
			packet.Write(position);
			packet.Write(rotation);
			packet.Write(headPos);
			packet.Write(headRot);
			packet.Write(torsoPos);
			packet.Write(torsoRot);
			packet.Write(leftHandPos);
			packet.Write(leftHandRot);
			packet.Write(rightHandPos);
			packet.Write(rightHandRot);
			packet.Write(health);
			packet.Write(maxHealth);
			byte[] array = ((GameManager.playerStateAddtionalDataSize == -1) ? null : new byte[GameManager.playerStateAddtionalDataSize]);
			if (array != null && array.Length != 0)
			{
				GameManager.playerStateAddtionalDataSize = array.Length;
				packet.Write((short)array.Length);
				packet.Write(array);
			}
			else
			{
				GameManager.playerStateAddtionalDataSize = 0;
				packet.Write((short)0);
			}
			SendUDPData(value2, packet, ID, custom: false, GM.CurrentPlayerBody);
		}

		public static void PlayerState(Packet packet, Player player)
		{
			if (GameManager.playersByInstanceByScene.TryGetValue(player.scene, out var value) && value.TryGetValue(player.instance, out var value2) && (value2.Count > 1 || value2[0] != player.ID))
			{
				byte[] bytes = BitConverter.GetBytes(2);
				for (int i = 0; i < 4; i++)
				{
					packet.buffer[i] = bytes[i];
				}
				packet.buffer.InsertRange(4, BitConverter.GetBytes(player.ID));
				SendUDPData(value2, packet, player.ID);
			}
		}

		public static void PlayerIFF(int clientID, int IFF)
		{
			using Packet packet = new Packet(92);
			packet.Write(clientID);
			packet.Write(IFF);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void PlayerScene(int clientID, string sceneName)
		{
			using Packet packet = new Packet(3);
			packet.Write(clientID);
			packet.Write(sceneName);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TrackedObjects()
		{
			if (GameManager.playersPresent.Count <= 0)
			{
				return;
			}
			for (int i = 0; i < GameManager.objects.Count; i++)
			{
				TrackedObjectData trackedObjectData = GameManager.objects[i];
				if (trackedObjectData.trackedID == -1)
				{
					continue;
				}
				if (trackedObjectData.Update())
				{
					trackedObjectData.latestUpdateSent = false;
					using Packet packet = new Packet(157);
					trackedObjectData.WriteToPacket(packet, incrementOrder: true, full: false);
					if (packet.buffer.Count >= 1500)
					{
						Mod.LogWarning("Update packet size for " + trackedObjectData.trackedID + " of type: " + trackedObjectData.typeIdentifier + " is above 1500 bytes");
					}
					SendUDPDataToClients(packet, GameManager.playersPresent, -1, custom: false, trackedObjectData);
				}
				else if (!trackedObjectData.latestUpdateSent)
				{
					trackedObjectData.latestUpdateSent = true;
					ObjectUpdate(trackedObjectData);
				}
			}
		}

		public static void TrackedObjects(Packet packet, List<int> players, int sender)
		{
			byte[] bytes = BitConverter.GetBytes(157);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendUDPDataToClients(packet, players, sender);
		}

		public static void ObjectUpdate(TrackedObjectData trackedObject)
		{
			using Packet packet = new Packet(158);
			trackedObject.WriteToPacket(packet, incrementOrder: true, full: false);
			if (GameManager.playersByInstanceByScene.TryGetValue(trackedObject.scene, out var value) && value.TryGetValue(trackedObject.instance, out var value2) && value2.Count > 0)
			{
				SendTCPDataToClients(packet, value2, trackedObject.controller);
			}
		}

		public static void ObjectUpdate(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(158);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (GameManager.playersByInstanceByScene.TryGetValue(Server.clients[clientID].player.scene, out var value) && value.TryGetValue(Server.clients[clientID].player.instance, out var value2) && value2.Count > 0)
			{
				SendTCPDataToClients(packet, value2, clientID);
			}
		}

		public static void TrackedObject(TrackedObjectData trackedObject, List<int> toClients)
		{
			using Packet packet = new Packet(156);
			trackedObject.WriteToPacket(packet, incrementOrder: false, full: true);
			SendTCPData(toClients, packet);
		}

		public static void TrackedObjectSpecific(TrackedObjectData trackedObject, int toClientID)
		{
			using Packet packet = new Packet(156);
			trackedObject.WriteToPacket(packet, incrementOrder: false, full: true);
			SendTCPData(toClientID, packet);
		}

		public static void GiveObjectControl(int trackedID, int clientID, List<int> debounce)
		{
			using Packet packet = new Packet(6);
			packet.Write(trackedID);
			packet.Write(clientID);
			if (debounce == null || debounce.Count == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(debounce.Count);
				for (int i = 0; i < debounce.Count; i++)
				{
					packet.Write(debounce[i]);
				}
			}
			SendTCPDataToAll(packet);
		}

		public static void DestroyObject(int trackedID, bool removeFromList = true, int clientID = -1)
		{
			using Packet packet = new Packet(159);
			packet.Write(trackedID);
			packet.Write(removeFromList);
			if (clientID == -1)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ObjectParent(int trackedID, int newParentID, int clientID = -1)
		{
			using Packet packet = new Packet(7);
			packet.Write(trackedID);
			packet.Write(newParentID);
			if (clientID == -1)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void WeaponFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, List<Vector3> positions, List<Vector3> directions, int chamberIndex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(9);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			packet.Write(chamberIndex);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void WeaponFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(9);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FlintlockWeaponBurnOffOuter(int clientID, int trackedID, LoadedElementType[] loadedElementTypes, float[] loadedElementPositions, int powderAmount, bool ramRod, float num2, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(103);
			packet.Write(trackedID);
			packet.Write((byte)loadedElementTypes.Length);
			for (int i = 0; i < loadedElementTypes.Length; i++)
			{
				packet.Write((byte)loadedElementTypes[i]);
				packet.Write(loadedElementPositions[i]);
			}
			packet.Write(powderAmount);
			packet.Write(ramRod);
			packet.Write(num2);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int j = 0; j < positions.Count; j++)
				{
					packet.Write(positions[j]);
					packet.Write(directions[j]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FlintlockWeaponBurnOffOuter(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(103);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FlintlockWeaponFire(int clientID, int trackedID, LoadedElementType[] loadedElementTypes, float[] loadedElementPositions, int[] loadedElementPowderAmounts, bool ramRod, float num5, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(104);
			packet.Write(trackedID);
			packet.Write((byte)loadedElementTypes.Length);
			for (int i = 0; i < loadedElementTypes.Length; i++)
			{
				packet.Write((byte)loadedElementTypes[i]);
				packet.Write(loadedElementPositions[i]);
				packet.Write(loadedElementPowderAmounts[i]);
			}
			packet.Write(ramRod);
			packet.Write(num5);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int j = 0; j < positions.Count; j++)
				{
					packet.Write(positions[j]);
					packet.Write(directions[j]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FlintlockWeaponFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(104);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void BreakActionWeaponFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int barrelIndex, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(91);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)barrelIndex);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void BreakActionWeaponFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(91);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void DerringerFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int barrelIndex, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(102);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)barrelIndex);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void DerringerFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(102);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void LeverActionFirearmFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, bool hammer1, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(100);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write(hammer1);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void LeverActionFirearmFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(100);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RevolvingShotgunFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(101);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RevolvingShotgunFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(101);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RevolverFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(109);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RevolverFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(109);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SingleActionRevolverFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(110);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SingleActionRevolverFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(110);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void StingerLauncherFire(int clientID, int trackedID, Vector3 targetPos, Vector3 position, Quaternion rotation)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(111);
			packet.Write(trackedID);
			packet.Write(targetPos);
			packet.Write(position);
			packet.Write(rotation);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void StingerLauncherFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(111);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GrappleGunFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, int curChamber, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(105);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write((byte)curChamber);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GrappleGunFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(105);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void HCBReleaseSled(int clientID, int trackedID, float cookedAmount, Vector3 position, Vector3 direction)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(106);
			packet.Write(trackedID);
			packet.Write(cookedAmount);
			packet.Write(position);
			packet.Write(direction);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void HCBReleaseSled(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(106);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SosigWeaponFire(int clientID, int trackedID, float recoilMult, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0050: 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)
			using Packet packet = new Packet(83);
			packet.Write(trackedID);
			packet.Write(recoilMult);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SosigWeaponFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(83);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void LAPD2019Fire(int clientID, int trackedID, int chamberIndex, FireArmRoundType roundType, FireArmRoundClass roundClass, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(86);
			packet.Write(trackedID);
			packet.Write(chamberIndex);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void LAPD2019Fire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(86);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void MinigunFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(89);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AttachableFirearmFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, bool firedFromInterface, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(90);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			packet.Write(firedFromInterface);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AttachableFirearmFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(90);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void IntegratedFirearmFire(int clientID, int trackedID, FireArmRoundType roundType, FireArmRoundClass roundClass, List<Vector3> positions, List<Vector3> directions)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(154);
			packet.Write(trackedID);
			packet.Write((short)roundType);
			packet.Write((short)roundClass);
			if (positions == null || positions.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)positions.Count);
				for (int i = 0; i < positions.Count; i++)
				{
					packet.Write(positions[i]);
					packet.Write(directions[i]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void IntegratedFirearmFire(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(154);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void LAPD2019LoadBattery(int clientID, int trackedID, int batteryTrackedID)
		{
			using Packet packet = new Packet(87);
			packet.Write(trackedID);
			packet.Write(batteryTrackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void LAPD2019ExtractBattery(int clientID, int trackedID)
		{
			using Packet packet = new Packet(88);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SosigWeaponShatter(int clientID, int trackedID)
		{
			using Packet packet = new Packet(84);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AutoMeaterFirearmFireShot(int clientID, int trackedID, Vector3 angles)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(60);
			packet.Write(trackedID);
			packet.Write(angles);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void PlayerDamage(int clientID, float damageMult, bool head, Damage damage)
		{
			using Packet packet = new Packet(10);
			packet.Write(damageMult);
			packet.Write(head);
			packet.Write(damage);
			SendTCPData(clientID, packet);
		}

		public static void UberShatterableShatter(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(93);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void UberShatterableShatter(int trackedID, Vector3 point, Vector3 dir, float intensity, byte[] data, int clientID = 0)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(93);
			packet.Write(trackedID);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(intensity);
			if (data == null || data.Length == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(data.Length);
				packet.Write(data);
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SosigPickUpItem(int trackedSosigID, int itemTrackedID, bool primaryHand, int fromclientID = 0)
		{
			using Packet packet = new Packet(11);
			packet.Write(trackedSosigID);
			packet.Write(itemTrackedID);
			packet.Write(primaryHand);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigPlaceItemIn(int trackedSosigID, int slotIndex, int itemTrackedID, int fromclientID = 0)
		{
			using Packet packet = new Packet(12);
			packet.Write(trackedSosigID);
			packet.Write(itemTrackedID);
			packet.Write(slotIndex);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigDropSlot(int trackedSosigID, int slotIndex, int fromclientID = 0)
		{
			using Packet packet = new Packet(13);
			packet.Write(trackedSosigID);
			packet.Write(slotIndex);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigHandDrop(int trackedSosigID, bool primaryHand, int fromclientID = 0)
		{
			using Packet packet = new Packet(14);
			packet.Write(trackedSosigID);
			packet.Write(primaryHand);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigConfigure(int trackedSosigID, SosigConfigTemplate config, int fromclientID = 0)
		{
			using Packet packet = new Packet(15);
			packet.Write(trackedSosigID);
			packet.Write(config);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigLinkRegisterWearable(int trackedSosigID, int linkIndex, string itemID, int fromclientID = 0)
		{
			using Packet packet = new Packet(16);
			packet.Write(trackedSosigID);
			packet.Write((byte)linkIndex);
			packet.Write(itemID);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigLinkDeRegisterWearable(int trackedSosigID, int linkIndex, string itemID, int fromclientID = 0)
		{
			using Packet packet = new Packet(17);
			packet.Write(trackedSosigID);
			packet.Write((byte)linkIndex);
			packet.Write(itemID);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigSetIFF(int trackedSosigID, int IFF, int fromclientID = 0)
		{
			using Packet packet = new Packet(18);
			packet.Write(trackedSosigID);
			packet.Write((byte)IFF);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigSetOriginalIFF(int trackedSosigID, int IFF, int fromclientID = 0)
		{
			using Packet packet = new Packet(19);
			packet.Write(trackedSosigID);
			packet.Write((byte)IFF);
			if (fromclientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(fromclientID, packet);
			}
		}

		public static void SosigLinkDamage(TrackedSosigData trackedSosig, int linkIndex, Damage d)
		{
			using Packet packet = new Packet(20);
			packet.Write(trackedSosig.trackedID);
			packet.Write((byte)linkIndex);
			packet.Write(d);
			SendTCPData(trackedSosig.controller, packet);
		}

		public static void AutoMeaterDamage(TrackedAutoMeaterData trackedAutoMeater, Damage d)
		{
			using Packet packet = new Packet(59);
			packet.Write(trackedAutoMeater.trackedID);
			packet.Write(d);
			SendTCPData(trackedAutoMeater.controller, packet);
		}

		public static void AutoMeaterHitZoneDamage(TrackedAutoMeaterData trackedAutoMeater, byte type, Damage d)
		{
			using Packet packet = new Packet(62);
			packet.Write(trackedAutoMeater.trackedID);
			packet.Write(type);
			packet.Write(d);
			SendTCPData(trackedAutoMeater.controller, packet);
		}

		public static void EncryptionDamage(TrackedEncryptionData trackedEncryption, Damage d)
		{
			using Packet packet = new Packet(72);
			packet.Write(trackedEncryption.trackedID);
			packet.Write(d);
			SendTCPData(trackedEncryption.controller, packet);
		}

		public static void EncryptionSubDamage(TrackedEncryptionData trackedEncryption, int index, Damage d)
		{
			using Packet packet = new Packet(79);
			packet.Write(trackedEncryption.trackedID);
			packet.Write(index);
			packet.Write(d);
			SendTCPData(trackedEncryption.controller, packet);
		}

		public static void SosigWeaponDamage(TrackedItemData trackedItem, Damage d)
		{
			using Packet packet = new Packet(85);
			packet.Write(trackedItem.trackedID);
			packet.Write(d);
			SendTCPData(trackedItem.controller, packet);
		}

		public static void RemoteMissileDamage(TrackedItemData trackedItem, Damage d)
		{
			using Packet packet = new Packet(108);
			packet.Write(trackedItem.trackedID);
			packet.Write(d);
			SendTCPData(trackedItem.controller, packet);
		}

		public static void RemoteMissileDamage(TrackedItemData trackedItem, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(108);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(trackedItem.controller, packet);
		}

		public static void StingerMissileDamage(TrackedItemData trackedItem, Damage d)
		{
			using Packet packet = new Packet(112);
			packet.Write(trackedItem.trackedID);
			packet.Write(d);
			SendTCPData(trackedItem.controller, packet);
		}

		public static void StingerMissileDamage(TrackedItemData trackedItem, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(112);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(trackedItem.controller, packet);
		}

		public static void SosigWearableDamage(TrackedSosigData trackedSosig, int linkIndex, int wearableIndex, Damage d)
		{
			using Packet packet = new Packet(22);
			packet.Write(trackedSosig.trackedID);
			packet.Write((byte)linkIndex);
			packet.Write((byte)wearableIndex);
			packet.Write(d);
			SendTCPData(trackedSosig.controller, packet);
		}

		public static void SosigDamageData(TrackedSosig trackedSosig)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(21);
			packet.Write(trackedSosig.data.trackedID);
			packet.Write(trackedSosig.physicalSosig.IsStunned);
			packet.Write(trackedSosig.physicalSosig.m_stunTimeLeft);
			packet.Write((byte)trackedSosig.physicalSosig.BodyState);
			packet.Write(trackedSosig.physicalSosig.m_isOnOffMeshLink);
			packet.Write(trackedSosig.physicalSosig.Agent.autoTraverseOffMeshLink);
			packet.Write(((Behaviour)trackedSosig.physicalSosig.Agent).enabled);
			List<CharacterJoint> joints = trackedSosig.physicalSosig.m_joints;
			packet.Write((byte)joints.Count);
			for (int i = 0; i < joints.Count; i++)
			{
				if ((Object)(object)joints[i] == (Object)null)
				{
					packet.Write(0);
					packet.Write(0);
					packet.Write(0);
					packet.Write(0);
					continue;
				}
				SoftJointLimit val = joints[i].lowTwistLimit;
				packet.Write(((SoftJointLimit)(ref val)).limit);
				val = joints[i].highTwistLimit;
				packet.Write(((SoftJointLimit)(ref val)).limit);
				val = joints[i].swing1Limit;
				packet.Write(((SoftJointLimit)(ref val)).limit);
				val = joints[i].swing2Limit;
				packet.Write(((SoftJointLimit)(ref val)).limit);
			}
			packet.Write(trackedSosig.physicalSosig.m_isCountingDownToStagger);
			packet.Write(trackedSosig.physicalSosig.m_staggerAmountToApply);
			packet.Write(trackedSosig.physicalSosig.m_recoveringFromBallisticState);
			packet.Write(trackedSosig.physicalSosig.m_recoveryFromBallisticLerp);
			packet.Write(trackedSosig.physicalSosig.m_tickDownToWrithe);
			packet.Write(trackedSosig.physicalSosig.m_recoveryFromBallisticTick);
			packet.Write((byte)trackedSosig.physicalSosig.GetDiedFromIFF());
			packet.Write((byte)trackedSosig.physicalSosig.GetDiedFromClass());
			packet.Write(trackedSosig.physicalSosig.IsBlinded);
			packet.Write(trackedSosig.physicalSosig.m_blindTime);
			packet.Write(trackedSosig.physicalSosig.IsFrozen);
			packet.Write(trackedSosig.physicalSosig.m_debuffTime_Freeze);
			packet.Write(trackedSosig.physicalSosig.GetDiedFromHeadShot());
			packet.Write(trackedSosig.physicalSosig.m_timeSinceLastDamage);
			packet.Write(trackedSosig.physicalSosig.IsConfused);
			packet.Write(trackedSosig.physicalSosig.m_confusedTime);
			packet.Write(trackedSosig.physicalSosig.m_storedShudder);
			SosigLinkDamageData(packet);
		}

		public static void SosigLinkDamageData(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(21);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(packet);
		}

		public static void EncryptionDamageData(TrackedEncryption trackedEncryption)
		{
			using Packet packet = new Packet(73);
			packet.Write(trackedEncryption.data.trackedID);
			packet.Write(trackedEncryption.physicalEncryption.m_numHitsLeft);
			EncryptionDamageData(packet);
		}

		public static void EncryptionDamageData(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(73);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(packet);
		}

		public static void AutoMeaterHitZoneDamageData(int trackedID, AutoMeaterHitZone hitZone)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(63);
			packet.Write(trackedID);
			packet.Write((byte)hitZone.Type);
			packet.Write(hitZone.ArmorThreshold);
			packet.Write(hitZone.LifeUntilFailure);
			packet.Write(hitZone.m_isDestroyed);
			AutoMeaterHitZoneDamageData(packet);
		}

		public static void AutoMeaterHitZoneDamageData(Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(63);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(packet);
		}

		public static void SosigLinkExplodes(int sosigTrackedID, int linkIndex, DamageClass damClass, int fromClientID = 0)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(23);
			packet.Write(sosigTrackedID);
			packet.Write((byte)linkIndex);
			packet.Write((byte)damClass);
			SosigLinkExplodes(packet, fromClientID);
		}

		public static void SosigLinkExplodes(Packet packet, int fromClientID)
		{
			byte[] bytes = BitConverter.GetBytes(23);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigDies(int sosigTrackedID, DamageClass damClass, SosigDeathType deathType, int fromClientID = 0)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(24);
			packet.Write(sosigTrackedID);
			packet.Write((byte)damClass);
			packet.Write((byte)deathType);
			SosigDies(packet, fromClientID);
		}

		public static void SosigDies(Packet packet, int fromClientID)
		{
			byte[] bytes = BitConverter.GetBytes(24);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void PlaySosigFootStepSound(int sosigTrackedID, FVRPooledAudioType audioType, Vector3 position, Vector2 vol, Vector2 pitch, float delay, int fromClientID = 0)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(27);
			packet.Write(sosigTrackedID);
			packet.Write((byte)audioType);
			packet.Write(position);
			packet.Write(vol);
			packet.Write(pitch);
			packet.Write(delay);
			PlaySosigFootStepSound(packet, fromClientID);
		}

		public static void PlaySosigFootStepSound(Packet packet, int fromClientID = 0)
		{
			byte[] bytes = BitConverter.GetBytes(27);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigRequestHitDecal(int sosigTrackedID, Vector3 point, Vector3 normal, Vector3 edgeNormal, float scale, int linkIndex, int fromClientID = 0)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(31);
			packet.Write(sosigTrackedID);
			packet.Write(point);
			packet.Write(normal);
			packet.Write(edgeNormal);
			packet.Write(scale);
			packet.Write(linkIndex);
			SosigRequestHitDecal(packet, fromClientID);
		}

		public static void SosigRequestHitDecal(Packet packet, int fromClientID = 0)
		{
			byte[] bytes = BitConverter.GetBytes(31);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigClear(int sosigTrackedID, int fromClientID = 0)
		{
			using Packet packet = new Packet(25);
			packet.Write(sosigTrackedID);
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigSetBodyState(int sosigTrackedID, SosigBodyState s, int fromClientID = 0)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(26);
			packet.Write(sosigTrackedID);
			packet.Write((byte)s);
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigSpeakState(int sosigTrackedID, SosigOrder currentOrder, int fromClientID = 0)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(28);
			packet.Write(sosigTrackedID);
			packet.Write((byte)currentOrder);
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigSetCurrentOrder(TrackedSosigData trackedSosig, SosigOrder currentOrder, int fromClientID = 0)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected I4, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(29);
			packet.Write(trackedSosig.trackedID);
			packet.Write((byte)currentOrder);
			SosigOrder currentOrder2 = trackedSosig.currentOrder;
			SosigOrder val = currentOrder2;
			switch (val - 1)
			{
			case 0:
				packet.Write(trackedSosig.guardPoint);
				packet.Write(trackedSosig.guardDir);
				packet.Write(trackedSosig.hardGuard);
				break;
			case 1:
				packet.Write(trackedSosig.skirmishPoint);
				packet.Write(trackedSosig.pathToPoint);
				packet.Write(trackedSosig.assaultPoint);
				packet.Write(trackedSosig.faceTowards);
				break;
			case 2:
				packet.Write(trackedSosig.guardPoint);
				packet.Write(trackedSosig.hardGuard);
				packet.Write(trackedSosig.faceTowards);
				break;
			case 3:
			case 5:
				packet.Write(trackedSosig.wanderPoint);
				break;
			case 6:
				packet.Write(trackedSosig.assaultPoint);
				packet.Write((byte)trackedSosig.assaultSpeed);
				packet.Write(trackedSosig.faceTowards);
				break;
			case 8:
				packet.Write(trackedSosig.idleToPoint);
				packet.Write(trackedSosig.idleDominantDir);
				break;
			case 9:
				packet.Write(trackedSosig.pathToPoint);
				packet.Write(trackedSosig.pathToLookDir);
				break;
			}
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigVaporize(int sosigTrackedID, int iff, int fromClientID = 0)
		{
			using Packet packet = new Packet(30);
			packet.Write(sosigTrackedID);
			packet.Write((byte)iff);
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigLinkBreak(int sosigTrackedID, int linkIndex, bool isStart, byte damClass, int fromClientID = 0)
		{
			using Packet packet = new Packet(32);
			packet.Write(sosigTrackedID);
			packet.Write((byte)linkIndex);
			packet.Write(isStart);
			packet.Write(damClass);
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void SosigLinkSever(int sosigTrackedID, int linkIndex, byte damClass, bool isPullApart, int fromClientID = 0)
		{
			using Packet packet = new Packet(33);
			packet.Write(sosigTrackedID);
			packet.Write((byte)linkIndex);
			packet.Write(damClass);
			packet.Write(isPullApart);
			SendTCPDataToAll(fromClientID, packet);
		}

		public static void RequestUpToDateObjects(int clientID, bool instantiateOnReceive, int forClient)
		{
			using Packet packet = new Packet(34);
			packet.Write(instantiateOnReceive);
			packet.Write(forClient);
			SendTCPData(clientID, packet);
		}

		public static void PlayerInstance(int clientID, int instance)
		{
			using Packet packet = new Packet(35);
			packet.Write(clientID);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AddTNHInstance(TNHInstance instance)
		{
			using Packet packet = new Packet(36);
			packet.Write(instance);
			SendTCPDataToAll(packet);
		}

		public static void AddInstance(int instance)
		{
			using Packet packet = new Packet(51);
			packet.Write(instance);
			SendTCPDataToAll(packet);
		}

		public static void AddTNHCurrentlyPlaying(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(37);
			packet.Write(clientID);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RemoveTNHCurrentlyPlaying(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(38);
			packet.Write(clientID);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHProgression(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(39);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHEquipment(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(40);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHHealthMode(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(41);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHTargetMode(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(42);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHAIDifficulty(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(43);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHRadarMode(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(44);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHItemSpawnerMode(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(45);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHBackpackMode(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(46);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHHealthMult(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(47);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHSosigGunReload(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(48);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHSeed(int i, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(49);
			packet.Write(i);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHLevelID(string levelID, int instance, int clientID = 0)
		{
			using Packet packet = new Packet(50);
			packet.Write(levelID);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SetTNHController(int instance, int newController, int clientID = 0)
		{
			using Packet packet = new Packet(52);
			Mod.LogInfo("Server sending TNH controller " + newController + " for instance " + instance);
			packet.Write(instance);
			packet.Write(newController);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHPlayerDied(int instance, int ID, int clientID = 0)
		{
			using Packet packet = new Packet(54);
			packet.Write(instance);
			packet.Write(ID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHAddTokens(int instance, int ID, int clientID = 0)
		{
			using Packet packet = new Packet(55);
			packet.Write(instance);
			packet.Write(ID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AutoMeaterSetState(int trackedID, byte state, int clientID = 0)
		{
			using Packet packet = new Packet(57);
			packet.Write(trackedID);
			packet.Write(state);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AutoMeaterSetBladesActive(int trackedID, bool active, int clientID = 0)
		{
			using Packet packet = new Packet(58);
			packet.Write(trackedID);
			packet.Write(active);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AutoMeaterFirearmFireAtWill(int trackedID, int firearmIndex, bool fireAtWill, float dist, int clientID = 0)
		{
			using Packet packet = new Packet(61);
			packet.Write(trackedID);
			packet.Write(firearmIndex);
			packet.Write(fireAtWill);
			packet.Write(dist);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHSosigKill(int instance, int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(64);
			packet.Write(instance);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldPointSystemNode(int instance, int levelIndex, int holdPointIndex, int clientID = 0)
		{
			using Packet packet = new Packet(65);
			packet.Write(instance);
			packet.Write(levelIndex);
			packet.Write(holdPointIndex);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldBeginChallenge(int instance, bool controller, bool toAll, int clientID)
		{
			using Packet packet = new Packet(66);
			Mod.LogInfo("TNHHoldBeginChallenge server send", debug: false);
			packet.Write(instance);
			packet.Write(controller);
			if (toAll)
			{
				if (clientID == 0)
				{
					SendTCPDataToAll(packet);
				}
				else
				{
					SendTCPDataToAll(clientID, packet);
				}
			}
			else
			{
				Mod.LogInfo("\tSpecifically to controller: " + clientID, debug: false);
				SendTCPData(clientID, packet);
			}
		}

		public static void ShatterableCrateSetHoldingHealth(int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(5);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ShatterableCrateSetHoldingToken(int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(125);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ShatterableCrateSetUsesLoot(int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(208);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ShatterableCrateDamage(int trackedID, Damage d)
		{
			using Packet packet = new Packet(80);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPDataToAll(packet);
		}

		public static void ShatterableCrateDestroy(int trackedID, Damage d, int clientID = 0)
		{
			using Packet packet = new Packet(81);
			packet.Write(trackedID);
			packet.Write(d);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHSetLevel(int instance, int level, int clientID = 0)
		{
			using Packet packet = new Packet(56);
			packet.Write(instance);
			packet.Write(level);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHSetPhaseTake(int instance, int holdIndex, List<int> activeSupplyPointIndices, bool init, int clientID = 0)
		{
			using Packet packet = new Packet(67);
			packet.Write(instance);
			packet.Write(holdIndex);
			packet.Write(activeSupplyPointIndices.Count);
			foreach (int activeSupplyPointIndex in activeSupplyPointIndices)
			{
				packet.Write(activeSupplyPointIndex);
			}
			packet.Write(init);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHSetPhaseHold(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(124);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldCompletePhase(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(68);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldPointFailOut(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(69);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldPointBeginPhase(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(97);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldPointCompleteHold(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(98);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHSetPhaseComplete(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(70);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHSetPhase(int instance, short p, int clientID = 0)
		{
			using Packet packet = new Packet(71);
			packet.Write(instance);
			packet.Write(p);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionRespawnSubTarg(int instance, int index, int clientID = 0)
		{
			using Packet packet = new Packet(74);
			packet.Write(instance);
			packet.Write(index);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionRespawnSubTargGeo(int instance, int index, int clientID = 0)
		{
			using Packet packet = new Packet(176);
			packet.Write(instance);
			packet.Write(index);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionSpawnGrowth(int instance, int index, Vector3 point, int clientID = 0)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(75);
			packet.Write(instance);
			packet.Write(index);
			packet.Write(point);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionInit(int clientID, int trackedID, List<int> indices, Vector3 initialPos, int numHitsLeft)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(76);
			packet.Write(trackedID);
			if (indices == null || indices.Count == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(indices.Count);
				for (int i = 0; i < indices.Count; i++)
				{
					packet.Write(indices[i]);
				}
			}
			packet.Write(initialPos);
			packet.Write(numHitsLeft);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionResetGrowth(int instance, int index, Vector3 point, int clientID = 0)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(77);
			packet.Write(instance);
			packet.Write(index);
			packet.Write(point);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionDisableSubtarg(int instance, int index, int clientID = 0)
		{
			using Packet packet = new Packet(78);
			packet.Write(instance);
			packet.Write(index);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void InitTNHInstances(int toClientID)
		{
			if (GameManager.TNHInstances == null || GameManager.TNHInstances.Count == 0)
			{
				return;
			}
			using Packet packet = new Packet(82);
			packet.Write(GameManager.TNHInstances.Count);
			foreach (KeyValuePair<int, TNHInstance> tNHInstance in GameManager.TNHInstances)
			{
				packet.Write(tNHInstance.Value, full: true);
			}
			SendTCPData(toClientID, packet);
		}

		public static void TNHHoldPointBeginAnalyzing(int clientID, int instance, List<Vector3> data, float tickDownToID)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(94);
			packet.Write(instance);
			packet.Write(tickDownToID);
			if (data == null || data.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)data.Count);
				foreach (Vector3 datum in data)
				{
					packet.Write(datum);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldPointBeginAnalyzing(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(94);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldPointRaiseBarriers(int clientID, int instance, List<int> barrierIndices, List<int> barrierPrefabIndices)
		{
			using Packet packet = new Packet(95);
			packet.Write(instance);
			if (barrierIndices == null || barrierIndices.Count == 0)
			{
				packet.Write(0);
			}
			else
			{
				packet.Write(barrierIndices.Count);
				for (int i = 0; i < barrierIndices.Count; i++)
				{
					packet.Write(barrierIndices[i]);
				}
				for (int j = 0; j < barrierIndices.Count; j++)
				{
					packet.Write(barrierPrefabIndices[j]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldPointRaiseBarriers(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(95);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHoldIdentifyEncryption(int clientID, int instance)
		{
			using Packet packet = new Packet(96);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SosigPriorityIFFChart(int clientID, int trackedID, int chart)
		{
			using Packet packet = new Packet(99);
			packet.Write(trackedID);
			packet.Write(chart);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RemoteMissileDetonate(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(107);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RemoteMissileDetonate(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(107);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void StingerMissileExplode(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(113);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void StingerMissileExplode(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(113);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void PinnedGrenadeExplode(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(114);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void PinnedGrenadeExplode(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(114);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void PinnedGrenadePullPin(int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(139);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FVRGrenadeExplode(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(115);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FVRGrenadeExplode(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(115);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void BangSnapSplode(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(119);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void BangSnapSplode(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(119);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void C4Detonate(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(120);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void C4Detonate(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(120);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ClaymoreMineDetonate(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(121);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ClaymoreMineDetonate(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(121);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SLAMDetonate(int clientID, int trackedID, Vector3 pos)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(122);
			packet.Write(trackedID);
			packet.Write(pos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SLAMDetonate(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(122);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ClientDisconnect(int clientID)
		{
			using Packet packet = new Packet(116);
			packet.Write(clientID);
			SendTCPDataToAll(clientID, packet);
		}

		public static void ServerClosed()
		{
			using Packet packet = new Packet(117);
			SendTCPDataToAll(packet);
		}

		public static void SpectatorHost(int clientID, bool spectatorHost)
		{
			using Packet packet = new Packet(53);
			packet.Write(clientID);
			packet.Write(spectatorHost);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ResetTNH(int instance)
		{
			using Packet packet = new Packet(126);
			packet.Write(instance);
			SendTCPDataToAll(packet);
		}

		public static void ReviveTNHPlayer(int ID, int instance, int clientID)
		{
			using Packet packet = new Packet(127);
			packet.Write(ID);
			packet.Write(instance);
			SendTCPDataToAll(clientID, packet);
		}

		public static void PlayerColor(int ID, int index, int clientID = 0)
		{
			using Packet packet = new Packet(128);
			packet.Write(ID);
			packet.Write(index);
			SendTCPDataToAll(clientID, packet);
		}

		public static void ColorByIFF(bool colorByIFF)
		{
			using Packet packet = new Packet(129);
			packet.Write(colorByIFF);
			SendTCPDataToAll(packet);
		}

		public static void NameplateMode(int nameplateMode)
		{
			using Packet packet = new Packet(130);
			packet.Write(nameplateMode);
			SendTCPDataToAll(packet);
		}

		public static void RadarMode(int radarMode)
		{
			using Packet packet = new Packet(131);
			packet.Write(radarMode);
			SendTCPDataToAll(packet);
		}

		public static void RadarColor(bool radarColor)
		{
			using Packet packet = new Packet(132);
			packet.Write(radarColor);
			SendTCPDataToAll(packet);
		}

		public static void TNHInitializer(int instance, int initializer, bool only = false)
		{
			using Packet packet = new Packet(133);
			packet.Write(instance);
			packet.Write(initializer);
			if (only)
			{
				SendTCPData(initializer, packet);
			}
			else
			{
				SendTCPDataToAll(initializer, packet);
			}
		}

		public static void MaxHealth(string scene, int instance, int index, float original, int clientID = 0)
		{
			using Packet packet = new Packet(134);
			packet.Write(scene);
			packet.Write(instance);
			packet.Write(index);
			packet.Write(original);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FuseIgnite(int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(135);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FuseBoom(int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(136);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void MolotovShatter(int trackedID, bool ignited, int clientID = 0)
		{
			using Packet packet = new Packet(137);
			packet.Write(trackedID);
			packet.Write(ignited);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void MolotovDamage(TrackedItemData itemData, Damage damage)
		{
			using Packet packet = new Packet(138);
			packet.Write(itemData.trackedID);
			packet.Write(damage);
			SendTCPData(itemData.controller, packet);
		}

		public static void MagazineAddRound(int trackedID, FireArmRoundClass roundClass, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(140);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ClipAddRound(int trackedID, FireArmRoundClass roundClass, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(141);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SpeedloaderChamberLoad(int trackedID, FireArmRoundClass roundClass, int chamberIndex, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(142);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			packet.Write((byte)chamberIndex);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RemoteGunChamber(int trackedID, FireArmRoundClass roundClass, FireArmRoundType roundType, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(143);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			packet.Write((short)roundType);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ChamberRound(int trackedID, FireArmRoundClass roundClass, int chamberIndex, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(144);
			packet.Write(trackedID);
			packet.Write((short)roundClass);
			packet.Write((byte)chamberIndex);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void MagazineLoad(int trackedID, int FATrackedID, int slot = -1, int clientID = 0)
		{
			using Packet packet = new Packet(145);
			packet.Write(trackedID);
			packet.Write(FATrackedID);
			packet.Write((short)slot);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void MagazineLoadAttachable(int trackedID, int FATrackedID, int clientID = 0)
		{
			using Packet packet = new Packet(146);
			packet.Write(trackedID);
			packet.Write(FATrackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ClipLoad(int trackedID, int FATrackedID, int clientID = 0)
		{
			using Packet packet = new Packet(147);
			packet.Write(trackedID);
			packet.Write(FATrackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RevolverCylinderLoad(int trackedID, Speedloader speedLoader, List<short> classes = null, int clientID = 0)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(148);
			packet.Write(trackedID);
			if ((Object)(object)speedLoader == (Object)null)
			{
				packet.Write((byte)classes.Count);
				for (int i = 0; i < classes.Count; i++)
				{
					packet.Write(classes[i]);
				}
			}
			else
			{
				packet.Write((byte)speedLoader.Chambers.Count);
				for (int j = 0; j < speedLoader.Chambers.Count; j++)
				{
					if (speedLoader.Chambers[j].IsLoaded && !speedLoader.Chambers[j].IsSpent)
					{
						packet.Write((short)speedLoader.Chambers[j].LoadedClass);
					}
					else
					{
						packet.Write((short)(-1));
					}
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RevolvingShotgunLoad(int trackedID, Speedloader speedLoader, List<short> classes = null, int clientID = 0)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(149);
			packet.Write(trackedID);
			if ((Object)(object)speedLoader == (Object)null)
			{
				packet.Write((byte)classes.Count);
				for (int i = 0; i < classes.Count; i++)
				{
					packet.Write(classes[i]);
				}
			}
			else
			{
				packet.Write((byte)speedLoader.Chambers.Count);
				for (int j = 0; j < speedLoader.Chambers.Count; j++)
				{
					if (speedLoader.Chambers[j].IsLoaded && !speedLoader.Chambers[j].IsSpent)
					{
						packet.Write((short)speedLoader.Chambers[j].LoadedClass);
					}
					else
					{
						packet.Write((short)(-1));
					}
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GrappleGunLoad(int trackedID, Speedloader speedLoader, List<short> classes = null, int clientID = 0)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(150);
			packet.Write(trackedID);
			if ((Object)(object)speedLoader == (Object)null)
			{
				packet.Write((byte)classes.Count);
				for (int i = 0; i < classes.Count; i++)
				{
					packet.Write(classes[i]);
				}
			}
			else
			{
				packet.Write((byte)speedLoader.Chambers.Count);
				for (int j = 0; j < speedLoader.Chambers.Count; j++)
				{
					if (speedLoader.Chambers[j].IsLoaded && !speedLoader.Chambers[j].IsSpent)
					{
						packet.Write((short)speedLoader.Chambers[j].LoadedClass);
					}
					else
					{
						packet.Write((short)(-1));
					}
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void CarlGustafLatchSate(int trackedID, CGLatchType type, CGLatchState state, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(151);
			packet.Write(trackedID);
			packet.Write((byte)type);
			packet.Write((byte)state);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void CarlGustafShellSlideSate(int trackedID, ChamberSlideState state, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(152);
			packet.Write(trackedID);
			packet.Write((byte)state);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void TNHHostStartHold(int instance, int clientID = 0)
		{
			using Packet packet = new Packet(153);
			packet.Write(instance);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GrappleAttached(int trackedID, byte[] data, int clientID = 0)
		{
			using Packet packet = new Packet(155);
			packet.Write(trackedID);
			packet.Write((short)data.Length);
			packet.Write(data);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RegisterCustomPacketType(string handlerID, int index)
		{
			using Packet packet = new Packet(160);
			packet.Write(handlerID);
			packet.Write(index);
			SendTCPDataToAll(packet);
		}

		public static void BreakableGlassDamage(TrackedBreakableGlassData trackedBreakableGlassData, Damage d)
		{
			using Packet packet = new Packet(161);
			packet.Write(trackedBreakableGlassData.trackedID);
			packet.Write(d);
			SendTCPData(trackedBreakableGlassData.controller, packet);
		}

		public static void BreakableGlassDamage(Packet packet, int controller)
		{
			byte[] bytes = BitConverter.GetBytes(161);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(controller, packet);
		}

		public static void WindowShatterSound(int trackedID, int mode, int clientID = 0)
		{
			using Packet packet = new Packet(162);
			packet.Write(trackedID);
			packet.Write((byte)mode);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SpectatorHostAssignment(int host, int clientID, bool reassignment = false)
		{
			using Packet packet = new Packet(163);
			packet.Write(host);
			packet.Write(clientID);
			packet.Write(reassignment);
			SendTCPDataToClients(packet, new List<int> { host, clientID }, 0);
		}

		public static void GiveUpSpectatorHost(int clientID)
		{
			using Packet packet = new Packet(164);
			SendTCPData(clientID, packet);
		}

		public static void SpectatorHostOrderTNHHost(int host, bool spectateOnDeath)
		{
			using Packet packet = new Packet(165);
			packet.Write(spectateOnDeath);
			SendTCPData(host, packet);
		}

		public static void TNHSpectatorHostReady(int controller, int instance)
		{
			using Packet packet = new Packet(166);
			packet.Write(instance);
			SendTCPData(controller, packet);
		}

		public static void SpectatorHostStartTNH(int host)
		{
			using Packet packet = new Packet(167);
			SendTCPData(host, packet);
		}

		public static void UnassignSpectatorHost(int host)
		{
			using Packet packet = new Packet(168);
			SendTCPData(host, packet);
		}

		public static void ReactiveSteelTargetDamage(int trackedID, int targetIndex, float damKinetic, float damBlunt, Vector3 point, Vector3 dir, bool usesHoles, Vector3 pos, Quaternion rot, float scale)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(169);
			packet.Write(trackedID);
			packet.Write(targetIndex);
			packet.Write(damKinetic);
			packet.Write(damBlunt);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(usesHoles);
			if (usesHoles)
			{
				packet.Write(pos);
				packet.Write(rot);
				packet.Write(scale);
			}
			SendTCPDataToAll(packet);
		}

		public static void ReactiveSteelTargetDamage(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(169);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPDataToAll(clientID, packet);
		}

		public static void IDConfirm(KeyValuePair<int, List<int>> entry)
		{
			using Packet packet = new Packet(171);
			packet.Write(entry.Key);
			SendTCPDataToClients(packet, entry.Value);
		}

		public static void PlayerPrefabID(int clientID, string ID, int secondClientID)
		{
			using Packet packet = new Packet(172);
			packet.Write(clientID);
			packet.Write(ID);
			if (secondClientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(secondClientID, packet);
			}
		}

		public static void ObjectScene(TrackedObjectData trackedObjectData, int clientID = 0)
		{
			using Packet packet = new Packet(173);
			trackedObjectData.WriteToPacket(packet, incrementOrder: false, full: true);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ObjectInstance(TrackedObjectData trackedObjectData, int clientID = 0)
		{
			using Packet packet = new Packet(174);
			trackedObjectData.WriteToPacket(packet, incrementOrder: false, full: true);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void UpdateEncryptionDisplay(int trackedID, int numHitsLeft, int clientID = 0)
		{
			using Packet packet = new Packet(175);
			packet.Write(trackedID);
			packet.Write(numHitsLeft);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void RoundDamage(int trackedID, Damage damage, int clientID)
		{
			using Packet packet = new Packet(177);
			packet.Write(trackedID);
			packet.Write(damage);
			SendTCPData(clientID, packet);
		}

		public static void RoundSplode(int trackedID, float velMultiplier, bool isRandomDir, int clientID = 0)
		{
			using Packet packet = new Packet(178);
			packet.Write(trackedID);
			packet.Write(velMultiplier);
			packet.Write(isRandomDir);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void ConnectionComplete(int clientID)
		{
			using Packet packet = new Packet(179);
			SendTCPData(clientID, packet);
		}

		public static void SightFlipperState(int trackedID, int index, bool large, int clientID = 0)
		{
			using Packet packet = new Packet(180);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write(large);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SightRaiserState(int trackedID, int index, SightHeights height, int clientID = 0)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(181);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write((byte)height);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GatlingGunFire(int trackedID, Vector3 pos, Quaternion rot, Vector3 dir, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(182);
			packet.Write(trackedID);
			packet.Write(pos);
			packet.Write(rot);
			packet.Write(dir);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GasCuboidGout(int trackedID, Vector3 pos, Vector3 norm, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(184);
			packet.Write(trackedID);
			packet.Write(pos);
			packet.Write(norm);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GasCuboidDamage(int trackedID, Damage d, int clientID)
		{
			using Packet packet = new Packet(185);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(clientID, packet);
		}

		public static void GasCuboidDamage(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(185);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(clientID, packet);
		}

		public static void GasCuboidHandleDamage(int trackedID, Damage d, int clientID)
		{
			using Packet packet = new Packet(186);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(clientID, packet);
		}

		public static void GasCuboidHandleDamage(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(186);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(clientID, packet);
		}

		public static void GasCuboidDamageHandle(int trackedID, int clientID = 0)
		{
			using Packet packet = new Packet(187);
			packet.Write(trackedID);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GasCuboidExplode(int trackedID, Vector3 point, Vector3 dir, bool big, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(188);
			packet.Write(trackedID);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(big);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void GasCuboidShatter(int trackedID, Vector3 point, Vector3 dir, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(189);
			packet.Write(trackedID);
			packet.Write(point);
			packet.Write(dir);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void FloaterDamage(int trackedID, Damage d, int clientID)
		{
			using Packet packet = new Packet(190);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(clientID, packet);
		}

		public static void FloaterDamage(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(190);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(clientID, packet);
		}

		public static void FloaterCoreDamage(int trackedID, Damage d, int clientID)
		{
			using Packet packet = new Packet(191);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(clientID, packet);
		}

		public static void FloaterCoreDamage(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(191);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(clientID, packet);
		}

		public static void FloaterBeginExploding(int trackedID, bool fromController, int clientID = 0)
		{
			using Packet packet = new Packet(192);
			packet.Write(trackedID);
			packet.Write(fromController);
			if (fromController)
			{
				SendTCPDataToAll(clientID, packet);
			}
			else
			{
				SendTCPData(clientID, packet);
			}
		}

		public static void FloaterBeginDefusing(int trackedID, bool fromController, int clientID = 0)
		{
			using Packet packet = new Packet(197);
			packet.Write(trackedID);
			packet.Write(fromController);
			if (fromController)
			{
				SendTCPDataToAll(clientID, packet);
			}
			else
			{
				SendTCPData(clientID, packet);
			}
		}

		public static void FloaterExplode(int trackedID, bool defusing, int clientID = 0)
		{
			using Packet packet = new Packet(193);
			packet.Write(trackedID);
			packet.Write(defusing);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void IrisShatter(int trackedID, byte index, Vector3 point, Vector3 dir, float intensity, int clientID = 0)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(194);
			packet.Write(trackedID);
			packet.Write(index);
			packet.Write(point);
			packet.Write(dir);
			packet.Write(intensity);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void IrisShatter(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(194);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void IrisSetState(int trackedID, IrisState state, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(195);
			packet.Write(trackedID);
			packet.Write((byte)state);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void BrutBlockSystemStart(int trackedID, bool next, int clientID = 0)
		{
			using Packet packet = new Packet(196);
			packet.Write(trackedID);
			packet.Write(next);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void NodeInit(int trackedID, List<Vector3> points, List<Vector3> ups, int clientID = 0)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(199);
			packet.Write(trackedID);
			if (points == null || points.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)points.Count);
				for (int i = 0; i < points.Count; i++)
				{
					packet.Write(points[i]);
				}
			}
			if (ups == null || ups.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)ups.Count);
				for (int j = 0; j < ups.Count; j++)
				{
					packet.Write(ups[j]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void NodeFire(int trackedID, float velMult, Vector3 firingDir, int clientID = 0)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(200);
			packet.Write(trackedID);
			packet.Write(velMult);
			packet.Write(firingDir);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void HazeDamage(int trackedID, Damage d, int clientID)
		{
			using Packet packet = new Packet(201);
			packet.Write(trackedID);
			packet.Write(d);
			SendTCPData(clientID, packet);
		}

		public static void HazeDamage(Packet packet, int clientID)
		{
			byte[] bytes = BitConverter.GetBytes(201);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			SendTCPData(clientID, packet);
		}

		public static void EncryptionFireGun(int trackedID, float[] vels, Vector3[] dirs, int clientID = 0)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(202);
			packet.Write(trackedID);
			if (vels == null || vels.Length == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)vels.Length);
				for (int i = 0; i < vels.Length; i++)
				{
					packet.Write(vels[i]);
				}
			}
			if (dirs == null || dirs.Length == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)dirs.Length);
				for (int j = 0; j < dirs.Length; j++)
				{
					packet.Write(dirs[j]);
				}
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionFireGun(int clientID, Packet packet)
		{
			byte[] bytes = BitConverter.GetBytes(202);
			for (int i = 0; i < 4; i++)
			{
				packet.buffer[i] = bytes[i];
			}
			packet.readPos = 0;
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionNextPos(int trackedID, Vector3 previewPos, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(203);
			packet.Write(trackedID);
			packet.Write(previewPos);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void EncryptionShieldRot(int trackedID, Quaternion shieldRot, int clientID = 0)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(204);
			packet.Write(trackedID);
			packet.Write(shieldRot);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void SentinelInit(int trackedID, List<Vector3> points, int currentPointIndex, int targetPointIndex, bool movingUp, int clientID = 0)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(205);
			packet.Write(trackedID);
			if (points == null || points.Count == 0)
			{
				packet.Write((byte)0);
			}
			else
			{
				packet.Write((byte)points.Count);
				for (int i = 0; i < points.Count; i++)
				{
					packet.Write(points[i]);
				}
			}
			packet.Write((byte)currentPointIndex);
			packet.Write((byte)targetPointIndex);
			packet.Write(movingUp);
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}

		public static void AlertSosigs(List<int> players, string scene, int instance, Vector3 position, int clientID)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			using Packet packet = new Packet(206);
			packet.Write(scene);
			packet.Write(instance);
			packet.Write(position);
			SendTCPData(players, packet, clientID);
		}

		public static void SetModulWeaponPart(int trackedID, string groupID, string selectedPart, string skinID, int clientID = 0)
		{
			using Packet packet = new Packet(207);
			packet.Write(trackedID);
			packet.Write(groupID);
			packet.Write(selectedPart);
			if (skinID == null)
			{
				packet.Write(_value: false);
			}
			else
			{
				packet.Write(_value: true);
				packet.Write(skinID);
			}
			if (clientID == 0)
			{
				SendTCPDataToAll(packet);
			}
			else
			{
				SendTCPDataToAll(clientID, packet);
			}
		}
	}
	public class ThreadManager : MonoBehaviour
	{
		public static bool host;

		private static readonly List<Action> executeOnMainThread = new List<Action>();

		private static readonly List<Action> executeCopiedOnMainThread = new List<Action>();

		private static bool actionToExecuteOnMainThread = false;

		public static int updateTimeLimit = 10;

		public static int updateState = -1;

		public static int updateStateIndex = 0;

		public static int updateSubStateIndex = -1;

		public static readonly DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

		public static readonly float pingTime = 1f;

		public static float pingTimer = pingTime;

		private void Update()
		{
			UpdateMain();
		}

		private void FixedUpdate()
		{
			UpdateMainFixed();
		}

		public static void ExecuteOnMainThread(Action _action)
		{
			if (_action == null)
			{
				Mod.LogInfo("No action to execute on main thread!", debug: false);
				return;
			}
			lock (executeOnMainThread)
			{
				executeOnMainThread.Add(_action);
				actionToExecuteOnMainThread = true;
			}
		}

		public static void UpdateMain()
		{
			if (Input.GetKey((KeyCode)281))
			{
				Mod.LogInfo("DEBUG UPDATE MAIN");
			}
			if (actionToExecuteOnMainThread)
			{
				executeCopiedOnMainThread.Clear();
				lock (executeOnMainThread)
				{
					executeCopiedOnMainThread.AddRange(executeOnMainThread);
					executeOnMainThread.Clear();
					actionToExecuteOnMainThread = false;
				}
				if (Input.GetKey((KeyCode)281))
				{
					Mod.LogInfo("Actions to execute: " + executeCopiedOnMainThread.Count);
				}
				for (int i = 0; i < executeCopiedOnMainThread.Count; i++)
				{
					executeCopiedOnMainThread[i]();
					updateStateIndex = i;
				}
			}
			if (host)
			{
				return;
			}
			pingTimer -= Time.deltaTime;
			if (!(pingTimer <= 0f))
			{
				return;
			}
			pingTimer = pingTime;
			if (Client.singleton.gotWelcome)
			{
				ClientSend.Ping(Convert.ToInt64((DateTime.Now.ToUniversalTime() - epoch).TotalMilliseconds));
				return;
			}
			Client.singleton.pingAttemptCounter++;
			if (Client.singleton.pingAttemptCounter >= 10)
			{
				Mod.LogWarning("Have not received server welcome for " + Client.singleton.pingAttemptCounter + " seconds, timing out at 30");
			}
			if (Client.singleton.pingAttemptCounter >= 30)
			{
				Client.singleton.Disconnect(sendToServer: false, 4);
			}
		}

		public static void UpdateMainFixed()
		{
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (host)
			{
				if (GameManager.playersPresent.Count > 0)
				{
					ServerSend.TrackedObjects();
					if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
					{
						ServerSend.PlayerState(0, ((Component)GM.CurrentPlayerBody).transform.position, ((Component)GM.CurrentPlayerBody).transform.rotation, GM.CurrentPlayerBody.headPositionFiltered, GM.CurrentPlayerBody.headRotationFiltered, GM.CurrentPlayerBody.headPositionFiltered + GameManager.torsoOffset, GM.CurrentPlayerBody.Torso.rotation, GM.CurrentPlayerBody.LeftHand.position, GM.CurrentPlayerBody.LeftHand.rotation, GM.CurrentPlayerBody.RightHand.position, GM.CurrentPlayerBody.RightHand.rotation, GM.CurrentPlayerBody.Health, GM.CurrentPlayerBody.GetMaxHealthPlayerRaw(), GameManager.scene, GameManager.instance);
					}
				}
				if (Server.IDsToConfirm.Count <= 0)
				{
					return;
				}
				Mod.LogInfo("There are IDs to confirm");
				int num = 0;
				List<int> list = new List<int>();
				foreach (KeyValuePair<int, List<int>> item in Server.IDsToConfirm)
				{
					Mod.LogInfo("\tRequesting confirm for " + item.Key);
					ServerSend.IDConfirm(item);
					list.Add(item.Key);
					if (++num >= Server.IDConfirmLimit)
					{
						break;
					}
				}
				for (int i = 0; i < list.Count; i++)
				{
					Server.IDsToConfirm.Remove(list[i]);
				}
			}
			else if (GameManager.playersPresent.Count > 0)
			{
				ClientSend.TrackedObjects();
				if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
				{
					ClientSend.PlayerState(((Component)GM.CurrentPlayerBody).transform.position, ((Component)GM.CurrentPlayerBody).transform.rotation, GM.CurrentPlayerBody.headPositionFiltered, GM.CurrentPlayerBody.headRotationFiltered, GM.CurrentPlayerBody.headPositionFiltered + GameManager.torsoOffset, GM.CurrentPlayerBody.Torso.rotation, GM.CurrentPlayerBody.LeftHand.position, GM.CurrentPlayerBody.LeftHand.rotation, GM.CurrentPlayerBody.RightHand.position, GM.CurrentPlayerBody.RightHand.rotation, GM.CurrentPlayerBody.Health, GM.CurrentPlayerBody.GetMaxHealthPlayerRaw());
				}
			}
		}

		private void OnApplicationQuit()
		{
			if (host)
			{
				Server.Close();
			}
		}
	}
	public class TNHInstance
	{
		public int instance = -1;

		private int _controller = -1;

		public TNH_Manager manager;

		public List<int> playerIDs;

		public List<int> currentlyPlaying;

		public List<int> played;

		public List<int> dead;

		public int initializer = -1;

		public bool initializationRequested;

		public int tokenCount;

		public bool holdOngoing;

		public HoldState holdState;

		public List<Vector3> warpInData;

		public float tickDownToID;

		public float tickDownToFailure;

		public bool spawnedStartEquip;

		public int curHoldIndex;

		public int level;

		public TNH_Phase phase = (TNH_Phase)(-1);

		public List<int> activeSupplyPointIndices;

		public List<int> raisedBarriers;

		public List<int> raisedBarrierPrefabIndices;

		public int nextSupplyPanelType = 1;

		public bool letPeopleJoin;

		public int progressionTypeSetting;

		public int healthModeSetting;

		public int equipmentModeSetting;

		public int targetModeSetting;

		public int AIDifficultyModifier = 1;

		public int radarModeModifier = 1;

		public int itemSpawnerMode;

		public int backpackMode;

		public int healthMult;

		public int sosiggunShakeReloading;

		public int TNHSeed;

		public string levelID;

		public int controller
		{
			get
			{
				return _controller;
			}
			set
			{
				Mod.LogInfo("TNH instance at " + instance + " controller being set to " + value + ":\n" + Environment.StackTrace, debug: false);
				_controller = value;
			}
		}

		public TNHInstance(int instance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			this.instance = instance;
			playerIDs = new List<int>();
			currentlyPlaying = new List<int>();
			played = new List<int>();
			dead = new List<int>();
		}

		public TNHInstance(int instance, int hostID, bool letPeopleJoin, int progressionTypeSetting, int healthModeSetting, int equipmentModeSetting, int targetModeSetting, int AIDifficultyModifier, int radarModeModifier, int itemSpawnerMode, int backpackMode, int healthMult, int sosiggunShakeReloading, int TNHSeed, string levelID)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			this.instance = instance;
			playerIDs = new List<int>();
			playerIDs.Add(hostID);
			currentlyPlaying = new List<int>();
			played = new List<int>();
			dead = new List<int>();
			this.letPeopleJoin = letPeopleJoin;
			this.progressionTypeSetting = progressionTypeSetting;
			this.healthModeSetting = healthModeSetting;
			this.equipmentModeSetting = equipmentModeSetting;
			this.targetModeSetting = targetModeSetting;
			this.AIDifficultyModifier = AIDifficultyModifier;
			this.radarModeModifier = radarModeModifier;
			this.itemSpawnerMode = itemSpawnerMode;
			this.backpackMode = backpackMode;
			this.healthMult = healthMult;
			this.sosiggunShakeReloading = sosiggunShakeReloading;
			this.TNHSeed = TNHSeed;
			this.levelID = levelID;
		}

		public void AddCurrentlyPlaying(bool send, int ID, bool fromServer = false)
		{
			Mod.LogInfo("Adding " + ID + " to TNH instance " + instance + " currently playing", debug: false);
			if (!letPeopleJoin && currentlyPlaying.Count == 0 && (Object)(object)Mod.TNHInstanceList != (Object)null && Mod.joinTNHInstances.ContainsKey(instance))
			{
				Object.Destroy((Object)(object)Mod.joinTNHInstances[instance]);
				Mod.joinTNHInstances.Remove(instance);
			}
			currentlyPlaying.Add(ID);
			if (!played.Contains(ID))
			{
				if (ID == GameManager.ID)
				{
					TNH_ManagerPatch.addTokensSkip++;
					manager.AddTokens(tokenCount, false);
					TNH_ManagerPatch.addTokensSkip--;
				}
				played.Add(ID);
			}
			if (ID != GameManager.ID)
			{
				GameManager.UpdatePlayerHidden(GameManager.players[ID]);
			}
			if (fromServer)
			{
				Mod.LogInfo("\tServer", debug: false);
				if (ID == playerIDs[0])
				{
					Mod.LogInfo("\t\tNew player is host", debug: false);
					if (ID != controller)
					{
						Mod.LogInfo("\t\t\tbut not controller, distributing control", debug: false);
						GameManager.DistributeAllControl(controller, ID, new List<Type>
						{
							typeof(TrackedSosigData),
							typeof(TrackedAutoMeaterData),
							typeof(TrackedEncryptionData)
						});
					}
					Mod.LogInfo("\t\tSending", debug: false);
					controller = ID;
					ServerSend.SetTNHController(instance, ID);
				}
				else
				{
					Mod.LogInfo("\t\tNew player is not host", debug: false);
					if (currentlyPlaying.Count == 1)
					{
						Mod.LogInfo("\t\t\tOnly player", debug: false);
						if (ID != controller)
						{
							Mod.LogInfo("\t\t\t\tNot yet controller, distributing control", debug: false);
							GameManager.DistributeAllControl(controller, ID, new List<Type>
							{
								typeof(TrackedSosigData),
								typeof(TrackedAutoMeaterData),
								typeof(TrackedEncryptionData)
							});
						}
						Mod.LogInfo("\t\t\tSending", debug: false);
						controller = ID;
						ServerSend.SetTNHController(instance, ID);
					}
				}
			}
			if (send)
			{
				if (ThreadManager.host)
				{
					ServerSend.AddTNHCurrentlyPlaying(instance, ID);
				}
				else
				{
					ClientSend.AddTNHCurrentlyPlaying(instance);
				}
			}
		}

		public void RemoveCurrentlyPlaying(bool send, int ID, bool fromServer = false)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			if ((letPeopleJoin || currentlyPlaying.Count == 0) && (Object)(object)Mod.TNHInstanceList != (Object)null && Mod.joinTNHInstances != null && !Mod.joinTNHInstances.ContainsKey(instance))
			{
				GameObject val = Object.Instantiate<GameObject>(Mod.TNHInstancePrefab, Mod.TNHInstanceList.transform);
				((Component)val.transform.GetChild(0)).GetComponent<Text>().text = "Instance " + instance;
				val.SetActive(true);
				FVRPointableButton val2 = val.AddComponent<FVRPointableButton>();
				val2.SetButton();
				((FVRPointable)val2).MaxPointingRange = 5f;
				((UnityEvent)val2.Button.onClick).AddListener((UnityAction)delegate
				{
					Mod.OnTNHInstanceClicked(instance);
				});
				Mod.joinTNHInstances.Add(instance, val);
			}
			currentlyPlaying.Remove(ID);
			if (currentlyPlaying.Count == 0)
			{
				Reset();
			}
			else if (fromServer)
			{
				if (currentlyPlaying.Contains(playerIDs[0]))
				{
					if (playerIDs[0] != controller)
					{
						GameManager.DistributeAllControl(controller, playerIDs[0], new List<Type>
						{
							typeof(TrackedSosigData),
							typeof(TrackedAutoMeaterData),
							typeof(TrackedEncryptionData)
						});
					}
					ServerSend.SetTNHController(instance, playerIDs[0]);
					controller = playerIDs[0];
				}
				else
				{
					int num = int.MaxValue;
					for (int num2 = 0; num2 < currentlyPlaying.Count; num2++)
					{
						if (currentlyPlaying[num2] < num)
						{
							num = currentlyPlaying[num2];
						}
					}
					if (num != controller)
					{
						GameManager.DistributeAllControl(controller, num, new List<Type>
						{
							typeof(TrackedSosigData),
							typeof(TrackedAutoMeaterData),
							typeof(TrackedEncryptionData)
						});
					}
					ServerSend.SetTNHController(instance, num);
					controller = num;
				}
			}
			if (currentlyPlaying.Count == 1 && GameManager.spectatorHosts.Contains(currentlyPlaying[0]))
			{
				if (currentlyPlaying[0] == GameManager.ID)
				{
					GameManager.spectatorHostControlledBy = -1;
					if (!GameManager.sceneLoading)
					{
						if (!GameManager.scene.Equals("MainMenu3"))
						{
							SteamVR_LoadLevel.Begin("MainMenu3", false, 0.5f, 0f, 0f, 0f, 1f);
						}
					}
					else
					{
						GameManager.resetSpectatorHost = true;
					}
				}
				else if (GameManager.controlledSpectatorHost == currentlyPlaying[0])
				{
					Mod.OnSpectatorHostGiveUpInvoke();
				}
				if (ThreadManager.host && Server.spectatorHostControllers.TryGetValue(currentlyPlaying[0], out var value))
				{
					Server.spectatorHostByController.Remove(value);
					Server.spectatorHostControllers.Remove(currentlyPlaying[0]);
					if (GameManager.spectatorHosts.Contains(currentlyPlaying[0]))
					{
						Server.availableSpectatorHosts.Add(currentlyPlaying[0]);
					}
				}
			}
			if (initializer == ID && initializationRequested)
			{
				initializer = -1;
				initializationRequested = false;
			}
			if (send)
			{
				if (ThreadManager.host)
				{
					ServerSend.RemoveTNHCurrentlyPlaying(instance, ID);
				}
				else
				{
					ClientSend.RemoveTNHCurrentlyPlaying(instance);
				}
			}
		}

		public bool PlayersStillAlive()
		{
			for (int i = 0; i < Mod.currentTNHInstance.currentlyPlaying.Count; i++)
			{
				if (!Mod.currentTNHInstance.dead.Contains(Mod.currentTNHInstance.currentlyPlaying[i]))
				{
					return true;
				}
			}
			return false;
		}

		public void RevivePlayer(int ID, bool received = false)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (dead != null)
			{
				dead.Remove(ID);
			}
			if (ID == GameManager.ID)
			{
				Mod.TNHSpectating = false;
				if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
				{
					GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
					if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
					{
						((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
						((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
					}
				}
				if ((Object)(object)manager != (Object)null)
				{
					if ((Object)(object)Mod.TNHStartEquipButton == (Object)null)
					{
						Mod.TNHStartEquipButton = Object.Instantiate<GameObject>(Mod.TNHStartEquipButtonPrefab, GM.CurrentPlayerBody.Head);
						((UnityEvent)((Component)Mod.TNHStartEquipButton.transform.GetChild(0)).GetComponent<FVRPointableButton>().Button.onClick).AddListener(new UnityAction(Mod.OnTNHSpawnStartEquipClicked));
					}
					if (received)
					{
						manager.InitPlayerPosition();
					}
				}
				if (ThreadManager.host)
				{
					ServerSend.ReviveTNHPlayer(ID, instance, 0);
				}
				else if (!received)
				{
					ClientSend.ReviveTNHPlayer(ID, instance);
				}
			}
			else
			{
				GameManager.UpdatePlayerHidden(GameManager.players[ID]);
				if (!received && ThreadManager.host)
				{
					ServerSend.ReviveTNHPlayer(ID, instance, 0);
				}
			}
		}

		public void Reset()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			dead.Clear();
			played.Clear();
			controller = -1;
			tokenCount = 0;
			holdOngoing = false;
			holdState = (HoldState)0;
			warpInData = null;
			curHoldIndex = -1;
			level = 0;
			phase = (TNH_Phase)(-1);
			activeSupplyPointIndices = null;
			raisedBarriers = null;
			raisedBarrierPrefabIndices = null;
			spawnedStartEquip = false;
			tickDownToFailure = 120f;
			initializationRequested = false;
			initializer = -1;
			nextSupplyPanelType = 1;
			if (Mod.currentTNHInstance == null || Mod.currentTNHInstance.instance != instance)
			{
				return;
			}
			Mod.TNHSpectating = false;
			if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
				if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
				{
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
				}
			}
		}

		public void ResetManager()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)manager == (Object)null))
			{
				phase = (TNH_Phase)(-1);
				manager.UsesClassicPatrolBehavior = true;
				manager.m_level = -1;
				manager.m_numTokens = 5;
				manager.SupplyPoints.Clear();
				manager.m_weaponCases.Clear();
				manager.m_patrolSquads.Clear();
				manager.m_miscEnemies.Clear();
				for (int i = 0; i < manager.Nums.Length; i++)
				{
					manager.Nums[i] = 0;
				}
				for (int j = 0; j < manager.Stats.Length; j++)
				{
					manager.Stats[j] = 0;
				}
				manager.m_hasInit = false;
				manager.m_activeSupplyPointIndicies.Clear();
				manager.m_nextSupplyPanelType = 1;
			}
		}
	}
	public class Server
	{
		public delegate void PacketHandler(int clientID, Packet packet);

		public delegate void OnServerCloseDelegate();

		public static ushort port;

		public static ushort maxClientCount;

		public static Dictionary<int, ServerClient> clients = new Dictionary<int, ServerClient>();

		public static List<int> connectedClients = new List<int>();

		public static PacketHandler[] packetHandlers;

		public static TrackedObjectData[] objects;

		public static List<int> availableObjectIndices;

		public static Dictionary<int, List<int>> availableIndexBufferWaitingFor = new Dictionary<int, List<int>>();

		public static Dictionary<int, List<int>> availableIndexBufferClients = new Dictionary<int, List<int>>();

		public static Dictionary<int, List<int>> IDsToConfirm = new Dictionary<int, List<int>>();

		public static readonly int IDConfirmLimit = 1;

		public static List<int> availableSpectatorHosts;

		public static Dictionary<int, int> spectatorHostByController = new Dictionary<int, int>();

		public static Dictionary<int, int> spectatorHostControllers = new Dictionary<int, int>();

		public static Dictionary<int, List<int>> clientsWaitingUpDate = new Dictionary<int, List<int>>();

		public static Dictionary<int, List<int>> loadingClientsWaitingFrom = new Dictionary<int, List<int>>();

		public static TcpListener tcpListener;

		public static UdpClient udpListener;

		public static List<ServerClient> PTClients = new List<ServerClient>();

		public static System.Timers.Timer tickTimer = new System.Timers.Timer();

		public static event OnServerCloseDelegate OnServerClose;

		public static void Start(ushort _maxClientCount, ushort _port, int tickRate)
		{
			Mod.LogInfo("Starting server on port: " + _port, debug: false);
			maxClientCount = _maxClientCount;
			port = _port;
			InitializeServerData();
			tcpListener = new TcpListener(IPAddress.Any, port);
			tcpListener.Start();
			tcpListener.BeginAcceptTcpClient(TCPConnectCallback, null);
			udpListener = new UdpClient(port);
			udpListener.BeginReceive(UDPReceiveCallback, null);
			Mod.LogInfo("Server started, listening on port: " + port, debug: false);
			if (!GameManager.nonSynchronizedScenes.ContainsKey(GameManager.scene))
			{
				GameManager.SyncTrackedObjects(init: true, inControl: true);
			}
			tickTimer.Elapsed += Tick;
			tickTimer.Interval = 1000f / (float)tickRate;
			tickTimer.AutoReset = true;
			tickTimer.Start();
		}

		private static void Tick(object sender, ElapsedEventArgs e)
		{
			ServerSend.SendAllBatchedUDPData();
		}

		public static void Close()
		{
			tickTimer.Elapsed -= Tick;
			tickTimer.Stop();
			if (!((Object)(object)Mod.managerObject == (Object)null))
			{
				Mod.LogInfo("Closing server.", debug: false);
				ServerSend.ServerClosed();
				GameManager.TakeAllPhysicalControl(destroyTrackedScript: true);
				clients.Clear();
				objects = null;
				availableObjectIndices = null;
				availableSpectatorHosts.Clear();
				spectatorHostByController.Clear();
				tcpListener.Stop();
				tcpListener = null;
				udpListener.Close();
				udpListener = null;
				GameManager.Reset();
				Mod.Reset();
				SpecificClose();
				if (Server.OnServerClose != null)
				{
					Server.OnServerClose();
				}
			}
		}

		private static void SpecificClose()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			Mod.currentTNHInstance = null;
			Mod.TNHSpectating = false;
			if ((Object)(object)GM.CurrentPlayerBody != (Object)null)
			{
				GM.CurrentPlayerBody.SetPlayerIFF(GM.CurrentSceneSettings.DefaultPlayerIFF);
				if ((Object)(object)GM.CurrentPlayerBody.RightHand != (Object)null && (Object)(object)GM.CurrentPlayerBody.LeftHand != (Object)null)
				{
					((Component)GM.CurrentPlayerBody.RightHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
					((Component)GM.CurrentPlayerBody.LeftHand).GetComponent<FVRViveHand>().Mode = (HandMode)0;
				}
			}
			Mod.currentlyPlayingTNH = false;
			Mod.currentTNHInstancePlayers = null;
			Mod.joinTNHInstances = null;
			if ((Object)(object)Mod.TNHMenu != (Object)null)
			{
				Object.Destroy((Object)(object)Mod.TNHMenu);
				Mod.TNHMenu = null;
			}
		}

		private static void TCPConnectCallback(IAsyncResult result)
		{
			TcpClient tcpClient = tcpListener.EndAcceptTcpClient(result);
			tcpListener.BeginAcceptTcpClient(TCPConnectCallback, null);
			Mod.LogInfo($"Incoming connection from {tcpClient.Client.RemoteEndPoint}", debug: false);
			for (int i = 1; i <= maxClientCount; i++)
			{
				if (clients[i].tcp.socket == null && !clients[i].attemptingPunchThrough)
				{
					clients[i].tcp.Connect(tcpClient);
					clients[i].connected = true;
					return;
				}
			}
			Mod.LogWarning($"{tcpClient.Client.RemoteEndPoint} failed to connect, server full");
		}

		private static void UDPReceiveCallback(IAsyncResult result)
		{
			if (tcpListener == null)
			{
				return;
			}
			try
			{
				IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
				byte[] array = udpListener.EndReceive(result, ref remoteEP);
				udpListener.BeginReceive(UDPReceiveCallback, null);
				if (array.Length < 4)
				{
					return;
				}
				using Packet packet = new Packet(array);
				int num = packet.ReadInt();
				if (num != 0)
				{
					if (clients[num].udp.endPoint == null)
					{
						clients[num].udp.Connect(remoteEP);
					}
					else if (clients[num].udp.endPoint.ToString() == remoteEP.ToString())
					{
						clients[num].udp.HandleData(packet);
					}
				}
			}
			catch (Exception arg)
			{
				Mod.LogInfo($"Error receiving UDP data: {arg}", debug: false);
			}
		}

		public static void SendUDPData(IPEndPoint clientEndPoint, Packet packet)
		{
			try
			{
				if (clientEndPoint != null)
				{
					udpListener.BeginSend(packet.ToArray(), packet.Length(), clientEndPoint, null, null);
				}
			}
			catch (Exception arg)
			{
				Mod.LogInfo($"Error sending UDP data to {clientEndPoint}: {arg}", debug: false);
			}
		}

		public static void AddTrackedObject(TrackedObjectData trackedObject, int clientID)
		{
			Mod.LogInfo("Server adding new tracked object with waiting local index: " + trackedObject.localWaitingIndex + " from client: " + clientID + " with type ID: " + trackedObject.typeIdentifier + " in " + trackedObject.scene + "/" + trackedObject.instance, debug: false);
			if (trackedObject.trackedID == -1 && trackedObject.controller != 0 && trackedObject.sceneInit && !clients[trackedObject.controller].player.firstInSceneInstance)
			{
				Mod.LogInfo("\tRejecting", debug: false);
				trackedObject.trackedID = -2;
				ServerSend.TrackedObjectSpecific(trackedObject, trackedObject.controller);
				return;
			}
			if (availableObjectIndices.Count == 0)
			{
				IncreaseObjectsSize();
			}
			trackedObject.trackedID = availableObjectIndices[availableObjectIndices.Count - 1];
			availableObjectIndices.RemoveAt(availableObjectIndices.Count - 1);
			objects[trackedObject.trackedID] = trackedObject;
			Mod.LogInfo("\tAssigned tracked ID: " + trackedObject.trackedID, debug: false);
			if (GameManager.objectsByInstanceByScene.TryGetValue(trackedObject.scene, out var value))
			{
				if (value.TryGetValue(trackedObject.instance, out var value2))
				{
					value2.Add(trackedObject.trackedID);
				}
				else
				{
					value.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
				}
			}
			else
			{
				Dictionary<int, List<int>> dictionary = new Dictionary<int, List<int>>();
				dictionary.Add(trackedObject.instance, new List<int> { trackedObject.trackedID });
				GameManager.objectsByInstanceByScene.Add(trackedObject.scene, dictionary);
			}
			if (trackedObject.parent != -1 && trackedObject.initTracker != GameManager.ID)
			{
				TrackedObjectData trackedObjectData = objects[trackedObject.parent];
				if (trackedObjectData.children == null)
				{
					trackedObjectData.children = new List<TrackedObjectData>();
				}
				trackedObject.childIndex = trackedObjectData.children.Count;
				trackedObjectData.children.Add(trackedObject);
			}
			if (clientID != 0 && trackedObject.IsIdentifiable() && (Object)(object)trackedObject.physical == (Object)null && !trackedObject.awaitingInstantiation && !GameManager.sceneLoading && trackedObject.scene.Equals(GameManager.scene) && trackedObject.instance == GameManager.instance)
			{
				trackedObject.awaitingInstantiation = true;
				AnvilManager.Run(trackedObject.Instantiate());
			}
			List<int> list = new List<int>();
			if (clientID != 0)
			{
				list.Add(clientID);
			}
			if (GameManager.playersByInstanceByScene.TryGetValue(trackedObject.scene, out var value3) && value3.TryGetValue(trackedObject.instance, out var value4))
			{
				for (int i = 0; i < value4.Count; i++)
				{
					if (value4[i] != clientID)
					{
						list.Add(value4[i]);
					}
				}
			}
			Mod.LogInfo("\tSending to players:", debug: false);
			for (int j = 0; j < list.Count; j++)
			{
				Mod.LogInfo("\t\t" + list[j], debug: false);
			}
			ServerSend.TrackedObject(trackedObject, list);
			if (trackedObject.controller != 0)
			{
				trackedObject.localTrackedID = -1;
			}
		}

		private static void IncreaseObjectsSize()
		{
			TrackedObjectData[] array = objects;
			objects = new TrackedObjectData[array.Length + 100];
			for (int i = 0; i < array.Length; i++)
			{
				objects[i] = array[i];
			}
			for (int j = array.Length; j < objects.Length; j++)
			{
				availableObjectIndices.Add(j);
			}
		}

		private static void InitializeServerData()
		{
			for (int i = 1; i <= maxClientCount; i++)
			{
				clients.Add(i, new ServerClient(i));
			}
			packetHandlers = new PacketHandler[200]
			{
				ServerHandle.GrappleAttached,
				ServerHandle.WelcomeReceived,
				ServerHandle.PlayerState,
				ServerHandle.PlayerScene,
				null,
				ServerHandle.DestroyObject,
				ServerHandle.ObjectUpdate,
				ServerHandle.ShatterableCrateSetHoldingHealth,
				ServerHandle.GiveObjectControl,
				ServerHandle.TrackedObjects,
				ServerHandle.ObjectParent,
				ServerHandle.WeaponFire,
				ServerHandle.PlayerDamage,
				ServerHandle.RemoteGunChamber,
				ServerHandle.ChamberRound,
				ServerHandle.IntegratedFirearmFire,
				ServerHandle.TrackedObject,
				ServerHandle.SosigPickUpItem,
				ServerHandle.SosigPlaceItemIn,
				ServerHandle.SosigDropSlot,
				ServerHandle.SosigHandDrop,
				ServerHandle.SosigConfigure,
				ServerHandle.SosigLinkRegisterWearable,
				ServerHandle.SosigLinkDeRegisterWearable,
				ServerHandle.SosigSetIFF,
				ServerHandle.SosigSetOriginalIFF,
				ServerHandle.SosigLinkDamage,
				ServerHandle.SosigDamageData,
				ServerHandle.SosigWearableDamage,
				ServerHandle.SosigLinkExplodes,
				ServerHandle.SosigDies,
				ServerHandle.SosigClear,
				ServerHandle.SosigSetBodyState,
				ServerHandle.PlaySosigFootStepSound,
				ServerHandle.SosigSpeakState,
				ServerHandle.SosigSetCurrentOrder,
				ServerHandle.SosigVaporize,
				ServerHandle.SosigRequestHitDecal,
				ServerHandle.SosigLinkBreak,
				ServerHandle.SosigLinkSever,
				ServerHandle.UpToDateObjects,
				ServerHandle.SpeedloaderChamberLoad,
				ServerHandle.PlayerInstance,
				ServerHandle.AddTNHInstance,
				ServerHandle.AddTNHCurrentlyPlaying,
				ServerHandle.RemoveTNHCurrentlyPlaying,
				ServerHandle.SetTNHProgression,
				ServerHandle.SetTNHEquipment,
				ServerHandle.SetTNHHealthMode,
				ServerHandle.SetTNHTargetMode,
				ServerHandle.SetTNHAIDifficulty,
				ServerHandle.SetTNHRadarMode,
				ServerHandle.SetTNHItemSpawnerMode,
				ServerHandle.SetTNHBackpackMode,
				ServerHandle.SetTNHHealthMult,
				ServerHandle.SetTNHSosigGunReload,
				ServerHandle.SetTNHSeed,
				ServerHandle.SetTNHLevelID,
				ServerHandle.AddInstance,
				ServerHandle.SetTNHController,
				ServerHandle.SpectatorHost,
				ServerHandle.TNHPlayerDied,
				ServerHandle.TNHAddTokens,
				ServerHandle.TNHSetLevel,
				ServerHandle.RevolvingShotgunLoad,
				ServerHandle.GrappleGunLoad,
				ServerHandle.CarlGustafLatchSate,
				ServerHandle.CarlGustafShellSlideSate,
				ServerHandle.TNHHostStartHold,
				ServerHandle.AutoMeaterSetState,
				ServerHandle.AutoMeaterSetBladesActive,
				ServerHandle.AutoMeaterDamage,
				ServerHandle.AutoMeaterDamageData,
				ServerHandle.AutoMeaterFirearmFireShot,
				ServerHandle.AutoMeaterFirearmFireAtWill,
				ServerHandle.AutoMeaterHitZoneDamage,
				ServerHandle.AutoMeaterHitZoneDamageData,
				ServerHandle.TNHSosigKill,
				ServerHandle.TNHHoldPointSystemNode,
				ServerHandle.TNHHoldBeginChallenge,
				ServerHandle.ShatterableCrateDamage,
				ServerHandle.TNHSetPhaseTake,
				ServerHandle.TNHHoldCompletePhase,
				ServerHandle.TNHHoldPointFailOut,
				ServerHandle.TNHSetPhaseComplete,
				ServerHandle.TNHSetPhase,
				ServerHandle.MagazineLoad,
				ServerHandle.MagazineLoadAttachable,
				ServerHandle.ClipLoad,
				ServerHandle.RevolverCylinderLoad,
				ServerHandle.EncryptionDamage,
				ServerHandle.EncryptionDamageData,
				ServerHandle.EncryptionRespawnSubTarg,
				ServerHandle.EncryptionSpawnGrowth,
				ServerHandle.EncryptionInit,
				ServerHandle.EncryptionResetGrowth,
				ServerHandle.EncryptionDisableSubtarg,
				ServerHandle.EncryptionSubDamage,
				ServerHandle.ShatterableCrateDestroy,
				ServerHandle.RegisterCustomPacketType,
				ServerHandle.DoneLoadingScene,
				ServerHandle.DoneSendingUpToDateObjects,
				ServerHandle.SosigWeaponFire,
				ServerHandle.SosigWeaponShatter,
				ServerHandle.SosigWeaponDamage,
				ServerHandle.LAPD2019Fire,
				ServerHandle.LAPD2019LoadBattery,
				ServerHandle.LAPD2019ExtractBattery,
				null,
				ServerHandle.AttachableFirearmFire,
				ServerHandle.BreakActionWeaponFire,
				ServerHandle.PlayerIFF,
				ServerHandle.UberShatterableShatter,
				ServerHandle.TNHHoldPointBeginAnalyzing,
				ServerHandle.TNHHoldPointRaiseBarriers,
				ServerHandle.TNHHoldIdentifyEncryption,
				ServerHandle.TNHHoldPointBeginPhase,
				ServerHandle.TNHHoldPointCompleteHold,
				ServerHandle.SosigPriorityIFFChart,
				ServerHandle.LeverActionFirearmFire,
				ServerHandle.RevolvingShotgunFire,
				ServerHandle.DerringerFire,
				ServerHandle.FlintlockWeaponBurnOffOuter,
				ServerHandle.FlintlockWeaponFire,
				ServerHandle.GrappleGunFire,
				ServerHandle.HCBReleaseSled,
				ServerHandle.RemoteMissileDetonate,
				ServerHandle.RemoteMissileDamage,
				ServerHandle.RevolverFire,
				ServerHandle.SingleActionRevolverFire,
				ServerHandle.StingerLauncherFire,
				ServerHandle.StingerMissileDamage,
				ServerHandle.StingerMissileExplode,
				ServerHandle.PinnedGrenadeExplode,
				ServerHandle.FVRGrenadeExplode,
				ServerHandle.ClientDisconnect,
				ServerHandle.BangSnapSplode,
				ServerHandle.C4Detonate,
				ServerHandle.ClaymoreMineDetonate,
				ServerHandle.SLAMDetonate,
				ServerHandle.Ping,
				ServerHandle.TNHSetPhaseHold,
				ServerHandle.ShatterableCrateSetHoldingToken,
				ServerHandle.ResetTNH,
				ServerHandle.ReviveTNHPlayer,
				ServerHandle.PlayerColor,
				ServerHandle.RequestTNHInitialization,
				ServerHandle.TNHInitializer,
				ServerHandle.FuseIgnite,
				ServerHandle.FuseBoom,
				ServerHandle.MolotovShatter,
				ServerHandle.MolotovDamage,
				ServerHandle.PinnedGrenadePullPin,
				ServerHandle.MagazineAddRound,
				ServerHandle.ClipAddRound,
				ServerHandle.BreakableGlassDamage,
				ServerHandle.WindowShatterSound,
				ServerHandle.RequestSpectatorHost,
				ServerHandle.UnassignSpectatorHost,
				ServerHandle.SpectatorHostOrderTNHHost,
				ServerHandle.TNHSpectatorHostReady,
				ServerHandle.SpectatorHostStartTNH,
				ServerHandle.ReassignSpectatorHost,
				ServerHandle.ReactiveSteelTargetDamage,
				ServerHandle.MTUTest,
				ServerHandle.IDConfirm,
				ServerHandle.ObjectScene,
				ServerHandle.ObjectInstance,
				ServerHandle.UpdateEncryptionDisplay,
				ServerHandle.EncryptionRespawnSubTargGeo,
				ServerHandle.RoundDamage,
				ServerHandle.RoundSplode,
				ServerHandle.SightFlipperState,
				ServerHandle.SightRaiserState,
				ServerHandle.GatlingGunFire,
				ServerHandle.GasCuboidGout,
				ServerHandle.GasCuboidDamage,
				ServerHandle.GasCuboidHandleDamage,
				ServerHandle.GasCuboidDamageHandle,
				ServerHandle.GasCuboidExplode,
				ServerHandle.GasCuboidShatter,
				ServerHandle.FloaterDamage,
				ServerHandle.FloaterCoreDamage,
				ServerHandle.FloaterBeginExploding,
				ServerHandle.FloaterExplode,
				ServerHandle.IrisShatter,
				ServerHandle.IrisSetState,
				ServerHandle.BrutBlockSystemStart,
				ServerHandle.FloaterBeginDefusing,
				ServerHandle.BatchedPackets,
				ServerHandle.NodeInit,
				ServerHandle.NodeFire,
				ServerHandle.HazeDamage,
				ServerHandle.EncryptionFireGun,
				ServerHandle.EncryptionNextPos,
				ServerHandle.EncryptionShieldRot,
				ServerHandle.SentinelInit,
				ServerHandle.AlertSosigs,
				ServerHandle.SetModulWeaponPart,
				ServerHandle.ShatterableCrateSetUsesLoot
			};
			objects = new TrackedObjectData[100];
			availableObjectIndices = new List<int>
			{
				0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
				10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
				20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
				30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
				40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
				50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
				60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
				70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
				80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
				90, 91, 92, 93, 94, 95, 96, 97, 98, 99
			};
			availableSpectatorHosts = new List<int>();
			clientsWaitingUpDate.Clear();
			loadingClientsWaitingFrom.Clear();
			Mod.LogInfo("Initialized server", debug: false);
		}

		public static int RegisterCustomPacketType(string handlerID, int clientID = 0)
		{
			if (Mod.registeredCustomPacketIDs.TryGetValue(handlerID, out var value))
			{
				Mod.LogWarning("Client " + clientID + " requested for " + handlerID + " custom packet handler to be registered but this ID already exists.");
			}
			else
			{
				if (Mod.availableCustomPacketIndices.Count > 0)
				{
					value = Mod.availableCustomPacketIndices[Mod.availableCustomPacketIndices.Count - 1];
					Mod.availableCustomPacketIndices.RemoveAt(Mod.availableCustomPacketIndices.Count - 1);
				}
				else
				{
					value = Mod.customPacketHandlers.Length;
					Mod.CustomPacketHandler[] customPacketHandlers = Mod.customPacketHandlers;
					Mod.customPacketHandlers = new Mod.CustomPacketHandler[value + 10];
					for (int i = 0; i < customPacketHandlers.Length; i++)
					{
						Mod.customPacketHandlers[i] = customPacketHandlers[i];
					}
					for (int j = value + 1; j < Mod.customPacketHandlers.Length; j++)
					{
						Mod.availableCustomPacketIndices.Add(j);
					}
				}
				Mod.registeredCustomPacketIDs.Add(handlerID, value);
				Mod.CustomPacketHandlerReceivedInvoke(handlerID, value);
			}
			ServerSend.RegisterCustomPacketType(handlerID, value);
			return value;
		}
	}
}