using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LootbugTest.NetcodePatcher;
using LootbugTest.managers;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("LootbugTest")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LootbugTest")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fa7dac25-8bd7-4ad3-9669-4d3809b56b1f")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace LootbugTest
{
	[BepInPlugin("mzmbq.LootbugTest", "LootbugTest", "0.1")]
	public class LootbugTest : BaseUnityPlugin
	{
		private const string modGUID = "mzmbq.LootbugTest";

		private const string modName = "LootbugTest";

		private const string modVersion = "0.1";

		private readonly Harmony harmony = new Harmony("mzmbq.LootbugTest");

		public static LootbugTest Instance;

		public static ManualLogSource logger;

		public static AudioClip[] newLootbugSFX;

		public static AudioClip newFlowermanAngerSFX;

		public GameObject netManagerPrefab;

		public InputAction actionJumpForce;

		public InputAction actionBunnyMode;

		public InputAction actionSoftBoots;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			InitLogger();
			InitNetcodePatcher();
			LoadSound();
			LoadNetcode();
			Task.Delay(5000).ContinueWith(delegate
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_0020: 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: Expected O, but got Unknown
				//IL_007c: 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_00ca: Expected O, but got Unknown
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				actionJumpForce = new InputAction((string)null, (InputActionType)1, (string)null, (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(actionJumpForce, "<Keyboard>/p", (string)null, (string)null, (string)null);
				actionJumpForce.performed += delegate
				{
					CustomNetworkManager.Instance.ToggleWeakLegs();
				};
				actionJumpForce.Enable();
				actionBunnyMode = new InputAction((string)null, (InputActionType)1, (string)null, (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(actionBunnyMode, "<Keyboard>/l", (string)null, (string)null, (string)null);
				actionBunnyMode.performed += delegate
				{
					CustomNetworkManager.Instance.ToggleBunnyMode();
				};
				actionBunnyMode.Enable();
				actionSoftBoots = new InputAction((string)null, (InputActionType)1, (string)null, (string)null, (string)null, (string)null);
				InputActionSetupExtensions.AddBinding(actionSoftBoots, "<Keyboard>/i", (string)null, (string)null, (string)null);
				actionSoftBoots.performed += delegate
				{
					CustomNetworkManager.Instance.ToggleSoftBoots();
				};
				actionSoftBoots.Enable();
			});
			harmony.PatchAll();
		}

		internal void InitNetcodePatcher()
		{
			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);
					}
				}
			}
		}

		internal void InitLogger()
		{
			logger = Logger.CreateLogSource("mzmbq.LootbugTest");
			logger.LogInfo((object)"-- Hello :)");
		}

		internal void LoadNetcode()
		{
			string location = ((BaseUnityPlugin)Instance).Info.Location;
			string text = "LootbugTest.dll";
			string text2 = location.TrimEnd(text.ToCharArray());
			string text3 = text2 + "lootbugnetcode";
			netManagerPrefab = AssetBundle.LoadFromFile(text3).LoadAsset<GameObject>("Assets/NetcodeMod/CustomNetworking.prefab");
			if ((Object)(object)netManagerPrefab == (Object)null)
			{
				logger.LogInfo((object)"Failed loading netcode");
			}
			netManagerPrefab.AddComponent<CustomNetworkManager>();
			logger.LogInfo((object)"LootbugTest netcode was Loaded");
		}

		internal void LoadSound()
		{
			string location = ((BaseUnityPlugin)Instance).Info.Location;
			string text = "LootbugTest.dll";
			string text2 = location.TrimEnd(text.ToCharArray());
			string text3 = text2 + "lootbugtestbundle";
			AssetBundle val = AssetBundle.LoadFromFile(text3);
			if ((Object)(object)val == (Object)null)
			{
				logger.LogError((object)"Failed to load assets!");
				return;
			}
			newLootbugSFX = val.LoadAllAssets<AudioClip>();
			newFlowermanAngerSFX = val.LoadAsset<AudioClip>("Assets/Audio/Ululu.mp3");
			if (newLootbugSFX == null || (Object)(object)newFlowermanAngerSFX == (Object)null)
			{
				logger.LogError((object)"Failed loading audioclip");
			}
			logger.LogInfo((object)"Sounds were Loaded");
		}

		internal static void CreateCommands()
		{
		}
	}
}
namespace LootbugTest.patches
{
	[HarmonyPatch(typeof(FlowermanAI))]
	internal class FlowermanPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPatch(FlowermanAI __instance)
		{
			AudioClip newSFX = LootbugTest.newFlowermanAngerSFX;
			Task.Delay(1000).ContinueWith(delegate
			{
				__instance.creatureAngerVoice.clip = newSFX;
				LootbugTest.logger.LogInfo((object)"flowerman was patched");
			});
		}

