using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EnemySpeedConfig.EnemySpeedConfig.Patches;
using HarmonyLib;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: AssemblyTitle("EnemySpeedConfig")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EnemySpeedConfig")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("afaf5352-a47d-4dbc-a78f-0b8683eb7098")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace EnemySpeedConfig
{
	[BepInPlugin("MiminiSusuki.EnemySpeedConfig", "Enemy Speed Config Mod", "1.0.0.0")]
	public class SpeedBase : BaseUnityPlugin
	{
		private const string modGUID = "MiminiSusuki.EnemySpeedConfig";

		private const string modName = "Enemy Speed Config Mod";

		private const string modVersion = "1.0.0.0";

		private readonly Harmony harmony = new Harmony("MiminiSusuki.EnemySpeedConfig");

		public static SpeedBase Instance;

		internal ManualLogSource mls;

		public ConfigEntry<float> baboonSpeedConfig;

		public ConfigEntry<float> blobSpeedConfig;

		public ConfigEntry<float> beeSpeedConfig;

		public ConfigEntry<float> brakenSpeedConfig;

		public ConfigEntry<float> brakenEnterAngerConfig;

		public ConfigEntry<float> butlerBeeDoAIIntervalConfig;

		public ConfigEntry<float> butlerSpeedConfig;

		public ConfigEntry<float> centipedeSpeedConfig;

		public ConfigEntry<float> claySurgeonSpeedConfig;

		public ConfigEntry<float> coilheadDoAIIntervalConfig;

		public ConfigEntry<float> coilheadSpeedConfig;

		public ConfigEntry<float> ghostGirlSpeedConfig;

		public ConfigEntry<float> ghostGirlBeginChasingConfig;

		public ConfigEntry<float> giantSpeedConfig;

		public ConfigEntry<float> jesterSpeedConfig;

		public ConfigEntry<float> jesterDoAIIntervalConfig;

		public ConfigEntry<float> jesterPopUpConfig;

		public ConfigEntry<float> jesterBeginCrankConfig;

		public ConfigEntry<float> lootBugSpeedConfig;

		public ConfigEntry<float> MaskedSpeedConfig;

		public ConfigEntry<float> oldBirdSpeedConfig;

		public ConfigEntry<float> blindDogSpeedConfig;

		public ConfigEntry<float> caveDwellerBabyGrowthConfig;

		public ConfigEntry<float> caveDwellerDoBabyAIIntervalConfig;

		public ConfigEntry<float> caveDwellerSpeedConfig;

		public ConfigEntry<float> caveDwellerbecomeAdultAnimationSpeedConfig;

		public ConfigEntry<float> caveDwellerNonBabySpeedConfig;

		public ConfigEntry<float> nutCrackerTurnSpeedConfig;

		public ConfigEntry<float> nutCrackerSpeedConfig;

		public ConfigEntry<float> sporeLizardSpeedConfig;

		public ConfigEntry<float> tulipSnakeLeapSpeedConfig;

		public ConfigEntry<float> tulipSnakeDoAIIntervalConfig;

		public ConfigEntry<float> spiderSpeedConfig;

		public ConfigEntry<float> thumperSpeedConfig;

		public ConfigEntry<float> thumperSpeedAccelerationEffectConfig;

		public ConfigEntry<float> thumperSpeedIncreaseRateConfig;

		public ConfigEntry<float> sandWormSpeedConfig;

		private void Awake()
		{
			if (Instance == null)
			{
				Instance = this;
			}
			loadConfig();
			harmony.PatchAll(typeof(SpeedBase));
			harmony.PatchAll(typeof(LootBugPatch));
			harmony.PatchAll(typeof(BeePatch));
			harmony.PatchAll(typeof(MouthDogPatch));
			harmony.PatchAll(typeof(BaboonPatch));
			harmony.PatchAll(typeof(BlobPatch));
			harmony.PatchAll(typeof(ButlerPatch));
			harmony.PatchAll(typeof(ButlerBeePatch));
			harmony.PatchAll(typeof(BabyPatch));
			harmony.PatchAll(typeof(CentipedePatch));
			harmony.PatchAll(typeof(ClayPatch));
			harmony.PatchAll(typeof(ThumberPatch));
			harmony.PatchAll(typeof(GhostPatch));
			harmony.PatchAll(typeof(BrakenPatch));
			harmony.PatchAll(typeof(SnakePatch));
			harmony.PatchAll(typeof(GiantPatch));
			harmony.PatchAll(typeof(JesterPatch));
			harmony.PatchAll(typeof(MaskPatch));
			harmony.PatchAll(typeof(NutPatch));
			harmony.PatchAll(typeof(PufferPatch));
			harmony.PatchAll(typeof(MechPatch));
			harmony.PatchAll(typeof(SpiderPatch));
			harmony.PatchAll(typeof(WormPatch));
			harmony.PatchAll(typeof(CoilPatch));
		}

		private void loadConfig()
		{
			baboonSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Baboon", "Baboon Speed", 1f, "");
			blobSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Blob", "Blob Speed", 1f, "");
			beeSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Bee", "Bee Speed", 1f, "");
			brakenSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Braken", "Braken Speed", 1f, "");
			brakenEnterAngerConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Braken", "Enter Anger Mode", 1f, "");
			butlerBeeDoAIIntervalConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Butler", "Butler Bees Do AI Interval", 1f, "");
			butlerSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Butler", "Butler Speed", 1f, "");
			centipedeSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Centipede", "Centipede Speed", 1f, "");
			claySurgeonSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Clay Surgeon", "Clay Surgeon Speed", 1f, "");
			coilheadDoAIIntervalConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Coilhead", "Coilhead Do AI Interval", 1f, "");
			coilheadSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Coilhead", "Coilhead Speed", 1f, "");
			ghostGirlSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Ghost Girl", "Ghost Girl Speed", 1f, "");
			ghostGirlBeginChasingConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Ghost Girl", "Ghost Girl Begin Chasing", 1f, "");
			giantSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Giant", "Giant Speed", 1f, "");
			jesterSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Jester", "Jester Speed", 1f, "");
			jesterDoAIIntervalConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Jester", "Jester Do AI Interval Speed", 1f, "");
			jesterPopUpConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Jester", "Pop Up Speed", 1f, "");
			jesterBeginCrankConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Jester", "Begin Crank Speed", 1f, "");
			lootBugSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Loot Bug", "Loot Bug Speed", 1f, "");
			MaskedSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Masked", "Masked Speed", 1f, "");
			oldBirdSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Old Bird", "Old Bird Speed", 1f, "");
			blindDogSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Blind Dog", "Blind Dog Speed", 1f, "");
			caveDwellerBabyGrowthConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Cave Dweller", "Cave Dweller Baby Growth Speed", 1f, "");
			caveDwellerDoBabyAIIntervalConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Cave Dweller", "Cave Dweller Do Baby AI Interval", 1f, "");
			caveDwellerSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Cave Dweller", "Cave Dweller Speed", 1f, "");
			caveDwellerbecomeAdultAnimationSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Cave Dweller", "Cave Dweller Become Adult Animation Speed", 1f, "");
			caveDwellerNonBabySpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Cave Dweller", "Cave Dweller Non Baby Speed", 1f, "");
			nutCrackerTurnSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Nut Cracker", "Nut Cracker Turn Speed", 1f, "");
			nutCrackerSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Nut Cracker", "Nut Cracker Speed", 1f, "");
			sporeLizardSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Spore Lizard", "Spore Lizard Speed", 1f, "");
			tulipSnakeLeapSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Tulip Snake", "Tulip Snake Leap Speed", 1f, "");
			tulipSnakeDoAIIntervalConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Tulip Snake", "Tulip Snake Do AI Interval", 1f, "");
			spiderSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Spider", "Spider Speed", 1f, "");
			thumperSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Thumper", "Thumper Speed", 1f, "");
			thumperSpeedAccelerationEffectConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Thumper", "Thumper Speed Acceleration Effect", 1f, "");
			thumperSpeedIncreaseRateConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Thumper", "Thumper Speed Increase Rate", 1f, "");
			sandWormSpeedConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Sand Worm", "Sand Worm Speed", 1f, "");
		}
	}
}
namespace EnemySpeedConfig.EnemySpeedConfig.Patches
{
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class BaboonPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void baboonPatch(ref BaboonBirdAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.baboonSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class BlobPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void blobPatch(ref BlobAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.blobSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class BeePatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void beePatch(ref RedLocustBees __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.beeSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class BrakenPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void brakPatch2(ref FlowermanAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.brakenSpeedConfig.Value;
		}

		[HarmonyPatch("EnterAngerModeClientRpc")]
		[HarmonyPostfix]
		private static void brakPatch(ref FlowermanAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.brakenEnterAngerConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class ButlerBeePatch : Object
	{
		[HarmonyPatch("DoAIInterval")]
		[HarmonyPostfix]
		private static void bulterPatch(ref ButlerBeesEnemyAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.butlerBeeDoAIIntervalConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class ButlerPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void bulterPatch(ref ButlerEnemyAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.butlerSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class CentipedePatch : Object
	{
		[HarmonyPatch("IncreaseSpeedSlowly")]
		[HarmonyPostfix]
		private static void CentiPatch(ref CentipedeAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.centipedeSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class ClayPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void CentiPatch(ref ClaySurgeonAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.claySurgeonSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class CoilPatch : Object
	{
		[HarmonyPatch("DoAIInterval")]
		[HarmonyPostfix]
		private static void coilPatch(ref SpringManAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.coilheadDoAIIntervalConfig.Value;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void coilPatch2(ref SpringManAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.coilheadSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class GhostPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void ghostPatch(ref DressGirlAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.ghostGirlSpeedConfig.Value;
		}

		[HarmonyPatch("BeginChasing")]
		[HarmonyPostfix]
		private static void ghostPatch2(ref DressGirlAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.ghostGirlBeginChasingConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class GiantPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void giantPatch(ref ForestGiantAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.giantSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class JesterPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void jesterPatch2(ref JesterAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.jesterSpeedConfig.Value;
			JesterAI obj = __instance;
			obj.maxAnimSpeed *= SpeedBase.Instance.jesterSpeedConfig.Value;
		}

		[HarmonyPatch("DoAIInterval")]
		[HarmonyPostfix]
		private static void jesterPatch(ref JesterAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.jesterDoAIIntervalConfig.Value;
		}

		[HarmonyPatch("SetJesterInitialValues")]
		[HarmonyPostfix]
		private static void jesterPtach3(ref JesterAI __instance)
		{
			JesterAI obj = __instance;
			obj.popUpTimer /= SpeedBase.Instance.jesterPopUpConfig.Value;
			JesterAI obj2 = __instance;
			obj2.beginCrankingTimer /= SpeedBase.Instance.jesterBeginCrankConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class LootBugPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void lootBugPatch(ref HoarderBugAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.lootBugSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class MaskPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void maskPatch(ref MaskedPlayerEnemy __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.MaskedSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class MechPatch : Object
	{
		[HarmonyPatch("DoFootstepCycle")]
		[HarmonyPostfix]
		private static void mechPatch(ref RadMechAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.oldBirdSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class MouthDogPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void mouthDogPatch(ref MouthDogAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.blindDogSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class BabyPatch : Object
	{
		[HarmonyPatch("IncreaseBabyGrowthMeter")]
		[HarmonyPostfix]
		private static void babyPatch(ref CaveDwellerAI __instance)
		{
			CaveDwellerAI obj = __instance;
			obj.growthMeter *= SpeedBase.Instance.caveDwellerBabyGrowthConfig.Value;
		}

		[HarmonyPatch("DoBabyAIInterval")]
		[HarmonyPostfix]
		private static void babyPatch2(ref CaveDwellerAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.caveDwellerDoBabyAIIntervalConfig.Value;
		}

		[HarmonyPatch("BabyUpdate")]
		[HarmonyPostfix]
		private static void babyPatch3(ref CaveDwellerAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.caveDwellerSpeedConfig.Value;
		}

		[HarmonyPatch("becomeAdultAnimation")]
		[HarmonyPostfix]
		private static void babyPatch4(ref CaveDwellerAI __instance)
		{
			CaveDwellerAI obj = __instance;
			obj.leapSpeed *= SpeedBase.Instance.caveDwellerbecomeAdultAnimationSpeedConfig.Value;
		}

		[HarmonyPatch("DoNonBabyUpdateLogic")]
		[HarmonyPostfix]
		private static void babyPatch5(ref CaveDwellerAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.caveDwellerNonBabySpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class NutPatch : Object
	{
		[HarmonyPatch("TurnTorsoToTargetDegrees")]
		[HarmonyPostfix]
		private static void nutPatch(ref NutcrackerEnemyAI __instance)
		{
			NutcrackerEnemyAI obj = __instance;
			obj.torsoTurnSpeed *= SpeedBase.Instance.nutCrackerTurnSpeedConfig.Value;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void nutPatch2(ref NutcrackerEnemyAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.nutCrackerSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class PufferPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void pufPatch(ref PufferAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.sporeLizardSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class SnakePatch : Object
	{
		[HarmonyPatch("DoLeapAndDropPhysics")]
		[HarmonyPostfix]
		private static void snakePatch(ref FlowerSnakeEnemy __instance)
		{
			FlowerSnakeEnemy obj = __instance;
			obj.leapSpeedMultiplier *= SpeedBase.Instance.tulipSnakeLeapSpeedConfig.Value;
		}

		[HarmonyPatch("DoAIInterval")]
		[HarmonyPostfix]
		private static void snakePatch2(ref FlowerSnakeEnemy __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.tulipSnakeDoAIIntervalConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class SpiderPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void spiPatch(ref SandSpiderAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.spiderSpeedConfig.Value;
			__instance.spiderSpeed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.spiderSpeedConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class ThumberPatch : Object
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void ThumbPatch(ref CrawlerAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.thumperSpeedConfig.Value;
		}

		[HarmonyPatch("CalculateAgentSpeed")]
		[HarmonyPostfix]
		private static void ThumbPatch2(ref CrawlerAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.thumperSpeedConfig.Value;
			CrawlerAI obj = __instance;
			obj.SpeedAccelerationEffect *= SpeedBase.Instance.thumperSpeedAccelerationEffectConfig.Value;
			CrawlerAI obj2 = __instance;
			obj2.SpeedIncreaseRate *= SpeedBase.Instance.thumperSpeedIncreaseRateConfig.Value;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class WormPatch : Object
	{
		[HarmonyPatch("DoAIInterval")]
		[HarmonyPostfix]
		private static void wormPatch(ref SandWormAI __instance)
		{
			((EnemyAI)__instance).agent.speed = ((EnemyAI)__instance).agent.speed * SpeedBase.Instance.sandWormSpeedConfig.Value;
		}
	}
}