using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using IL;
using IL.GameNetcodeStuff;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace bunny;

[BepInPlugin("4902.No_Console_Spam", "No_Console_Spam", "1.0.0")]
public class no_console_spam : BaseUnityPlugin
{
	private static ConfigEntry<bool> yeet;

	private static ConfigEntry<uint>[] cfg = new ConfigEntry<uint>[35];

	private static ConfigEntry<string> cdlist;

	private static uint cd_01;

	private static uint cd_02;

	private static uint cd_03;

	private static uint cd_04;

	private static uint cd_05;

	private static uint cd_06;

	private static uint cd_07;

	private static uint cd_08;

	private static uint cd_09;

	private static uint cd_10;

	private static uint cd_11;

	private static uint cd_12;

	private static uint cd_13;

	private static uint cd_14;

	private static uint cd_15;

	private static uint cd_16;

	private static uint cd_17;

	private static uint cd_18;

	private static uint cd_19;

	private static uint cd_20;

	private static uint cd_21;

	private static uint cd_22;

	private static uint cd_23;

	private static uint cd_24;

	private static uint cd_25;

	private static uint cd_26;

	private static uint cd_27;

	private static uint cd_28;

	private static uint cd_29;

	private static uint cd_30;

	private static uint cd_31;

	private static uint cd_32;

	private static uint cd_33;

	private static uint cd_34;

	public static int _1;

	public static int _2;

	public static int[] _3 = new int[2];

	public static int _4;

	public static int[] _5 = new int[4];

	public static int _6;

	public static int[] _7 = new int[2];

	public static int[] _8 = new int[2];

	public static int _9;

	public static int[] _10 = new int[7];

	public static int _11;

	public static int[] _12 = new int[9];

	public static int[] _13 = new int[9];

	public static int _14;

	public static int[] _15 = new int[6];

	public static int[] _16 = new int[2];

	public static int[] _17 = new int[2];

	public static int _18;

	public static int[] _19 = new int[5];

	public static int _20;

	public static int[] _21 = new int[3];

	public static int[] _22 = new int[15];

	public static int[] _23 = new int[11];

	public static int[] _24 = new int[2];

	public static int[] _25 = new int[6];

	public static int _26;

	public static int _27;

	public static int _28;

	public static int _29;

	public static int _30;

	public static int _31;

	public static int[] _32 = new int[4];

	public static int[] _33 = new int[2];

	public static int _34;