		[HarmonyPatch("LookAtPlayerOfInterest")]
		[HarmonyPrefix]
		private static void InstantAnger(FlowermanAI __instance)
		{
			((EnemyAI)__instance).currentBehaviourStateIndex = 2;
			LootbugTest.logger.LogInfo((object)"flowerman was angered");
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void AddToPrefabs(ref GameNetworkManager __instance)
		{
			((Component)__instance).GetComponent<NetworkManager>().AddNetworkPrefab(LootbugTest.Instance.netManagerPrefab);
		}
	}
	[HarmonyPatch(typeof(HoarderBugAI))]
	internal class HoarderBugPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void hoarderBugAudioPatch(HoarderBugAI __instance)
		{
			AudioClip[] newSFX = LootbugTest.newLootbugSFX;
			Task.Delay(10000).ContinueWith(delegate
			{
				__instance.chitterSFX = newSFX;
			});
			LootbugTest.logger.LogInfo((object)"Lootbug was patched");
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void sprintPatch(PlayerControllerB __instance)
		{
			__instance.sprintMeter = 1f;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void spawnNetManager(StartOfRound __instance)
		{
			LootbugTest.logger.LogInfo((object)"Patching start of a round");
			if (((NetworkBehaviour)__instance).IsHost)
			{
				GameObject val = Object.Instantiate<GameObject>(LootbugTest.Instance.netManagerPrefab);
				val.GetComponent<NetworkObject>().Spawn(false);
			}
		}
	}
}
namespace LootbugTest.managers
{
	public class CustomNetworkManager : NetworkBehaviour
	{
		public static CustomNetworkManager Instance;

		public static bool isWeak;

		public static bool isImmortal;

		public static bool isBunnyMode;

		public static int oldHealth;

