using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using V73ScrapUnlagger.NetcodePatcher;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("V73ScrapUnlagger")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("V73ScrapUnlagger")]
[assembly: AssemblyTitle("V73ScrapUnlagger")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace V73ScrapUnlagger
{
	[BepInPlugin("WaterGun.V73ScrapUnlagger", "V73ScrapUnlagger", "1.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		internal class StartOfRoundPatch
		{
			[HarmonyPostfix]
			public static void StartOfRoundInstance(StartOfRound __instance)
			{
				if (NetworkManager.Singleton.IsServer)
				{
					GameObject val = Object.Instantiate<GameObject>(UnlaggerContainer);
					val.GetComponent<NetworkObject>().Spawn(false);
				}
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		internal class GameNetworkManagerPatch
		{
			[HarmonyPostfix]
			public static void GameNetworkManagerInstance(GameNetworkManager __instance)
			{
				Debug.Log((object)"hooked into gamenetworkmanager");
				if (!NetworkManager.Singleton.NetworkConfig.Prefabs.Contains(UnlaggerContainer))
				{
					NetworkManager.Singleton.AddNetworkPrefab(UnlaggerContainer);
					Debug.Log((object)("registered networkprefab: " + ((Object)UnlaggerContainer).name));
				}
			}
		}

		private const string GUID = "WaterGun.V73ScrapUnlagger";

		private const string NAME = "V73ScrapUnlagger";

		private const string VER = "1.1.0";

		public static AssetBundle bundle;

		public static GameObject UnlaggerContainer;

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Harmony val = new Harmony("WaterGun.V73ScrapUnlagger");
			val.PatchAll();
			string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "unlagger");
			bundle = AssetBundle.LoadFromFile(text);
			UnlaggerContainer = bundle.LoadAsset<GameObject>("Assets/LethalCompany/Mods/ScrapUnlagger/UnlaggerContainer.prefab");
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded!!!");
		}
	}
}
namespace V73ScrapUnlagger.Managers
{
	public class UnlagManager : NetworkBehaviour
	{
		public Transform ScrapPositioner;

		public Material ActiveMaterial;

		public Material EmptyMaterial;

		public MeshRenderer TriggerAMaterial;

		public MeshRenderer TriggerBMaterial;

		public GrabbableObject ObjectA;

		public GrabbableObject ObjectB;

		public void RemoveObjects(PlayerControllerB player)
		{
			RemoveObjectsServerRpc(player.playerClientId);
		}

		[ServerRpc(RequireOwnership = false)]
		public void RemoveObjectsServerRpc(ulong clientid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(97785220u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientid);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 97785220u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if ((Object)(object)ObjectA != (Object)null)
				{
					ApplyMaterialClientRpc(material: false, 1);
					ObjectA = null;
				}
				if ((Object)(object)ObjectB != (Object)null)
				{
					ApplyMaterialClientRpc(material: false, 2);
					ObjectB = null;
				}
			}
		}

		public void AddObjectA(PlayerControllerB player)
		{
			AddObjectAServerRpc(player.playerClientId);
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddObjectAServerRpc(ulong clientid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1466069345u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientid);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1466069345u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				Debug.Log((object)"Searching for client");
				if (val3.playerClientId != clientid)
				{
					continue;
				}
				Debug.Log((object)"Found Client");
				if (!((Object)(object)val3.currentlyHeldObjectServer != (Object)null) || !val3.currentlyHeldObjectServer.itemProperties.isScrap)
				{
					continue;
				}
				Debug.Log((object)"setting object");
				ObjectA = val3.currentlyHeldObjectServer;
				ApplyMaterialClientRpc(material: true, 1);
				DisplayScrapMergeClientRpc("ScrapUnlagger", "Set ObjectA to: " + ((Object)((Component)ObjectA).gameObject).name, IsWarning: false);
				if ((Object)(object)ObjectB != (Object)null)
				{
					if (ObjectA == ObjectB)
					{
						DisplayScrapMergeClientRpc("ScrapUnlagger", "Unable to set ObjectA", IsWarning: true);
						ObjectA = null;
						ApplyMaterialClientRpc(material: false, 1);
						break;
					}
					MergeValues();
				}
			}
		}

		public void AddObjectB(PlayerControllerB player)
		{
			AddObjectBServerRpc(player.playerClientId);
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddObjectBServerRpc(ulong clientid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2283259010u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientid);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2283259010u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				Debug.Log((object)"Searching for client");
				if (val3.playerClientId != clientid)
				{
					continue;
				}
				Debug.Log((object)"Found Client");
				if (!((Object)(object)val3.currentlyHeldObjectServer != (Object)null) || !val3.currentlyHeldObjectServer.itemProperties.isScrap)
				{
					continue;
				}
				Debug.Log((object)"setting object");
				ObjectB = val3.currentlyHeldObjectServer;
				ApplyMaterialClientRpc(material: true, 2);
				DisplayScrapMergeClientRpc("ScrapUnlagger", "Set ObjectB to: " + ((Object)((Component)ObjectB).gameObject).name, IsWarning: false);
				if ((Object)(object)ObjectA != (Object)null)
				{
					if (ObjectB == ObjectA)
					{
						DisplayScrapMergeClientRpc("ScrapUnlagger", "Unable to set ObjectB", IsWarning: true);
						ObjectB = null;
						ApplyMaterialClientRpc(material: false, 2);
						break;
					}
					MergeValues();
				}
			}
		}

		public void MergeValues()
		{
			//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_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ObjectA != (Object)null) || !((Object)(object)ObjectB != (Object)null))
			{
				return;
			}
			GrabbableObject objectA = ObjectA;
			int scrapValue = (objectA.scrapValue += ObjectB.scrapValue);
			GameObject val = Object.Instantiate<GameObject>(ObjectA.itemProperties.spawnPrefab, ScrapPositioner.position, Quaternion.identity);
			val.GetComponent<NetworkObject>().Spawn(false);
			val.GetComponent<GrabbableObject>().isInShipRoom = true;
			val.GetComponent<GrabbableObject>().isInFactory = false;
			SyncScrapValuesClientRpc(scrapValue, NetworkObjectReference.op_Implicit(val));
			if ((Object)(object)ObjectA.playerHeldBy != (Object)null)
			{
				ObjectA.playerHeldBy.DropAllHeldItems(true, false);
				if ((Object)(object)ObjectA.playerHeldBy == (Object)null)
				{
					((Component)ObjectA).GetComponent<NetworkObject>().Despawn(true);
					ObjectA = null;
					ApplyMaterialClientRpc(material: false, 1);
				}
			}
			else
			{
				((Component)ObjectA).GetComponent<NetworkObject>().Despawn(true);
				ObjectA = null;
				ApplyMaterialClientRpc(material: false, 1);
			}
			if ((Object)(object)ObjectB.playerHeldBy != (Object)null && !ObjectB.isPocketed)
			{
				ObjectB.playerHeldBy.DropAllHeldItems(true, false);
				if ((Object)(object)ObjectB.playerHeldBy == (Object)null)
				{
					((Component)ObjectB).GetComponent<NetworkObject>().Despawn(true);
					ObjectB = null;
					ApplyMaterialClientRpc(material: false, 2);
				}
			}
			else
			{
				((Component)ObjectB).GetComponent<NetworkObject>().Despawn(true);
				ObjectB = null;
				ApplyMaterialClientRpc(material: false, 2);
			}
			DisplayScrapMergeClientRpc("ScrapUnlagger", "Converted two scraps into one", IsWarning: false);
		}

		[ClientRpc]
		public void SyncScrapValuesClientRpc(int ScrapValue, NetworkObjectReference netobj)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0090: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(280204983u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, ScrapValue);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref netobj, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 280204983u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				NetworkObject val3 = default(NetworkObject);
				if (((NetworkObjectReference)(ref netobj)).TryGet(ref val3, (NetworkManager)null))
				{
					((Component)val3).GetComponent<GrabbableObject>().SetScrapValue(ScrapValue);
				}
			}
		}

		[ClientRpc]
		public void DisplayScrapMergeClientRpc(string Header, string Description, bool IsWarning)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0158: 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_00cc: 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_00ff: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4218013638u, val, (RpcDelivery)0);
				bool flag = Header != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(Header, false);
				}
				bool flag2 = Description != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(Description, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref IsWarning, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4218013638u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (StartOfRound.Instance.localPlayerController.isInHangarShipRoom)
				{
					HUDManager.Instance.DisplayTip(Header, Description, IsWarning, false, "LC_Tip1");
				}
			}
		}

		[ClientRpc]
		public void ApplyMaterialClientRpc(bool material, int triggerid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_008c: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2160625355u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref material, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, triggerid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2160625355u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			switch (triggerid)
			{
			case 1:
				if (material)
				{
					((Renderer)TriggerAMaterial).material = ActiveMaterial;
				}
				else
				{
					((Renderer)TriggerAMaterial).material = EmptyMaterial;
				}
				break;
			case 2:
				if (material)
				{
					((Renderer)TriggerBMaterial).material = ActiveMaterial;
				}
				else
				{
					((Renderer)TriggerBMaterial).material = EmptyMaterial;
				}
				break;
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(97785220u, new RpcReceiveHandler(__rpc_handler_97785220), "RemoveObjectsServerRpc");
			((NetworkBehaviour)this).__registerRpc(1466069345u, new RpcReceiveHandler(__rpc_handler_1466069345), "AddObjectAServerRpc");
			((NetworkBehaviour)this).__registerRpc(2283259010u, new RpcReceiveHandler(__rpc_handler_2283259010), "AddObjectBServerRpc");
			((NetworkBehaviour)this).__registerRpc(280204983u, new RpcReceiveHandler(__rpc_handler_280204983), "SyncScrapValuesClientRpc");
			((NetworkBehaviour)this).__registerRpc(4218013638u, new RpcReceiveHandler(__rpc_handler_4218013638), "DisplayScrapMergeClientRpc");
			((NetworkBehaviour)this).__registerRpc(2160625355u, new RpcReceiveHandler(__rpc_handler_2160625355), "ApplyMaterialClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_97785220(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((UnlagManager)(object)target).RemoveObjectsServerRpc(clientid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1466069345(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((UnlagManager)(object)target).AddObjectAServerRpc(clientid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2283259010(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((UnlagManager)(object)target).AddObjectBServerRpc(clientid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_280204983(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: 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_0060: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int scrapValue = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref scrapValue);
				NetworkObjectReference netobj = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref netobj, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((UnlagManager)(object)target).SyncScrapValuesClientRpc(scrapValue, netobj);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4218013638(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_009f: 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_00b4: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string header = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref header, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string description = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref description, false);
				}
				bool isWarning = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isWarning, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((UnlagManager)(object)target).DisplayScrapMergeClientRpc(header, description, isWarning);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2160625355(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool material = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref material, default(ForPrimitives));
				int triggerid = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref triggerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((UnlagManager)(object)target).ApplyMaterialClientRpc(material, triggerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "UnlagManager";
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace V73ScrapUnlagger.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}