	private void Awake()
	{
		//IL_096a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0974: Expected O, but got Unknown
		//IL_0997: Unknown result type (might be due to invalid IL or missing references)
		//IL_09a1: Expected O, but got Unknown
		//IL_09c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_09ce: Expected O, but got Unknown
		//IL_0a0c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a16: Expected O, but got Unknown
		//IL_0a11: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a39: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a43: Expected O, but got Unknown
		//IL_0a66: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a70: Expected O, but got Unknown
		//IL_0a93: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a9d: Expected O, but got Unknown
		//IL_0ac0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0aca: Expected O, but got Unknown
		//IL_0aed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0af7: Expected O, but got Unknown
		//IL_0b1a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b24: Expected O, but got Unknown
		//IL_0b47: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b51: Expected O, but got Unknown
		//IL_0b90: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b9a: Expected O, but got Unknown
		//IL_0b95: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ba2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bac: Expected O, but got Unknown
		//IL_0bb4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bbe: Expected O, but got Unknown
		//IL_0be3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bed: Expected O, but got Unknown
		//IL_0bf5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bff: Expected O, but got Unknown
		//IL_0c07: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c11: Expected O, but got Unknown
		//IL_0c35: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c3f: Expected O, but got Unknown
		//IL_0c63: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c6d: Expected O, but got Unknown
		//IL_0c75: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c7f: Expected O, but got Unknown
		//IL_0c87: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c91: Expected O, but got Unknown
		//IL_0c99: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ca3: Expected O, but got Unknown
		//IL_0cc7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cd1: Expected O, but got Unknown
		//IL_0cf4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cfe: Expected O, but got Unknown
		//IL_0d21: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d2b: Expected O, but got Unknown
		//IL_0d4f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d59: Expected O, but got Unknown
		//IL_0d61: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d6b: Expected O, but got Unknown
		//IL_0d8f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d99: Expected O, but got Unknown
		//IL_0dbc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0dc6: Expected O, but got Unknown
		//IL_0dea: Unknown result type (might be due to invalid IL or missing references)
		//IL_0df4: Expected O, but got Unknown
		//IL_0dfc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e06: Expected O, but got Unknown
		//IL_0e2b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e35: Expected O, but got Unknown
		//IL_0e3d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e47: Expected O, but got Unknown
		//IL_0e6b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e75: Expected O, but got Unknown
		//IL_0e99: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ea3: Expected O, but got Unknown
		//IL_0eab: Unknown result type (might be due to invalid IL or missing references)
		//IL_0eb5: Expected O, but got Unknown
		//IL_0ed9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ee3: Expected O, but got Unknown
		//IL_0f06: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f10: Expected O, but got Unknown
		//IL_0f4e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f58: Expected O, but got Unknown
		//IL_0f53: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f7b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f85: Expected O, but got Unknown
		//IL_0fa8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0fb2: Expected O, but got Unknown
		//IL_0fd5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0fdf: Expected O, but got Unknown
		//IL_1002: Unknown result type (might be due to invalid IL or missing references)
		//IL_100c: Expected O, but got Unknown
		//IL_102f: Unknown result type (might be due to invalid IL or missing references)
		//IL_1039: Expected O, but got Unknown
		//IL_105c: Unknown result type (might be due to invalid IL or missing references)
		//IL_1066: Expected O, but got Unknown
		string text = "number of frames this string should be on cooldown for after being logged. set to 0 to disable the string completely";
		string text2 = "number of frames these strings should be on cooldown for after being logged. set to 0 to disable the strings completely";
		yeet = ((BaseUnityPlugin)this).Config.Bind<bool>("#", "enabled", true, "whether this mod should be enabled or not\ndefault cooldown values are assuming 60 frames per second, with higher or lower fps you may want to adjust the values");
		cdlist = ((BaseUnityPlugin)this).Config.Bind<string>("#", "cd_list", "{01,02,03,04,05,06,07,08,09,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}", "if you want to disable individual cooldowns, or if you want to see a variable in a string that the original string would've had (like cd_04), you can disable the cooldown related to that string with this option, which will prevent the transpiler/il from modifying those cooldowns related strings and will be the same as vanilla. to remove a cooldown remove its number from this configs string");
		cfg[1] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "01_cooldown", 180u, "[average velocity]\n" + text + "\nconditions: while using the jetpack or while flower snakes are lifting the player\nfrequency: every frame\n(PlayerControllerB.Update)\n\"Average velocity: {0}\"");
		cd_01 = cfg[1].Value;
		cfg[2] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "02_cooldown", 480u, "[targetable a]\n" + text + "\nconditions: roughly when certain enemies check if the player is targetable while they're in the ship\nfrequency: every frame (per enemy)\n(EnemyAI.PlayerIsTargetable)\n\"Targetable A\"");
		cd_02 = cfg[2].Value;
		cfg[3] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "03_cooldown", 480u, "[set destination a/b]\n" + text2 + "\nconditions: roughly when an enemy sees a player and is going towards them\nfrequency: every frame (per enemy)\n(EnemyAI.Update)\n\"Set destination to target player A\"\n\"Set destination to target player B\"");
		cd_03 = cfg[3].Value;
		cfg[4] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "04_cooldown", 60u, "[level timer]\n" + text + "\nconditions: during the xp increase/decrease animation after the end of a round\nfrequency: every frame for a short duration\n(HUDManager.SetPlayerLevelSmoothly)\n\"Level up timer: {0}\"");
		cd_04 = cfg[4].Value;
		cfg[5] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "05_cooldown", 600u, "[fs 1-4]\n" + text2 + "\nconditions: flower snakes existing during a round\nfrequency: every few frames (per flower snake)\n(FlowerSnakeEnemy.DoAIInterval)\n\"FS 1\"\n\"FS 2\"\n\"FS 3\"\n\"FS 4\"");
		cd_05 = cfg[5].Value;
		cfg[6] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "06_cooldown", 180u, "[called teleport function]\n" + text + "\nconditions: anytime TeleportPlayer() is called, most notably while the player is waiting to be respawned while in orbit it will log every frame\nfrequency: either infrequently or every frame\n(PlayerControllerB.TeleportPlayer)\n\"Called teleport function on (player)\"");
		cd_06 = cfg[6].Value;
		cfg[7] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "07_cooldown", 60u, "[company desk timer]\n" + text2 + "\nconditions: while host and while the desk door is open\nfrequency: every frame for a short duration\n(DepositItemsDesk.Update)\n\"Desk: Waiting to grab the items on the desk; {0}\"\n\"Desk: no objects on counter, waiting with door open; {0}\"");
		cd_07 = cfg[7].Value;
		cfg[8] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "08_cooldown", 600u, "[shower]\n" + text2 + "\nconditions: while the shower is on and there is spray paint anywhere, and while the shower is on and spray paint is on a player\nfrequency: every frame\n(ShowerTrigger.Update)\n\"Shower is running with players inside!\"\n\"spray decal #{0} found as child of {1}\"");
		cd_08 = cfg[8].Value;
		cfg[9] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "09_cooldown", 180u, "[agent speed]\n" + text + "\nconditions: while a giant was chasing a player and then lost sight of the player\nfrequency: every frame for maybe a short duration\n(ForestGiantAI.Update)\n\"agent speed: {0}\"");
		cd_09 = cfg[9].Value;
		cfg[10] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "10_cooldown", 0u, "[secondary use a-g]\n" + text2 + "\nconditions: anytime the key that the item secondary use keybind is set to is pressed\nfrequency: up to 7 strings once per press\n(PlayerControllerB.ItemSecondaryUse_performed)\n\"secondary use A\"\n\"secondary use B\"\n\"secondary use C\"\n\"secondary use D\"\n\"secondary use E\"\n\"secondary use F\"\n\"secondary use G\"");
		cd_10 = cfg[10].Value;
		cfg[11] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "11_cooldown", 1u, "[player leave web]\n" + text + "\nconditions: when a player leaves a web or other stuff like going through an entrance\nfrequency: once per web, so with 10 webs it would log 10 lines in 1 frame. cooldown doesn't need to be anything above 1\n(SandSpiderWebTrap.PlayerLeaveWeb)\n\"Player leave web called\"");
		cd_11 = cfg[11].Value;
		cfg[12] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "12_cooldown", 240u, "[zapgun]\n" + text2 + "\nconditions: activating the zap gun and or zapping something\nfrequency: some strings (multiple times) on each activation and 1 string logged every frame while zapping something\n(PatcherTool.ScanGun)\n\"Scan A\"\n\"Scan B\"\n\"Got shockable transform name :\"\n\"Zap gun light off!!!\"\n(PatcherTool.GunMeetsConditionsToShock)\n\"Target position: {0}\"\n\"Gun not meeting conditions to zap; {0}; {1}; {2}\"\n(PatcherTool.ItemActivate)\n\"Stop shocking gun\"\n\"Start scanning gun\"\n\"Use patcher tool\"");
		cd_12 = cfg[12].Value;
		cfg[13] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "13_cooldown", 240u, "[walkie]\n" + text2 + "\nconditions: using the walkie\nfrequency: some strings on each activation\n(WalkieTalkie.SetLocalClientSpeaking)\n\"Set local client speaking on walkie talkie: {0}\"\n(WalkieTalkie.SendWalkieTalkieStartTransmissionSFX)\n\"Walkie talkie A\"\n\"Walkie talkie #{0} {1} B\"\n\"is walkie being used: {0}\"\n\"Walkie talkie #{0} {1} C\"\n(WalkieTalkie.PlayerIsHoldingAnotherWalkieTalkie)\n\"False A\"\n\"False B\"\n\"False C\"\n\"{0}\"");
		cd_13 = cfg[13].Value;
		cfg[14] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "14_cooldown", 300u, "[loud horn]\n" + text + "\nconditions: holding the cord\nfrequency: every frame\n(ShipAlarmCord.HoldCordDown)\n\"HOLD horn local client called\"");
		cd_14 = cfg[14].Value;
		cfg[15] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "15_cooldown", 480u, "[mouth dog]\n" + text2 + "\nconditions: dog hearing noise\nfrequency: some strings initially and 1 string logged maybe every frame if hearing continuous noise\n(MouthDogAI.DetectNoise)\n\"dog '{0}': Heard noise! Distance: {1} meters\"\n(MouthDogAI.EnrageDogOnLocalClient)\n\"Mouth dog targetPos 1: {0}; distanceToNoise: {1}\"\n\"Mouth dog targetPos 2: {0}\"\n\"Dog lastheardnoisePosition: {0}\"\n(MouthDogAI.ReactToOtherDogHowl)\n\"Setting lastHeardNoisePosition to {0}\"\n(MouthDogAI.EndLungeClientRpc)\n\"Ending lunge\"");
		cd_15 = cfg[15].Value;
		cfg[16] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "16_cooldown", 600u, "[behaviour state]\n" + text2 + "\nconditions: when an enemy changes behaviour state\nfrequency: not common per enemy, however since every enemy can log this it can end up being alot\n(EnemyAI.SwitchToBehaviourStateOnLocalClient)\n\"Current behaviour state: {0}\"\n\"CHANGING BEHAVIOUR STATE!!! to {0}\"");
		cd_16 = cfg[16].Value;
		cfg[17] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "17_cooldown", 180u, "[hoarder bug]\n" + text2 + "\nconditions: when a hoarder bug finds an item\nfrequency: every frame for maybe a short duration\n(HoarderBugAI.SetGoTowardsTargetObject)\n\": Setting target object and going towards it.\"\n\": i found an object but cannot reach it (or it has been taken by another bug):\"");
		cd_17 = cfg[17].Value;
		cfg[18] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "18_cooldown", 300u, "[random nav]\n" + text + "\nconditions: when some enemies search for a position on the map\nfrequency: usually low\n(RoundManager.GetRandomNavMeshPositionInRadius)\n\"Unable to get random nav mesh position in radius! Returning old pos\"");
		cd_18 = cfg[18].Value;
		cfg[19] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "19_cooldown", 480u, "[quicksand]\n" + text2 + "\nconditions: interacting with quicksand, can also be triggered by enemies\nfrequency: every frame for a short duration\n(QuicksandTrigger.OnTriggerStay)\n\"Set local player to sinking!\"\n(QuicksandTrigger.OnExit)\n\"Quicksand is not sinking local player!\"\n\"Quicksand is sinking local player!\"\n\"Quicksand is sinking local player! B\"\n\"Quicksand is sinking local player! C\"");
		cd_19 = cfg[19].Value;
		cfg[20] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "20_cooldown", 180u, "[not targetable]\n" + text + "\nconditions: player not being targetable while trying to be hit by an enemy (most commonly while invincable)\nfrequency: every frame for maybe a short duration\n(EnemyAI.MeetsStandardPlayerCollisionConditions)\n\"Player is not targetable\"");
		cd_20 = cfg[20].Value;
		cfg[21] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "21_cooldown", 300u, "[masked]\n" + text2 + "\nconditions: masked detecting noise\nfrequency: every few frames (per masked)\n(MaskedPlayerEnemy.DetectNoise)\n\"Noise heard relative loudness: {0}\"\n\"Can't hear noise reason A\"\n\"Can't hear noise reason B\"");
		cd_21 = cfg[21].Value;
		cfg[22] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "22_cooldown", 600u, "[fox]\n" + text2 + "\nconditions: fox existing during a round\nfrequency: every frame\n(BushWolfEnemy.Update)\n\"Fox spotted meter: {0}\"\n\"Fox A\"\n\"Fox B\"\n\"Fox C; {0}; {1}\"\n\"Fox D\"\n\"Fox E\"\n\"Fox F\"\n\"Fox G\"\n\"Fox H\"\n\"Fox I\"\n\"Fox J\"\n(BushWolfEnemy.GetBiggestWeedPatch)\n\"Bush wolf: No game objects found with spore tag; cancelling\"\n\"{0}: Mold spore {1} at {2} surrounded by {3}\"\n\"Bush wolf: Most surrounding spores is {0}\"\n\"Bush wolf: All spores found were lone spores; cancelling\"");
		cd_22 = cfg[22].Value;
		cfg[23] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "23_cooldown", 180u, "[bush]\n" + text2 + "\nconditions: using spray on bushes or loading a level\nfrequency: every frame for a short duration\n(MoldSpreadManager.DestroyMoldAtPosition)\n\"weeds found at pos {0}: {1}\"\n\"Index: {0}\"\n(MoldSpreadManager.GenerateMold)\n\"Mold iteration {0}\"\n\"Spore duplication count: {0}\"\n\"Mold #{0} of it#{1} pos: {2} ; {3}\"\n\"previousSpores[{0}]: pos {1}, marked {2}\"\n\"{0}; {1}; too close?: {2}\"\n\"Spore #{0} of iteration #{1} marked for deletion; \\n found spore position?: {2}; \\n stemmed from destroyed spore?: {3}; \\n too close to other?: {4}\"\n\"Added spore\"\n\"Growing back mold at index {0}\"");
		cd_23 = cfg[23].Value;
		cfg[24] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "24_cooldown", 0u, "[hold interact]\n" + text2 + "\nconditions: interacting with any hold interact\nfrequency: every frame\n(InteractTrigger.HoldInteractNotFilled)\n\"{0}; {1}\"\n\"Set on interact early\"");
		cd_24 = cfg[24].Value;
		cfg[25] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "25_cooldown", 180u, "[truck]\n" + text2 + "\nconditions: spawning truck, using magnet, collecting items with the truck, collide audio playing\nfrequency: some strings multiple times\n(VehicleController.CollectItemsInTruck)\n\"Collect items in truck A\"\n\"Collect items in truck B; {0}\"\n\"Collect items in truck C; {0}\"\n\"{0}; {1}; {2}\"\n\"Magneted? : {0}\"\n(VehicleController.PlayCollisionAudio)\n\"Play collision audio with type {0} A\"");
		cd_25 = cfg[25].Value;
		cfg[26] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "26_cooldown", 300u, "[ropes]\n" + text + "\nconditions: bought cruiser arriving\nfrequency: every frame for a short duration\n(ItemDropship.Update)\n\"Setting position of ropes\"");
		cd_26 = cfg[26].Value;
		cfg[27] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "27_cooldown", 480u, "[cavedweller]\n" + text + "\nconditions: cavedweller being near a player\nfrequency: every frame\n(CaveDwellerAI.BabyUpdate)\n\"Following player, like meter: {0}; decreasing loneliness by {1} * Time.deltaTime\"");
		cd_27 = cfg[27].Value;
		cfg[28] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "28_cooldown", 300u, "[grabinvalidated]\n" + text + "\nconditions: waiting for a grabbed item to be validated\nfrequency: depends on the connection, if laggy then can be every frame\n(PlayerControllerB.GrabObject)\n\"grabInvalidated: {0}\"");
		cd_28 = cfg[28].Value;
		cfg[29] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "29_cooldown", 600u, "[physics region]\n" + text + "\nconditions: being in cruiser and probably other stuff\nfrequency: every frame\n(PlayerPhysicsRegion.OnTriggerStay)\n\"Got player in physics region: {0}\"");
		cd_29 = cfg[29].Value;
		cfg[30] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "30_cooldown", 0u, "[item meshes]\n" + text + "\nconditions: picking up or dropping certain items\nfrequency: once each time\n(GrabbableObject.EnableItemMeshes)\n\"DISABLING/ENABLING SKINNEDMESH:\"");
		cd_30 = cfg[30].Value;
		cfg[31] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "31_cooldown", 600u, "[weedkiller]\n" + text + "\nconditions: spraying weed killer\nfrequency: every frame\n(SprayPaintItem)\n\"Spraying, depleting tank\"");
		cd_31 = cfg[31].Value;
		cfg[32] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "32_cooldown", 600u, "[spraypaint]\n" + text2 + "\nconditions: spraying spray paint or weed killer\nfrequency: two lines each activation\n(SprayPaintItem)\n\"Start using spray\"\n\"Spray empty\"\n\"Spray not empty\"\n\"Stop using spray\"");
		cd_32 = cfg[32].Value;
		cfg[33] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "33_cooldown", 480u, "[flashlight]\n" + text2 + "\nconditions: another player using a flashlight\nfrequency: two lines each activation\n(FlashlightItem)\n\"Flashlight click. playerheldby null?: {0}\"\n\"Flashlight being disabled or enabled: {0}\"");
		cd_33 = cfg[33].Value;
		cfg[34] = ((BaseUnityPlugin)this).Config.Bind<uint>("#", "34_cooldown", 480u, "[item being used]\n" + text + "\nconditions: another player using an item\nfrequency: one line each activation\n(GrabbableObject)\n\"Is being used set to {0} by RPC\"");
		cd_34 = cfg[34].Value;
		if (yeet.Value)
		{
			if (cdlist.Value.Contains("01"))
			{
				PlayerControllerB.Update += new Manipulator(pcb_update);
			}
			if (cdlist.Value.Contains("02"))
			{
				EnemyAI.PlayerIsTargetable += new Manipulator(enemy_target);
			}
			if (cdlist.Value.Contains("03"))
			{
				EnemyAI.Update += new Manipulator(enemy_update);
			}
			if (cdlist.Value.Contains("04"))
			{
				new ILHook((MethodBase)Extensions.GetStateMachineTarget(typeof(HUDManager).GetMethod("SetPlayerLevelSmoothly", BindingFlags.Instance | BindingFlags.NonPublic)), new Manipulator(level));
			}
			if (cdlist.Value.Contains("05"))
			{
				FlowerSnakeEnemy.DoAIInterval += new Manipulator(snake);
			}
			if (cdlist.Value.Contains("06"))
			{
				PlayerControllerB.TeleportPlayer += new Manipulator(pcb_teleport);
			}
			if (cdlist.Value.Contains("07"))
			{
				DepositItemsDesk.Update += new Manipulator(desk);
			}
			if (cdlist.Value.Contains("08"))
			{
				ShowerTrigger.Update += new Manipulator(shower);
			}
			if (cdlist.Value.Contains("09"))
			{
				ForestGiantAI.Update += new Manipulator(giant);
			}
			if (cdlist.Value.Contains("10"))
			{
				PlayerControllerB.ItemSecondaryUse_performed += new Manipulator(pcb_secondary);
			}
			if (cdlist.Value.Contains("11"))
			{
				SandSpiderWebTrap.PlayerLeaveWeb += new Manipulator(spider);
			}
			if (cdlist.Value.Contains("12"))
			{
				new ILHook((MethodBase)Extensions.GetStateMachineTarget(typeof(PatcherTool).GetMethod("ScanGun", BindingFlags.Instance | BindingFlags.NonPublic)), new Manipulator(patch_1));
				PatcherTool.GunMeetsConditionsToShock += new Manipulator(patch_2);
				PatcherTool.ItemActivate += new Manipulator(patch_3);
			}
			if (cdlist.Value.Contains("13"))
			{
				WalkieTalkie.SetLocalClientSpeaking += new Manipulator(radio_1);
				WalkieTalkie.SendWalkieTalkieStartTransmissionSFX += new Manipulator(radio_2);
				WalkieTalkie.PlayerIsHoldingAnotherWalkieTalkie += new Manipulator(radio_3);
			}
			if (cdlist.Value.Contains("14"))
			{
				ShipAlarmCord.HoldCordDown += new Manipulator(cord);
			}
			if (cdlist.Value.Contains("15"))
			{
				MouthDogAI.DetectNoise += new Manipulator(dog_1);
				MouthDogAI.EnrageDogOnLocalClient += new Manipulator(dog_2);
				MouthDogAI.ReactToOtherDogHowl += new Manipulator(dog_3);
				MouthDogAI.EndLungeClientRpc += new Manipulator(dog_4);
			}
			if (cdlist.Value.Contains("16"))
			{
				EnemyAI.SwitchToBehaviourStateOnLocalClient += new Manipulator(enemy_behaviour);
			}
			if (cdlist.Value.Contains("17"))
			{
				HoarderBugAI.SetGoTowardsTargetObject += new Manipulator(hoarder);
			}
			if (cdlist.Value.Contains("18"))
			{
				RoundManager.GetRandomNavMeshPositionInRadius += new Manipulator(random);
			}
			if (cdlist.Value.Contains("19"))
			{
				QuicksandTrigger.OnTriggerStay += new Manipulator(sand_1);
				QuicksandTrigger.OnExit += new Manipulator(sand_2);
			}
			if (cdlist.Value.Contains("20"))
			{
				EnemyAI.MeetsStandardPlayerCollisionConditions += new Manipulator(enemy_not_targetable);
			}
			if (cdlist.Value.Contains("21"))
			{
				MaskedPlayerEnemy.DetectNoise += new Manipulator(masked);
			}
			if (cdlist.Value.Contains("22"))
			{
				BushWolfEnemy.Update += new Manipulator(bushwolf_update);
				BushWolfEnemy.GetBiggestWeedPatch += new Manipulator(bushwolf_big);
			}
			if (cdlist.Value.Contains("23"))
			{
				MoldSpreadManager.DestroyMoldAtPosition += new Manipulator(bush_destroy);
				MoldSpreadManager.GenerateMold += new Manipulator(bush_generate);
			}
			if (cdlist.Value.Contains("24"))
			{
				InteractTrigger.HoldInteractNotFilled += new Manipulator(hold_interact);
			}
			if (cdlist.Value.Contains("25"))
			{
				VehicleController.CollectItemsInTruck += new Manipulator(truck_collect);
				VehicleController.PlayCollisionAudio += new Manipulator(truck_audio);
			}
			if (cdlist.Value.Contains("26"))
			{
				ItemDropship.Update += new Manipulator(ropes);
			}
			if (cdlist.Value.Contains("27"))
			{
				CaveDwellerAI.BabyUpdate += new Manipulator(cavedweller);
			}
			if (cdlist.Value.Contains("28"))
			{
				new ILHook((MethodBase)Extensions.GetStateMachineTarget(typeof(PlayerControllerB).GetMethod("GrabObject", BindingFlags.Instance | BindingFlags.NonPublic)), new Manipulator(grab));
			}
			if (cdlist.Value.Contains("29"))
			{
				PlayerPhysicsRegion.OnTriggerStay += new Manipulator(physics);
			}
			if (cdlist.Value.Contains("30"))
			{
				GrabbableObject.EnableItemMeshes += new Manipulator(item_meshes);
			}
			if (cdlist.Value.Contains("31"))
			{
				SprayPaintItem.LateUpdate += new Manipulator(spray_1);
			}
			if (cdlist.Value.Contains("32"))
			{
				SprayPaintItem.ItemActivate += new Manipulator(spray_2);
			}
			if (cdlist.Value.Contains("33"))
			{
				FlashlightItem.SwitchFlashlight += new Manipulator(flashlight);
			}
			if (cdlist.Value.Contains("34"))
			{
				GrabbableObject.ActivateItemClientRpc += new Manipulator(item_used);
			}
		}
	}

	private static void pcb_update(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Average velocity: {0}"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 6; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_01 == 0)
			{
				continue;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Action<PlayerControllerB>>((Action<PlayerControllerB>)delegate(PlayerControllerB self)
			{
				if (Time.frameCount - _1 >= cd_01)
				{
					_1 = Time.frameCount;
					Debug.Log((object)("Average velocity: " + self.averageVelocity + " [NCS:" + cd_01 + "-" + _1 + "]"));
				}
			});
			break;
		}
	}

	private static void enemy_target(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Targetable A"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 2; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_02 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _2 >= cd_02)
				{
					_2 = Time.frameCount;
					Debug.Log((object)("Targetable A [NCS:" + cd_02 + "-" + _2 + "]"));
				}
			});
			break;
		}
	}

	private static void enemy_update(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0079: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Set destination to target player A")
			{
				val.Index = i;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_03 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _3[0] >= cd_03)
					{
						_3[0] = Time.frameCount;
						Debug.Log((object)("Set destination to target player A [NCS:" + cd_03 + "-" + _3[0] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Set destination to target player B"))
				{
					continue;
				}
				val.Index = i;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_03 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _3[1] >= cd_03)
					{
						_3[1] = Time.frameCount;
						Debug.Log((object)("Set destination to target player B [NCS:" + cd_03 + "-" + _3[1] + "]"));
					}
				});
			}
		}
	}

	private static void level(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0075: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Level up timer: {0}"))
			{
				continue;
			}
			val.Index = i + 8;
			for (int j = 0; j < 8; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_04 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _4 >= cd_04)
				{
					_4 = Time.frameCount;
					Debug.Log((object)("Level up timer: (timer) [NCS:" + cd_04 + "-" + _4 + "]"));
				}
			});
			break;
		}
	}

	private static void snake(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "FS 1")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_05 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _5[0] >= cd_05)
					{
						_5[0] = Time.frameCount;
						Debug.Log((object)("FS 1 [NCS:" + cd_05 + "-" + _5[0] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "FS 2")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_05 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _5[1] >= cd_05)
					{
						_5[1] = Time.frameCount;
						Debug.Log((object)("FS 2 [NCS:" + cd_05 + "-" + _5[1] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "FS 3")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_05 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _5[2] >= cd_05)
					{
						_5[2] = Time.frameCount;
						Debug.Log((object)("FS 3 [NCS:" + cd_05 + "-" + _5[2] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "FS 4"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_05 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _5[3] >= cd_05)
					{
						_5[3] = Time.frameCount;
						Debug.Log((object)("FS 4 [NCS:" + cd_05 + "-" + _5[3] + "]"));
					}
				});
			}
		}
	}

	private static void pcb_teleport(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Called teleport function on "))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 6; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_06 == 0)
			{
				continue;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Action<PlayerControllerB>>((Action<PlayerControllerB>)delegate(PlayerControllerB self)
			{
				if (Time.frameCount - _6 >= cd_06)
				{
					_6 = Time.frameCount;
					Debug.Log((object)("Called teleport function on " + ((Object)((Component)self).gameObject).name + " [NCS:" + cd_06 + "-" + _6 + "]"));
				}
			});
			break;
		}
	}

	private static void desk(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007c: 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_00a8: 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_016f: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Desk: Waiting to grab the items on the desk; {0}")
			{
				val.Index = i;
				for (int j = 0; j < 6; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_07 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, typeof(DepositItemsDesk).GetField("grabObjectsTimer", BindingFlags.Instance | BindingFlags.NonPublic));
				val.EmitDelegate<Action<float>>((Action<float>)delegate(float timer)
				{
					if (Time.frameCount - _7[0] >= cd_07)
					{
						_7[0] = Time.frameCount;
						Debug.Log((object)("Desk: Waiting to grab the items on the desk; " + timer + " [NCS:" + cd_07 + "-" + _7[0] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Desk: no objects on counter, waiting with door open; {0}"))
				{
					continue;
				}
				val.Index = i;
				for (int j = 0; j < 6; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_07 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, typeof(DepositItemsDesk).GetField("waitingWithDoorOpenTimer", BindingFlags.Instance | BindingFlags.NonPublic));
				val.EmitDelegate<Action<float>>((Action<float>)delegate(float timer)
				{
					if (Time.frameCount - _7[1] >= cd_07)
					{
						_7[1] = Time.frameCount;
						Debug.Log((object)("Desk: no objects on counter, waiting with door open; " + timer + " [NCS:" + cd_07 + "-" + _7[1] + "]"));
					}
				});
			}
		}
	}

	private static void shower(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_0144: 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_0172: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Shower is running with players inside!")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_08 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _8[0] >= cd_08)
					{
						_8[0] = Time.frameCount;
						Debug.Log((object)("Shower is running with players inside! [NCS:" + cd_08 + "-" + _8[0] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "spray decal #{0} found as child of {1}"))
				{
					continue;
				}
				val.Index = i;
				for (int j = 0; j < 11; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_08 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, typeof(ShowerTrigger).GetField("cleanDecalIndex", BindingFlags.Instance | BindingFlags.NonPublic));
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, typeof(ShowerTrigger).GetField("playersInShower", BindingFlags.Instance | BindingFlags.NonPublic));
				val.Emit(OpCodes.Ldloc_1);
				val.EmitDelegate<Action<int, List<PlayerControllerB>, int>>((Action<int, List<PlayerControllerB>, int>)delegate(int num, List<PlayerControllerB> players, int index)
				{
					if (Time.frameCount - _8[1] >= cd_08)
					{
						_8[1] = Time.frameCount;
						Debug.Log((object)string.Concat("spray decal #", num, " found as child of ", players[index], " [NCS:", cd_08, "-", _8[1], "]"));
					}
				});
			}
		}
	}

	private static void giant(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "agent speed: {0}"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 7; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_09 == 0)
			{
				continue;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.EmitDelegate<Action<EnemyAI>>((Action<EnemyAI>)delegate(EnemyAI self)
			{
				if (Time.frameCount - _9 >= cd_09)
				{
					_9 = Time.frameCount;
					Debug.Log((object)("agent speed: " + self.agent.speed + " [NCS:" + cd_09 + "-" + _9 + "]"));
				}
			});
			break;
		}
	}

	private static void pcb_secondary(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: 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_0382: Unknown result type (might be due to invalid IL or missing references)
		//IL_041d: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "secondary use A")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_10 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _10[0] >= cd_10)
					{
						_10[0] = Time.frameCount;
						Debug.Log((object)("secondary use A [NCS:" + cd_10 + "-" + _10[0] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "secondary use B")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_10 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _10[1] >= cd_10)
					{
						_10[1] = Time.frameCount;
						Debug.Log((object)("secondary use B [NCS:" + cd_10 + "-" + _10[1] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "secondary use C")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_10 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _10[2] >= cd_10)
					{
						_10[2] = Time.frameCount;
						Debug.Log((object)("secondary use C [NCS:" + cd_10 + "-" + _10[2] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "secondary use D")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_10 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _10[3] >= cd_10)
					{
						_10[3] = Time.frameCount;
						Debug.Log((object)("secondary use D [NCS:" + cd_10 + "-" + _10[3] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "secondary use E")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_10 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _10[4] >= cd_10)
					{
						_10[4] = Time.frameCount;
						Debug.Log((object)("secondary use E [NCS:" + cd_10 + "-" + _10[4] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "secondary use F")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_10 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _10[5] >= cd_10)
					{
						_10[5] = Time.frameCount;
						Debug.Log((object)("secondary use F [NCS:" + cd_10 + "-" + _10[5] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "secondary use G"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_10 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _10[6] >= cd_10)
					{
						_10[6] = Time.frameCount;
						Debug.Log((object)("secondary use G [NCS:" + cd_10 + "-" + _10[6] + "]"));
					}
				});
			}
		}
	}

	private static void spider(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Player leave web called"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 2; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_11 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _11 >= cd_11)
				{
					_11 = Time.frameCount;
					Debug.Log((object)("Player leave web called [NCS:" + cd_11 + "-" + _11 + "]"));
				}
			});
			break;
		}
	}

	private static void patch_1(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_0256: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Scan A")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _12[0] >= cd_12)
					{
						_12[0] = Time.frameCount;
						Debug.Log((object)("Scan A [NCS:" + cd_12 + "-" + _12[0] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Scan B")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _12[1] >= cd_12)
					{
						_12[1] = Time.frameCount;
						Debug.Log((object)("Scan B [NCS:" + cd_12 + "-" + _12[1] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Got shockable transform name : ")
			{
				val.Index = i + 7;
				for (int j = 0; j < 7; j++)
				{
					if (j != 1)
					{
						l.Instrs[i + j].OpCode = OpCodes.Nop;
					}
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action<IShockableWithGun>>((Action<IShockableWithGun>)delegate(IShockableWithGun component)
				{
					if (Time.frameCount - _12[2] >= cd_12)
					{
						_12[2] = Time.frameCount;
						Debug.Log((object)("Got shockable transform name : " + ((Object)((Component)component.GetShockableTransform()).gameObject).name + " [NCS:" + cd_12 + "-" + _12[2] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Zap gun light off!!!"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _12[3] >= cd_12)
					{
						_12[3] = Time.frameCount;
						Debug.Log((object)("Zap gun light off!!! [NCS:" + cd_12 + "-" + _12[3] + "]"));
					}
				});
			}
		}
	}

	private static void patch_2(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0079: 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_00a5: 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_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_0183: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Target position: {0}")
			{
				val.Index = i;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_2);
				val.EmitDelegate<Action<Vector3>>((Action<Vector3>)delegate(Vector3 position)
				{
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					if (Time.frameCount - _12[4] >= cd_12)
					{
						_12[4] = Time.frameCount;
						Debug.Log((object)string.Concat("Target position: ", position, " [NCS:", cd_12, "-", _12[4], "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Gun not meeting conditions to zap; {0}; {1}; {2}"))
				{
					continue;
				}
				val.Index = i;
				for (int j = 0; j < 21; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, typeof(PatcherTool).GetField("gunOverheat"));
				val.Emit(OpCodes.Ldloc_0);
				val.Emit(OpCodes.Ldarg_2);
				val.EmitDelegate<Action<float, Vector3, Vector3>>((Action<float, Vector3, Vector3>)delegate(float num, Vector3 position, Vector3 target_position)
				{
					//IL_0055: 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_0073: 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 (Time.frameCount - _12[5] >= cd_12)
					{
						_12[5] = Time.frameCount;
						Debug.Log((object)("Gun not meeting conditions to zap; " + (num > 2f) + "; " + (Vector3.Distance(position, target_position) < 0.7f) + "; " + Physics.Linecast(position, target_position, StartOfRound.Instance.collidersAndRoomMask, (QueryTriggerInteraction)1) + " [NCS:" + cd_12 + "-" + _12[5] + "]"));
					}
				});
			}
		}
	}

	private static void patch_3(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Stop shocking gun")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _12[6] >= cd_12)
					{
						_12[6] = Time.frameCount;
						Debug.Log((object)("Stop shocking gun [NCS:" + cd_12 + "-" + _12[6] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Start scanning gun")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _12[7] >= cd_12)
					{
						_12[7] = Time.frameCount;
						Debug.Log((object)("Start scanning gun [NCS:" + cd_12 + "-" + _12[7] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Use patcher tool"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_12 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _12[8] >= cd_12)
					{
						_12[8] = Time.frameCount;
						Debug.Log((object)("Use patcher tool [NCS:" + cd_12 + "-" + _12[8] + "]"));
					}
				});
			}
		}
	}

	private static void radio_1(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Set local client speaking on walkie talkie: {0}"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 5; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_13 == 0)
			{
				continue;
			}
			val.Emit(OpCodes.Ldarg_1);
			val.EmitDelegate<Action<bool>>((Action<bool>)delegate(bool bol)
			{
				if (Time.frameCount - _13[0] >= cd_13)
				{
					_13[0] = Time.frameCount;
					Debug.Log((object)("Set local client speaking on walkie talkie: " + bol + " [NCS:" + cd_13 + "-" + _13[0] + "]"));
				}
			});
			break;
		}
	}

	private static void radio_2(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_01e5: 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_0167: 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_0211: 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)
		//IL_02da: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Walkie talkie A")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _13[1] >= cd_13)
					{
						_13[1] = Time.frameCount;
						Debug.Log((object)("Walkie talkie A [NCS:" + cd_13 + "-" + _13[1] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Walkie talkie #{0} {1} B")
			{
				val.Index = i + 10;
				for (int j = 0; j < 10; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldsfld, typeof(WalkieTalkie).GetField("allWalkieTalkies"));
				val.Emit(OpCodes.Ldloc_0);
				val.EmitDelegate<Action<List<WalkieTalkie>, int>>((Action<List<WalkieTalkie>, int>)delegate(List<WalkieTalkie> list, int index)
				{
					if (Time.frameCount - _13[2] >= cd_13)
					{
						_13[2] = Time.frameCount;
						Debug.Log((object)("Walkie talkie #" + index + " " + ((Object)((Component)list[index]).gameObject).name + " B [NCS:" + cd_13 + "-" + _13[2] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "is walkie being used: {0}")
			{
				val.Index = i + 8;
				for (int j = 0; j < 8; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldsfld, typeof(WalkieTalkie).GetField("allWalkieTalkies"));
				val.Emit(OpCodes.Ldloc_0);
				val.EmitDelegate<Action<List<WalkieTalkie>, int>>((Action<List<WalkieTalkie>, int>)delegate(List<WalkieTalkie> list, int index)
				{
					if (Time.frameCount - _13[3] >= cd_13)
					{
						_13[3] = Time.frameCount;
						Debug.Log((object)("is walkie being used: " + ((GrabbableObject)list[index]).isBeingUsed + " [NCS:" + cd_13 + "-" + _13[3] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Walkie talkie #{0}  {1} C"))
				{
					continue;
				}
				val.Index = i + 10;
				for (int j = 0; j < 10; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldsfld, typeof(WalkieTalkie).GetField("allWalkieTalkies"));
				val.Emit(OpCodes.Ldloc_0);
				val.EmitDelegate<Action<List<WalkieTalkie>, int>>((Action<List<WalkieTalkie>, int>)delegate(List<WalkieTalkie> list, int index)
				{
					if (Time.frameCount - _13[4] >= cd_13)
					{
						_13[4] = Time.frameCount;
						Debug.Log((object)("Walkie talkie #" + index + " " + ((Object)((Component)list[index]).gameObject).name + " C [NCS:" + cd_13 + "-" + _13[4] + "]"));
					}
				});
			}
		}
	}

	private static void radio_3(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "False A")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _13[5] >= cd_13)
					{
						_13[5] = Time.frameCount;
						Debug.Log((object)("False A [NCS:" + cd_13 + "-" + _13[5] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "False B")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _13[6] >= cd_13)
					{
						_13[6] = Time.frameCount;
						Debug.Log((object)("False B [NCS:" + cd_13 + "-" + _13[6] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "False C")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _13[7] >= cd_13)
					{
						_13[7] = Time.frameCount;
						Debug.Log((object)("False C [NCS:" + cd_13 + "-" + _13[7] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "{0}"))
				{
					continue;
				}
				val.Index = i + 6;
				for (int j = 0; j < 6; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_13 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Action<WalkieTalkie>>((Action<WalkieTalkie>)delegate(WalkieTalkie self)
				{
					if (Time.frameCount - _13[8] >= cd_13)
					{
						_13[8] = Time.frameCount;
						Debug.Log((object)(((GrabbableObject)self).isPocketed + " [NCS:" + cd_13 + "-" + _13[8] + "]"));
					}
				});
			}
		}
	}

	private static void cord(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0075: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "HOLD horn local client called"))
			{
				continue;
			}
			val.Index = i + 2;
			for (int j = 0; j < 2; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_14 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _14 >= cd_14)
				{
					_14 = Time.frameCount;
					Debug.Log((object)("HOLD horn local client called [NCS:" + cd_14 + "-" + _14 + "]"));
				}
			});
			break;
		}
	}

	private static void dog_1(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0076: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "dog '{0}': Heard noise! Distance: {1} meters"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 8; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_15 == 0)
			{
				continue;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldloc_0);
			val.EmitDelegate<Action<MouthDogAI, float>>((Action<MouthDogAI, float>)delegate(MouthDogAI self, float num)
			{
				if (Time.frameCount - _15[0] >= cd_15)
				{
					_15[0] = Time.frameCount;
					Debug.Log((object)("dog '" + ((Object)((Component)self).gameObject).name + "': Heard noise! Distance: " + num + " meters [NCS:" + cd_15 + "-" + _15[0] + "]"));
				}
			});
			break;
		}
	}

	private static void dog_2(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007c: 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_00a8: 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_01d5: 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_01fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_020a: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Mouth dog targetPos 1: {0}; distanceToNoise: {1}")
			{
				val.Index = i;
				for (int j = 0; j < 7; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_15 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_1);
				val.Emit(OpCodes.Ldarg_2);
				val.EmitDelegate<Action<Vector3, float>>((Action<Vector3, float>)delegate(Vector3 position, float distance)
				{
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					if (Time.frameCount - _15[1] >= cd_15)
					{
						_15[1] = Time.frameCount;
						Debug.Log((object)string.Concat("Mouth dog targetPos 1: ", position, "; distanceToNoise: ", distance, " [NCS:", cd_15, "-", _15[1], "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Mouth dog targetPos 2: {0}")
			{
				val.Index = i;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_15 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Action<Vector3>>((Action<Vector3>)delegate(Vector3 position)
				{
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					if (Time.frameCount - _15[2] >= cd_15)
					{
						_15[2] = Time.frameCount;
						Debug.Log((object)string.Concat("Mouth dog targetPos 2: ", position, " [NCS:", cd_15, "-", _15[2], "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Dog lastheardnoisePosition: {0}"))
				{
					continue;
				}
				val.Index = i;
				for (int j = 0; j < 6; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_15 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldfld, typeof(MouthDogAI).GetField("lastHeardNoisePosition", BindingFlags.Instance | BindingFlags.NonPublic));
				val.EmitDelegate<Action<Vector3>>((Action<Vector3>)delegate(Vector3 position)
				{
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					if (Time.frameCount - _15[3] >= cd_15)
					{
						_15[3] = Time.frameCount;
						Debug.Log((object)string.Concat("Dog lastheardnoisePosition: ", position, " [NCS:", cd_15, "-", _15[3], "]"));
					}
				});
			}
		}
	}

	private static void dog_3(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Setting lastHeardNoisePosition to {0}"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 5; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_15 == 0)
			{
				continue;
			}
			val.Emit(OpCodes.Ldarg_1);
			val.EmitDelegate<Action<Vector3>>((Action<Vector3>)delegate(Vector3 position)
			{
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				if (Time.frameCount - _15[4] >= cd_15)
				{
					_15[4] = Time.frameCount;
					Debug.Log((object)string.Concat("Setting lastHeardNoisePosition to ", position, " [NCS:", cd_15, "-", _15[4], "]"));
				}
			});
			break;
		}
	}

	private static void dog_4(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0073: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Ending lunge"))
			{
				continue;
			}
			val.Index = i;
			for (int j = 0; j < 2; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_15 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _15[5] >= cd_15)
				{
					_15[5] = Time.frameCount;
					Debug.Log((object)("Ending lunge [NCS:" + cd_15 + "-" + _15[5] + "]"));
				}
			});
			break;
		}
	}

	private static void enemy_behaviour(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0079: 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_00a5: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Current behaviour state: {0}")
			{
				val.Index = i;
				for (int j = 0; j < 6; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_16 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Action<EnemyAI>>((Action<EnemyAI>)delegate(EnemyAI self)
				{
					if (Time.frameCount - _16[0] >= cd_16)
					{
						_16[0] = Time.frameCount;
						Debug.Log((object)("Current behaviour state: " + self.currentBehaviourStateIndex + " [NCS:" + cd_16 + "-" + _16[0] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "CHANGING BEHAVIOUR STATE!!! to {0}"))
				{
					continue;
				}
				val.Index = i + 5;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_16 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Action<int>>((Action<int>)delegate(int index)
				{
					if (Time.frameCount - _16[1] >= cd_16)
					{
						_16[1] = Time.frameCount;
						Debug.Log((object)("CHANGING BEHAVIOUR STATE!!! to " + index + " [NCS:" + cd_16 + "-" + _16[1] + "]"));
					}
				});
			}
		}
	}

	private static void hoarder(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0080: 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_00ac: 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_0161: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == ": Setting target object and going towards it.")
			{
				val.Index = i + 3;
				for (int j = 0; j < 6; j++)
				{
					l.Instrs[i - 3 + j].OpCode = OpCodes.Nop;
				}
				if (cd_17 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Action<HoarderBugAI>>((Action<HoarderBugAI>)delegate(HoarderBugAI self)
				{
					if (Time.frameCount - _17[0] >= cd_17)
					{
						_17[0] = Time.frameCount;
						Debug.Log((object)(((Object)((Component)self).gameObject).name + " : Setting target object and going towards it. [NCS:" + cd_17 + "-" + _17[0] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == ": i found an object but cannot reach it (or it has been taken by another bug): "))
				{
					continue;
				}
				val.Index = i + 5;
				for (int j = 0; j < 8; j++)
				{
					l.Instrs[i - 3 + j].OpCode = OpCodes.Nop;
				}
				if (cd_17 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Action<HoarderBugAI, GameObject>>((Action<HoarderBugAI, GameObject>)delegate(HoarderBugAI self, GameObject item)
				{
					if (Time.frameCount - _17[1] >= cd_17)
					{
						_17[1] = Time.frameCount;
						Debug.Log((object)(((Object)((Component)self).gameObject).name + " : i found an object but cannot reach it (or it has been taken by another bug): " + ((Object)item).name + " [NCS:" + cd_17 + "-" + _17[1] + "]"));
					}
				});
			}
		}
	}

	private static void random(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0075: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Unable to get random nav mesh position in radius! Returning old pos"))
			{
				continue;
			}
			val.Index = i + 2;
			for (int j = 0; j < 2; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_18 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _18 >= cd_18)
				{
					_18 = Time.frameCount;
					Debug.Log((object)("Unable to get random nav mesh position in radius! Returning old pos [NCS:" + cd_18 + "-" + _18 + "]"));
				}
			});
			break;
		}
	}

	private static void sand_1(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0075: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Set local player to sinking!"))
			{
				continue;
			}
			val.Index = i + 2;
			for (int j = 0; j < 2; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_19 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _19[0] >= cd_19)
				{
					_19[0] = Time.frameCount;
					Debug.Log((object)("Set local player to sinking! [NCS:" + cd_19 + "-" + _19[0] + "]"));
				}
			});
			break;
		}
	}

	private static void sand_2(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Quicksand is not sinking local player!")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_19 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _19[1] >= cd_19)
					{
						_19[1] = Time.frameCount;
						Debug.Log((object)("Quicksand is not sinking local player! [NCS:" + cd_19 + "-" + _19[1] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Quicksand is sinking local player!")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_19 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _19[2] >= cd_19)
					{
						_19[2] = Time.frameCount;
						Debug.Log((object)("Quicksand is sinking local player! [NCS:" + cd_19 + "-" + _19[2] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Quicksand is sinking local player! B")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_19 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _19[3] >= cd_19)
					{
						_19[3] = Time.frameCount;
						Debug.Log((object)("Quicksand is sinking local player! B [NCS:" + cd_19 + "-" + _19[3] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Quicksand is sinking local player! C"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_19 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _19[4] >= cd_19)
					{
						_19[4] = Time.frameCount;
						Debug.Log((object)("Quicksand is sinking local player! C [NCS:" + cd_19 + "-" + _19[4] + "]"));
					}
				});
			}
		}
	}

	private static void enemy_not_targetable(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_0075: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (!(l.Instrs[i].OpCode == OpCodes.Ldstr) || !(l.Instrs[i].Operand.ToString() == "Player is not targetable"))
			{
				continue;
			}
			val.Index = i + 2;
			for (int j = 0; j < 2; j++)
			{
				l.Instrs[i + j].OpCode = OpCodes.Nop;
			}
			if (cd_20 == 0)
			{
				continue;
			}
			val.EmitDelegate<Action>((Action)delegate
			{
				if (Time.frameCount - _20 >= cd_20)
				{
					_20 = Time.frameCount;
					Debug.Log((object)("Player is not targetable [NCS:" + cd_20 + "-" + _20 + "]"));
				}
			});
			break;
		}
	}

	private static void masked(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007e: 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_00aa: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Noise heard relative loudness: {0}")
			{
				val.Index = i + 5;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_21 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldloc_1);
				val.EmitDelegate<Action<float>>((Action<float>)delegate(float num)
				{
					if (Time.frameCount - _21[0] >= cd_21)
					{
						_21[0] = Time.frameCount;
						Debug.Log((object)("Noise heard relative loudness: " + num + " [NCS:" + cd_21 + "-" + _21[0] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Can't hear noise reason A")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_21 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _21[1] >= cd_21)
					{
						_21[1] = Time.frameCount;
						Debug.Log((object)("Can't hear noise reason A [NCS:" + cd_21 + "-" + _21[1] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Can't hear noise reason B"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_21 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _21[2] >= cd_21)
					{
						_21[2] = Time.frameCount;
						Debug.Log((object)("Can't hear noise reason B [NCS:" + cd_21 + "-" + _21[2] + "]"));
					}
				});
			}
		}
	}

	private static void bushwolf_update(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007e: 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_00aa: 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_025e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0315: 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_0298: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_044b: 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)
		//IL_0581: Unknown result type (might be due to invalid IL or missing references)
		//IL_061c: Unknown result type (might be due to invalid IL or missing references)
		//IL_06b7: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Fox spotted meter: {0}")
			{
				val.Index = i + 6;
				for (int j = 0; j < 6; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Action<BushWolfEnemy>>((Action<BushWolfEnemy>)delegate(BushWolfEnemy self)
				{
					if (Time.frameCount - _22[0] >= cd_22)
					{
						_22[0] = Time.frameCount;
						Debug.Log((object)("Fox spotted meter: " + self.spottedMeter + " [NCS:" + cd_22 + "-" + _22[0] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox A")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[1] >= cd_22)
					{
						_22[1] = Time.frameCount;
						Debug.Log((object)("Fox A [NCS:" + cd_22 + "-" + _22[1] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox B")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[2] >= cd_22)
					{
						_22[2] = Time.frameCount;
						Debug.Log((object)("Fox B [NCS:" + cd_22 + "-" + _22[2] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox C; {0}; {1}")
			{
				val.Index = i + 7;
				for (int j = 0; j < 7; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldloc, 14);
				val.Emit(OpCodes.Ldloc, 15);
				val.EmitDelegate<Action<float, float>>((Action<float, float>)delegate(float distance, float angle)
				{
					if (Time.frameCount - _22[3] >= cd_22)
					{
						_22[3] = Time.frameCount;
						Debug.Log((object)("Fox C; " + distance + "; " + angle + " [NCS:" + cd_22 + "-" + _22[3] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox D")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[4] >= cd_22)
					{
						_22[4] = Time.frameCount;
						Debug.Log((object)("Fox D [NCS:" + cd_22 + "-" + _22[4] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox E")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[5] >= cd_22)
					{
						_22[5] = Time.frameCount;
						Debug.Log((object)("Fox E [NCS:" + cd_22 + "-" + _22[5] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox F")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[6] >= cd_22)
					{
						_22[6] = Time.frameCount;
						Debug.Log((object)("Fox F [NCS:" + cd_22 + "-" + _22[6] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox G")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[7] >= cd_22)
					{
						_22[7] = Time.frameCount;
						Debug.Log((object)("Fox G [NCS:" + cd_22 + "-" + _22[7] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox H")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[8] >= cd_22)
					{
						_22[8] = Time.frameCount;
						Debug.Log((object)("Fox H [NCS:" + cd_22 + "-" + _22[8] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Fox I")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[9] >= cd_22)
					{
						_22[9] = Time.frameCount;
						Debug.Log((object)("Fox I [NCS:" + cd_22 + "-" + _22[9] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Fox J"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[10] >= cd_22)
					{
						_22[10] = Time.frameCount;
						Debug.Log((object)("Fox J [NCS:" + cd_22 + "-" + _22[10] + "]"));
					}
				});
			}
		}
	}

	private static void bushwolf_big(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007b: 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_01de: 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_0154: 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_0285: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Bush wolf: No game objects found with spore tag; cancelling")
			{
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[11] >= cd_22)
					{
						_22[11] = Time.frameCount;
						Debug.Log((object)("Bush wolf: No game objects found with spore tag; cancelling [NCS:" + cd_22 + "-" + _22[11] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "{0}: Mold spore {1} at {2} surrounded by {3}")
			{
				val.Index = i + 32;
				for (int j = 0; j < 32; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldloc, 6);
				val.Emit(OpCodes.Ldloc_0);
				val.Emit(OpCodes.Ldloc_3);
				val.EmitDelegate<Action<int, GameObject[], int>>((Action<int, GameObject[], int>)delegate(int index, GameObject[] objects, int num)
				{
					//IL_0068: Unknown result type (might be due to invalid IL or missing references)
					if (Time.frameCount - _22[12] >= cd_22)
					{
						_22[12] = Time.frameCount;
						Debug.Log((object)string.Concat(index, ": Mold spore ", ((Object)objects[index].gameObject).name, " at ", objects[index].transform.position, " surrounded by ", num, " [NCS:", cd_22, "-", _22[12], "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Bush wolf: Most surrounding spores is {0}")
			{
				val.Index = i + 5;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldloc_2);
				val.EmitDelegate<Action<int>>((Action<int>)delegate(int num)
				{
					if (Time.frameCount - _22[13] >= cd_22)
					{
						_22[13] = Time.frameCount;
						Debug.Log((object)("Bush wolf: Most surrounding spores is " + num + " [NCS:" + cd_22 + "-" + _22[13] + "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Bush wolf: All spores found were lone spores; cancelling"))
				{
					continue;
				}
				val.Index = i + 2;
				for (int j = 0; j < 2; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_22 == 0)
				{
					continue;
				}
				val.EmitDelegate<Action>((Action)delegate
				{
					if (Time.frameCount - _22[14] >= cd_22)
					{
						_22[14] = Time.frameCount;
						Debug.Log((object)("Bush wolf: All spores found were lone spores; cancelling [NCS:" + cd_22 + "-" + _22[14] + "]"));
					}
				});
			}
		}
	}

	private static void bush_destroy(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007e: 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_00aa: 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_015a: Unknown result type (might be due to invalid IL or missing references)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "weeds found at pos {0}: {1}")
			{
				val.Index = i + 7;
				for (int j = 0; j < 7; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_23 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldarg_1);
				val.Emit(OpCodes.Ldloc_0);
				val.EmitDelegate<Action<Vector3, int>>((Action<Vector3, int>)delegate(Vector3 position, int num)
				{
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					if (Time.frameCount - _23[0] >= cd_23)
					{
						_23[0] = Time.frameCount;
						Debug.Log((object)string.Concat("weeds found at pos ", position, ": ", num, " [NCS:", cd_23, "-", _23[0], "]"));
					}
				});
			}
			else
			{
				if (!(l.Instrs[i].Operand.ToString() == "Index: {0}"))
				{
					continue;
				}
				val.Index = i + 5;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_23 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldloc_2);
				val.EmitDelegate<Action<int>>((Action<int>)delegate(int num)
				{
					if (Time.frameCount - _23[1] >= cd_23)
					{
						_23[1] = Time.frameCount;
						Debug.Log((object)("Index: " + num + " [NCS:" + cd_23 + "-" + _23[1] + "]"));
					}
				});
			}
		}
	}

	private static void bush_generate(ILContext l)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Expected O, but got Unknown
		//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_007e: 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_00aa: 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_0156: 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_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0212: 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_022d: 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_02db: 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_042e: 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_03a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b1: 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_05ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_04fa: 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_0516: Unknown result type (might be due to invalid IL or missing references)
		//IL_0524: Unknown result type (might be due to invalid IL or missing references)
		//IL_0531: Unknown result type (might be due to invalid IL or missing references)
		//IL_053d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0658: 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)
		ILCursor val = new ILCursor(l);
		for (int i = 0; i < l.Instrs.Count; i++)
		{
			if (l.Instrs[i].OpCode != OpCodes.Ldstr)
			{
				continue;
			}
			if (l.Instrs[i].Operand.ToString() == "Mold iteration {0}")
			{
				val.Index = i + 5;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.Nop;
				}
				if (cd_23 == 0)
				{
					continue;
				}
				val.Emit(OpCodes.Ldloc, 13);
				val.EmitDelegate<Action<int>>((Action<int>)delegate(int num)
				{
					if (Time.frameCount - _23[2] >= cd_23)
					{
						_23[2] = Time.frameCount;
						Debug.Log((object)("Mold iteration " + num + " [NCS:" + cd_23 + "-" + _23[2] + "]"));
					}
				});
			}
			else if (l.Instrs[i].Operand.ToString() == "Spore duplication count: {0}")
			{
				val.Index = i + 5;
				for (int j = 0; j < 5; j++)
				{
					l.Instrs[i + j].OpCode = OpCodes.N