		private void Awake()
		{
			Instance = this;
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlayerCrouchedServerRpc(ulong id)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3065379250u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, id);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3065379250u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					LootbugTest.logger.LogInfo((object)"called PlayerCrouchedServerRpc");
					PlayerCrouchedClientRpc(id);
				}
			}
		}

		[ClientRpc]
		public void PlayerCrouchedClientRpc(ulong id)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4027485125u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4027485125u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				LootbugTest.logger.LogInfo((object)"called PlayerCrouchedClientRpc");
				PlayerControllerB component = StartOfRound.Instance.allPlayerObjects[id].GetComponent<PlayerControllerB>();
				string playerUsername = component.playerUsername;
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				LootbugTest.logger.LogInfo((object)("Caller id: " + component.playerClientId + " Local id: " + localPlayerController.playerClientId));
				if (isWeak)
				{
					localPlayerController.jumpForce *= 2f;
				}
				else
				{
					localPlayerController.jumpForce /= 2f;
				}
				isWeak = !isWeak;
				LootbugTest.logger.LogInfo((object)("Callers SteamID" + component.playerSteamId));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlayerBunnyModeServerRpc(ulong id)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2450289791u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, id);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2450289791u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					PlayerBunnyModeClientRpc(id);
				}
			}
		}

		[ClientRpc]
		public void PlayerBunnyModeClientRpc(ulong id)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1891911518u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1891911518u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				PlayerControllerB component = StartOfRound.Instance.allPlayerObjects[id].GetComponent<PlayerControllerB>();
				string playerUsername = component.playerUsername;
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				LootbugTest.logger.LogInfo((object)("Caller id: " + component.playerClientId + " Local id: " + localPlayerController.playerClientId));
				if (!isBunnyMode)
				{
					localPlayerController.jumpForce *= 10f;
				}
				else
				{
					localPlayerController.jumpForce /= 10f;
				}
				isBunnyMode = !isBunnyMode;
				LootbugTest.logger.LogInfo((object)("Callers SteamID" + component.playerSteamId));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlayerSoftBootsServerRpc(ulong id)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1466130292u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, id);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1466130292u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					PlayerSoftBootsClientRpc(id);
				}
			}
		}

		[ClientRpc]
		public void PlayerSoftBootsClientRpc(ulong id)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(683044615u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 683044615u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				PlayerControllerB component = StartOfRound.Instance.allPlayerObjects[id].GetComponent<PlayerControllerB>();
				string playerUsername = component.playerUsername;
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				LootbugTest.logger.LogInfo((object)("Caller id: " + component.playerClientId + " Local id: " + localPlayerController.playerClientId));
				if (isImmortal)
				{
					oldHealth = localPlayerController.health;
					localPlayerController.health = 99999;
				}
				else
				{
					localPlayerController.health = oldHealth;
				}
				isImmortal = !isImmortal;
			}
		}

		public bool isAdmin(PlayerControllerB player)
		{
			return player.playerSteamId == 76561198076123228L;
		}

		public void ToggleWeakLegs()
		{
			LootbugTest.logger.LogInfo((object)"called ToggleWeakLegs");
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			ulong playerClientId = localPlayerController.playerClientId;
			bool flag = ((NetworkBehaviour)StartOfRound.Instance).IsHost || ((NetworkBehaviour)StartOfRound.Instance).IsServer;
			if (flag || isAdmin(localPlayerController))
			{
				HUDManager.Instance.DisplayTip("Toggling jump force", isWeak ? "Back to normal" : "Weak legs", false, false, "LC_Tip1");
				if (flag)
				{
					PlayerCrouchedServerRpc(playerClientId);
				}
				else if (isAdmin(localPlayerController))
				{
					PlayerCrouchedClientRpc(playerClientId);
				}
			}
		}

		public void ToggleBunnyMode()
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			ulong playerClientId = localPlayerController.playerClientId;
			bool flag = ((NetworkBehaviour)StartOfRound.Instance).IsHost || ((NetworkBehaviour)StartOfRound.Instance).IsServer;
			if (flag || isAdmin(localPlayerController))
			{
				HUDManager.Instance.DisplayTip("Toggling bunny mode", isBunnyMode ? "Off" : "On", false, false, "LC_Tip1");
				if (flag)
				{
					PlayerBunnyModeServerRpc(playerClientId);
				}
				else if (isAdmin(localPlayerController))
				{
					PlayerBunnyModeClientRpc(playerClientId);
				}
			}
		}

		public void ToggleSoftBoots()
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			ulong playerClientId = localPlayerController.playerClientId;
			bool flag = ((NetworkBehaviour)StartOfRound.Instance).IsHost || ((NetworkBehaviour)StartOfRound.Instance).IsServer;
			if (flag || isAdmin(localPlayerController))
			{
				HUDManager.Instance.DisplayTip("<broken> Toggling soft boots", isImmortal ? "Off" : "On", false, false, "LC_Tip1");
				if (flag)
				{
					PlayerSoftBootsServerRpc(playerClientId);
				}
				else if (isAdmin(localPlayerController))
				{
					PlayerSoftBootsClientRpc(playerClientId);
				}
			}
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_CustomNetworkManager()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(3065379250u, new RpcReceiveHandler(__rpc_handler_3065379250));
			NetworkManager.__rpc_func_table.Add(4027485125u, new RpcReceiveHandler(__rpc_handler_4027485125));
			NetworkManager.__rpc_func_table.Add(2450289791u, new RpcReceiveHandler(__rpc_handler_2450289791));
			NetworkManager.__rpc_func_table.Add(1891911518u, new RpcReceiveHandler(__rpc_handler_1891911518));
			NetworkManager.__rpc_func_table.Add(1466130292u, new RpcReceiveHandler(__rpc_handler_1466130292));
			NetworkManager.__rpc_func_table.Add(683044615u, new RpcReceiveHandler(__rpc_handler_683044615));
		}

		private static void __rpc_handler_3065379250(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 id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CustomNetworkManager)(object)target).PlayerCrouchedServerRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4027485125(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 id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((CustomNetworkManager)(object)target).PlayerCrouchedClientRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2450289791(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 id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CustomNetworkManager)(object)target).PlayerBunnyModeServerRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1891911518(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 id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((CustomNetworkManager)(object)target).PlayerBunnyModeClientRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1466130292(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 id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((CustomNetworkManager)(object)target).PlayerSoftBootsServerRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_683044615(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 id = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((CustomNetworkManager)(object)target).PlayerSoftBootsClientRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "CustomNetworkManager";
		}
	}
}
namespace LootbugTest.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}