using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EpiVision.Patches;
using HarmonyLib;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("EpiVision")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EpiVision")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c288ed3b-0505-45d7-8dec-fe34c180763c")]
[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 EpiVision
{
	[BepInPlugin("toastoverflow.EpilepsySafeREPO", "EpilepsySafeREPO", "1.0.0")]
	public class EpiVision : BaseUnityPlugin
	{
		public const string PLUGIN_GUID = "toastoverflow.EpilepsySafeREPO";

		public const string PLUGIN_NAME = "EpilepsySafeREPO";

		public const string PLUGIN_VERSION = "1.0.0";

		public bool turnLightsBackOn = false;

		public bool flashlightOn = false;

		public static ConfigEntry<bool> PhotosensitivitySetting;

		public static ConfigEntry<bool> MusicogenicSetting;

		public static ConfigEntry<bool> MotionSensitivitySetting;

		public static ConfigEntry<bool> ToggleFlashlightSetting;

		public static ConfigEntry<bool> TurnLightsBackOnSetting;

		public bool showOvercharge = false;

		public static EpiVision Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony Harmony { get; set; }

		private void Awake()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			PhotosensitivitySetting = ((BaseUnityPlugin)this).Config.Bind<bool>("Accessibility", "Photosensitivity features", true, new ConfigDescription("Removes flashing or very bright effects, as well as animations like shaking and spinning", (AcceptableValueBase)null, Array.Empty<object>()));
			MusicogenicSetting = ((BaseUnityPlugin)this).Config.Bind<bool>("Accessibility", "Musicogenic sensitivity features", true, new ConfigDescription("Mutes deep, beeping, buzzing, or droning sounds", (AcceptableValueBase)null, Array.Empty<object>()));
			MotionSensitivitySetting = ((BaseUnityPlugin)this).Config.Bind<bool>("Accessibility", "Motion sensitivity features", true, new ConfigDescription("Disables effects that swing or spin the camera or change its look speed", (AcceptableValueBase)null, Array.Empty<object>()));
			ToggleFlashlightSetting = ((BaseUnityPlugin)this).Config.Bind<bool>("Accessibility", "Toggle flashlight", true, new ConfigDescription("Allows the player's flashlight to be turned on and off by pressing the F key", (AcceptableValueBase)null, Array.Empty<object>()));
			TurnLightsBackOnSetting = ((BaseUnityPlugin)this).Config.Bind<bool>("Accessibility", "Turn lights back on", true, new ConfigDescription("After the last extraction point turns all the lights off, turn them back on a few seconds later", (AcceptableValueBase)null, Array.Empty<object>()));
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Patch();
		}

		internal static void Patch()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Harmony = new Harmony("toastoverflow.EpilepsySafeREPO");
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(SemiUISpringScale));
				Harmony.PatchAll(typeof(SemiUITextFlashColor));
				Harmony.PatchAll(typeof(MenuSelectionBoxSetTarget));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(PageOpen));
			}
			if (PhotosensitivitySetting.Value || ToggleFlashlightSetting.Value || MotionSensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(LoadingUILevelAnimationStart));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(SemiUISemiUISpringShakeY));
				Harmony.PatchAll(typeof(DataDirectorLoadSettings));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(TutorialDirectorNextPage));
			}
			if (PhotosensitivitySetting.Value || MusicogenicSetting.Value || ToggleFlashlightSetting.Value)
			{
				Harmony.PatchAll(typeof(LevelGeneratorPlayerSpawn));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(PlayerAvatarFlashlightFlicker));
				Harmony.PatchAll(typeof(FlashlightControllerFlickerSet));
				Harmony.PatchAll(typeof(RenderTextureMainChangeResolution));
				Harmony.PatchAll(typeof(RenderTextureMainShake));
				Harmony.PatchAll(typeof(RenderTextureMainChangeSize));
				Harmony.PatchAll(typeof(CameraFreezeFreeze));
				Harmony.PatchAll(typeof(CameraGlitchPlayLong));
				Harmony.PatchAll(typeof(CameraGlitchPlayLongHeal));
				Harmony.PatchAll(typeof(CameraGlitchPlayLongHurt));
				Harmony.PatchAll(typeof(CameraGlitchPlayShort));
				Harmony.PatchAll(typeof(CameraGlitchPlayShortHeal));
				Harmony.PatchAll(typeof(CameraGlitchPlayShortHurt));
				Harmony.PatchAll(typeof(CameraGlitchPlayTiny));
				Harmony.PatchAll(typeof(CameraGlitchPlayUpgrade));
			}
			if (PhotosensitivitySetting.Value || MusicogenicSetting.Value)
			{
				Harmony.PatchAll(typeof(ExtractionPointButtonPress));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(TruckHealerHeal));
				Harmony.PatchAll(typeof(ItemMineStateArming));
				Harmony.PatchAll(typeof(ItemMineAnimateLight));
			}
			if (MusicogenicSetting.Value)
			{
				Harmony.PatchAll(typeof(PhysGrabObjectGrabStarted));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(ExtractionPointExtractionPointSurplusRPC));
			}
			if (TurnLightsBackOnSetting.Value)
			{
				Harmony.PatchAll(typeof(ExtractionPointHitCeiling));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(MenuElementAnimationsUIAniNewInitialPosition));
				Harmony.PatchAll(typeof(MenuElementAnimationsUIAniNudgeX));
				Harmony.PatchAll(typeof(MenuElementAnimationsUIAniNudgeY));
				Harmony.PatchAll(typeof(MenuElementAnimationsUIAniRotate));
				Harmony.PatchAll(typeof(MenuElementAnimationsUIAniScale));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(SemiLaserLaserActive));
				Harmony.PatchAll(typeof(SlowWalkerSparkEffectPlaySparkEffect));
				Harmony.PatchAll(typeof(SlowWalkerSparkEffectToggleSparkEffect));
				Harmony.PatchAll(typeof(SlowWalkerAttackStart));
				Harmony.PatchAll(typeof(EnemyHunterOnInvestigate));
				Harmony.PatchAll(typeof(EnemySlowMouthOnSpawn));
			}
			if (PhotosensitivitySetting.Value || MotionSensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(CameraZoomOverrideZoomSet));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(EnemySlowMouthCameraVisualsStateSet));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(ObjectInstantiate));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(ItemMineStunOnTriggered));
				Harmony.PatchAll(typeof(ShaderPropertyToID));
				Harmony.PatchAll(typeof(EnemyBangOnSpawn));
				Harmony.PatchAll(typeof(EnemyFloaterOnSpawn));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(PlayerDeathEffectsTrigger));
				Harmony.PatchAll(typeof(AudioLowPassLogicSetup));
				Harmony.PatchAll(typeof(ParticleScriptExplosionSpawn));
				Harmony.PatchAll(typeof(TrapTVTrapActivate));
				Harmony.PatchAll(typeof(LineBetweenTwoPointsDrawLine));
				Harmony.PatchAll(typeof(PlayerHealthMaterialEffectOverride));
				Harmony.PatchAll(typeof(PlayerHealthMaterialEffectOverrideRPC));
				Harmony.PatchAll(typeof(ItemUpgradePlayerUpgrade));
			}
			if (PhotosensitivitySetting.Value || MotionSensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(CameraAimAimTargetSoftSet));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(ValuableWizardTimeGlassSetStateRPC));
			}
			if (MotionSensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(PlayerControllerOverrideLookSpeed));
			}
			if (TurnLightsBackOnSetting.Value)
			{
				Harmony.PatchAll(typeof(RoundDirectorExtractionCompletedAllCheck));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(IceSawValuableTrapActivate));
				Harmony.PatchAll(typeof(ClownTrapTouchNose));
				Harmony.PatchAll(typeof(ClownTrapTrapStop));
				Harmony.PatchAll(typeof(MusicBoxTrapMusicBoxStart));
			}
			if (MusicogenicSetting.Value)
			{
				Harmony.PatchAll(typeof(AudioSourcePatch));
			}
			if (ToggleFlashlightSetting.Value)
			{
				Harmony.PatchAll(typeof(GameDirectorUpdate));
			}
			if (MusicogenicSetting.Value)
			{
				Harmony.PatchAll(typeof(StartRoomStart));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(PowerCrystalValuableGlowDim));
				Harmony.PatchAll(typeof(PowerCrystalValuableGlowMed));
				Harmony.PatchAll(typeof(PowerCrystalValuableGlowStrong));
			}
			if (PhotosensitivitySetting.Value || ToggleFlashlightSetting.Value)
			{
				Harmony.PatchAll(typeof(FlashlightControllerLightOn));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(ScreamDollValuableSetStateRPC));
				Harmony.PatchAll(typeof(ScreamDollValuableSetState));
				Harmony.PatchAll(typeof(IceSawValuableSetStateRPC));
				Harmony.PatchAll(typeof(IceSawValuableSetState));
				Harmony.PatchAll(typeof(TrapRadioRadioTrapActivated));
				Harmony.PatchAll(typeof(BlenderValuableUpdate));
			}
			if (MotionSensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(EnemyGnomeOnSpawn));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(ChargingStationChargingEffects));
				Harmony.PatchAll(typeof(ChargingStationStart));
				Harmony.PatchAll(typeof(MaterialSetColor));
				Harmony.PatchAll(typeof(ValuableBoomboxStart));
				Harmony.PatchAll(typeof(MenuPagePasswordPasswordTextSet));
				Harmony.PatchAll(typeof(MenuElementRegionUpdate));
				Harmony.PatchAll(typeof(ValuableObjectDiscover));
				Harmony.PatchAll(typeof(ItemGunMuzzleFlashActivateAllEffects));
				Harmony.PatchAll(typeof(ItemGunBulletActivateAll));
				Harmony.PatchAll(typeof(PhysGrabCartStart));
				Harmony.PatchAll(typeof(PhysGrabCartGlitchyText));
				Harmony.PatchAll(typeof(PhysGrabCartObjectsInCart));
				Harmony.PatchAll(typeof(OverchargeRoundBarUIFlashColorLogic));
				Harmony.PatchAll(typeof(OverchargeRoundBarUIUpdate));
				Harmony.PatchAll(typeof(OverchargeRoundBarUIShow));
				Harmony.PatchAll(typeof(PlayerAvatarOverchargeVisualsStart));
				Harmony.PatchAll(typeof(PhysGrabBeamStart));
				Harmony.PatchAll(typeof(GumballValuableInstantiateHypnosisLines));
				Harmony.PatchAll(typeof(GumballValuableOpenEyes));
				Harmony.PatchAll(typeof(ItemCartLaserShootParticles));
				Harmony.PatchAll(typeof(ItemCartCannonShootParticlesPlay));
				Harmony.PatchAll(typeof(TrafficLightValuableIsFlickering));
				Harmony.PatchAll(typeof(TrafficLightValuableRedState));
				Harmony.PatchAll(typeof(ItemCartCannonMainStateActive));
				Harmony.PatchAll(typeof(ItemCartLaserBuildupMeterStart));
				Harmony.PatchAll(typeof(ParticlePrefabExplosionStart));
				Harmony.PatchAll(typeof(SpiralOnScreenFadeIn));
				Harmony.PatchAll(typeof(ItemStunBatonPlayParticles));
				Harmony.PatchAll(typeof(ItemGunLaserStart));
				Harmony.PatchAll(typeof(BatteryBarEffectStart));
				Harmony.PatchAll(typeof(BatteryVisualLogicBatteryVisualBounce));
				Harmony.PatchAll(typeof(BatteryVisualLogicBatteryChargeVisuals));
			}
			if (MusicogenicSetting.Value)
			{
				Harmony.PatchAll(typeof(GameDirectorStart));
			}
			if (PhotosensitivitySetting.Value)
			{
				Harmony.PatchAll(typeof(FlatScreenTVLateStart));
				Harmony.PatchAll(typeof(MuseumLaserLogicSetLightIntensities));
				Harmony.PatchAll(typeof(MuseumLaserLogicLaserVisuals));
				Harmony.PatchAll(typeof(MuseumLaserLogicStart));
				Harmony.PatchAll(typeof(ItemLadderFlickerBridge));
				Harmony.PatchAll(typeof(DeathPitSaveEffectStart));
				Harmony.PatchAll(typeof(ItemOrbZeroGravityStart));
				Harmony.PatchAll(typeof(CauldronStart));
				Harmony.PatchAll(typeof(ItemStunBatonStart));
			}
		}
	}
}
namespace EpiVision.Patches
{
	[HarmonyPatch(typeof(SemiUI), "SemiUISpringScale", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class SemiUISpringScale
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(SemiUI), "SemiUITextFlashColor", new Type[]
	{
		typeof(Color),
		typeof(float)
	})]
	public static class SemiUITextFlashColor
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuSelectionBox), "MenuSelectionBoxSetTarget", new Type[]
	{
		typeof(Vector3),
		typeof(Vector3),
		typeof(MenuPage),
		typeof(bool),
		typeof(MenuScrollBox),
		typeof(Vector2)
	})]
	public static class MenuSelectionBoxSetTarget
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(SemiUI), "SemiUISpringShakeX", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	[HarmonyPatch(typeof(SemiUI), "SemiUISpringShakeY", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class SemiUISemiUISpringShakeY
	{
		public static void Postfix(SemiUI __instance)
		{
			__instance.SemiUIResetAllShakeEffects();
		}
	}
	[HarmonyPatch(typeof(MenuManager), "PageOpen", new Type[]
	{
		typeof(MenuPageIndex),
		typeof(bool)
	})]
	public static class PageOpen
	{
		public static void Postfix(MenuPageIndex menuPageIndex, ref MenuPage __result)
		{
			if (((Object)__result).name.Contains("Saves"))
			{
				((Behaviour)((Component)((Component)__result).transform.Find("Save File Info/Panel")).gameObject.GetComponent<Image>()).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(DataDirector), "LoadSettings")]
	public static class DataDirectorLoadSettings
	{
		public static void Postfix(DataDirector __instance)
		{
			__instance.TutorialPlayed();
		}
	}
	[HarmonyPatch(typeof(LoadingUI), "LevelAnimationStart", new Type[] { })]
	public static class LoadingUILevelAnimationStart
	{
		public static void Postfix()
		{
			if (EpiVision.PhotosensitivitySetting.Value || EpiVision.MotionSensitivitySetting.Value)
			{
				List<string> list = new List<string>(new string[1] { "Game Director/Post Processing/Post Processing Overlay" });
				if (EpiVision.PhotosensitivitySetting.Value)
				{
					string[] collection = new string[3] { "Game Director/Post Processing/Post Processing Main", "UI/HUD/HUD Canvas/HUD/Menu Selection Outline/Menu Selection Box/RawImage", "UI/HUD/HUD Canvas/Render Texture Video" };
					list.AddRange(collection);
				}
				foreach (string item in list)
				{
					GameObject.Find(item).SetActive(false);
				}
				Map.Instance.ActiveSet(true);
				GameObject.Find("Map/Active/Player/Dirt Finder Map Camera").GetComponent<CameraUpdate>().updateRate = 0f;
				Map.Instance.ActiveSet(false);
			}
			if (EpiVision.TurnLightsBackOnSetting.Value)
			{
				Transform transform = GameObject.Find("Level Generator/Level").transform;
				PropLight[] componentsInChildren = ((Component)transform).GetComponentsInChildren<PropLight>(true);
				foreach (PropLight val in componentsInChildren)
				{
					((Component)val).gameObject.GetComponent<Light>().intensity = 4f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(FlashlightController), "LightOn", new Type[] { })]
	public static class FlashlightControllerLightOn
	{
		public static void Postfix(FlashlightController __instance)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (EpiVision.PhotosensitivitySetting.Value)
			{
				__instance.lightOnSpeed = 999f;
			}
			if ((SemiFunc.IsMultiplayer() && !__instance.PlayerAvatar.photonView.IsMine && EpiVision.PhotosensitivitySetting.Value) || ((!SemiFunc.IsMultiplayer() || __instance.PlayerAvatar.photonView.IsMine) && EpiVision.ToggleFlashlightSetting.Value && !EpiVision.Instance.flashlightOn))
			{
				__instance.spotlight.color = Color.clear;
			}
		}
	}
	[HarmonyPatch(typeof(TutorialDirector), "NextPage", new Type[] { })]
	public static class TutorialDirectorNextPage
	{
		public static void Postfix(int ___currentPage)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject.Find("UI/HUD/HUD Canvas/HUD/Game Hud/Tutorial/videoTransform/videoImage").SetActive(false);
			Transform transform = GameObject.Find("Level Generator/Level/Start Room - Tutorial(Clone)/Doors/").transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (((Object)child).name.Contains("Tutorial Door"))
				{
					child.Find("Door Animation/Tutorial Door").localScale = new Vector3(1f, 70f, 999f);
					((Component)child.Find("Door Animation/Latch/Fill Bar/Bleep")).gameObject.SetActive(false);
					((Component)child.Find("Door Animation/Latch/Fill Bar (1)/Bleep (1)")).gameObject.SetActive(false);
					((Component)child.Find("Light Particle")).gameObject.SetActive(false);
					((Component)child.Find("Light Particle2")).gameObject.SetActive(false);
					((Renderer)((Component)child).GetComponent<TutorialDoor>().emojiScreenGlitch.GetComponent<MeshRenderer>()).enabled = false;
				}
			}
			string text = "Level Generator/Level/Start Room - Tutorial(Clone)/Doors/Tutorial Door";
			string text2 = "";
			if (___currentPage > 1 && ___currentPage < 8)
			{
				text2 = " (" + (___currentPage - 1) + ")";
			}
			else if (___currentPage == 8)
			{
				text2 = " (15)";
			}
			else if (___currentPage > 8)
			{
				text2 = " (" + (___currentPage - 2) + ")";
			}
			if (___currentPage > 0)
			{
				GameObject.Find(text + text2 + "/Door Animation/Latch").SetActive(false);
				GameObject.Find(text + text2 + "/Door Animation/ScreenTransform").SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(LevelGenerator), "PlayerSpawn")]
	public static class LevelGeneratorPlayerSpawn
	{
		public static void Postfix()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (EpiVision.ToggleFlashlightSetting.Value)
			{
				EpiVision.Instance.flashlightOn = false;
				FlashlightLightAim[] array = Object.FindObjectsOfType<FlashlightLightAim>(true);
				foreach (FlashlightLightAim val in array)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			if (EpiVision.PhotosensitivitySetting.Value)
			{
				CameraCrouchNoise[] array2 = Object.FindObjectsOfType<CameraCrouchNoise>(true);
				foreach (CameraCrouchNoise val2 in array2)
				{
					((Behaviour)val2).enabled = false;
				}
				PhysGrabBeam[] array3 = Object.FindObjectsOfType<PhysGrabBeam>(true);
				foreach (PhysGrabBeam val3 in array3)
				{
					((Component)val3).gameObject.GetComponent<LineRenderer>().startColor = new Color(1f, 1f, 1f, 0.1f);
					((Component)val3).gameObject.GetComponent<LineRenderer>().endColor = new Color(1f, 1f, 1f, 0.1f);
					val3.lineRendererOverCharge.startColor = new Color(0f, 0f, 0f, 0f);
					val3.lineRendererOverCharge.endColor = new Color(0f, 0f, 0f, 0f);
				}
			}
			if (!EpiVision.MusicogenicSetting.Value)
			{
				return;
			}
			Fireplace[] array4 = Object.FindObjectsOfType<Fireplace>(true);
			foreach (Fireplace val4 in array4)
			{
				foreach (AudioSource item in ((Component)val4).GetComponentsInChildren<AudioSource>(true).ToList())
				{
					((Behaviour)item).enabled = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAvatar), "FlashlightFlicker", new Type[] { typeof(float) })]
	public static class PlayerAvatarFlashlightFlicker
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(FlashlightController), "FlickerSet", new Type[] { typeof(float) })]
	public static class FlashlightControllerFlickerSet
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(RenderTextureMain), "ChangeResolution", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class RenderTextureMainChangeResolution
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(RenderTextureMain), "Shake", new Type[] { typeof(float) })]
	public static class RenderTextureMainShake
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(RenderTextureMain), "ChangeSize", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class RenderTextureMainChangeSize
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraFreeze), "Freeze", new Type[] { typeof(float) })]
	public static class CameraFreezeFreeze
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayLong")]
	public static class CameraGlitchPlayLong
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayLongHeal")]
	public static class CameraGlitchPlayLongHeal
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayLongHurt")]
	public static class CameraGlitchPlayLongHurt
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayShort")]
	public static class CameraGlitchPlayShort
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayShortHeal")]
	public static class CameraGlitchPlayShortHeal
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayShortHurt")]
	public static class CameraGlitchPlayShortHurt
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayTiny")]
	public static class CameraGlitchPlayTiny
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraGlitch), "PlayUpgrade")]
	public static class CameraGlitchPlayUpgrade
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ExtractionPoint), "ButtonPress")]
	public static class ExtractionPointButtonPress
	{
		public static void Postfix(ExtractionPoint __instance)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			if (EpiVision.PhotosensitivitySetting.Value)
			{
				((Renderer)__instance.emojiScreenGlitch.GetComponent<MeshRenderer>()).enabled = false;
				__instance.tubeSlamDown = AnimationCurve.Linear(0f, 0f, 100f, 100f);
				((Component)((Component)__instance).gameObject.transform.Find("Scale/Platform/Spotlight Head 1/Light - Spotlight 1")).gameObject.SetActive(false);
				((Component)((Component)__instance).gameObject.transform.Find("Scale/Platform/Spotlight Head 2/Light - Spotlight 2")).gameObject.SetActive(false);
				((TMP_Text)((Component)((Component)__instance).gameObject.transform.Find("Scale/Platform/Screen/Display Wide/Text")).GetComponent<TextMeshPro>()).fontSizeMax = 10f;
				((TMP_Text)((Component)((Component)__instance).gameObject.transform.Find("Scale/Extraction Tube/Tube Screen/Text")).GetComponent<TextMeshPro>()).fontSizeMax = 10f;
				((Behaviour)((Component)((Component)__instance).gameObject.transform.Find("Scale/Extraction Tube/Tube Screen/Light - Button Light (1)")).GetComponent<Light>()).enabled = false;
				((Component)((Component)__instance).gameObject.transform.Find("Scale/Extraction Tube/Light - Surplus Reward")).GetComponent<Light>().color = Color.clear;
				((Component)((Component)__instance).gameObject.transform.Find("Scale/Suck Particles")).gameObject.SetActive(false);
			}
			if (EpiVision.MusicogenicSetting.Value)
			{
				__instance.soundAlarm.Volume = 0f;
				__instance.soundAlarmGlobal.Volume = 0f;
				__instance.soundAlarmFinal.Volume = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(TruckHealer), "Heal", new Type[] { typeof(PlayerAvatar) })]
	public static class TruckHealerHeal
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemMine), "StateArming")]
	public static class ItemMineStateArming
	{
		public static void Postfix(ItemMine __instance)
		{
			((Component)((Component)__instance).transform.Find("Light - Small Lamp")).gameObject.SetActive(false);
			Transform val = ((Component)__instance).transform.Find("Trigger Direction");
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(ItemMine), "AnimateLight")]
	public static class ItemMineAnimateLight
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(AudioLowPassLogic), "Setup")]
	public static class AudioLowPassLogicSetup
	{
		public static void Postfix(AudioLowPassLogic __instance)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			if (((Object)__instance).name.Contains("Grenade"))
			{
				((Renderer)((Component)((Component)__instance).transform.Find("Mesh")).GetComponent<MeshRenderer>()).material = new Material(Shader.Find("Standard"));
			}
			if (((Object)__instance).name.Contains("Torque") || ((Object)__instance).name.Contains("Feather") || ((Object)__instance).name.Contains("Item Drone Zero Gravity") || ((Object)__instance).name.Contains("Item Drone Battery"))
			{
				Transform val = ((Component)__instance).transform.Find("Drone");
				for (int i = 0; i < val.childCount; i++)
				{
					((Component)val.GetChild(i)).gameObject.SetActive(false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObject), "GrabStarted", new Type[] { typeof(PhysGrabber) })]
	public static class PhysGrabObjectGrabStarted
	{
		public static void Postfix(PhysGrabber player)
		{
			player.loopSound.Volume = 0f;
		}
	}
	[HarmonyPatch(typeof(ExtractionPoint), "ExtractionPointSurplusRPC", new Type[]
	{
		typeof(int),
		typeof(PhotonMessageInfo)
	})]
	public static class ExtractionPointExtractionPointSurplusRPC
	{
		public static void Postfix(ExtractionPoint __instance)
		{
			MeshRenderer[] componentsInChildren = ((Component)((Component)__instance).transform.Find("Scale/Extraction Tube")).GetComponentsInChildren<MeshRenderer>();
			foreach (MeshRenderer val in componentsInChildren)
			{
				((Renderer)val).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(ExtractionPoint), "HitCeiling")]
	public static class ExtractionPointHitCeiling
	{
		public static void Postfix()
		{
			if (!EpiVision.Instance.turnLightsBackOn)
			{
				return;
			}
			bool flag = true;
			Transform transform = GameObject.Find("Level Generator/Level").transform;
			PropLight[] componentsInChildren = ((Component)transform).GetComponentsInChildren<PropLight>(true);
			foreach (PropLight val in componentsInChildren)
			{
				if (((Component)val).gameObject.GetComponent<Light>().intensity == 0f)
				{
					flag = false;
				}
				((Component)val).gameObject.GetComponent<Light>().intensity = 4f;
			}
			if (flag)
			{
				EpiVision.Instance.turnLightsBackOn = false;
			}
		}
	}
	[HarmonyPatch(typeof(MenuElementAnimations), "UIAniNewInitialPosition", new Type[] { typeof(Vector2) })]
	public static class MenuElementAnimationsUIAniNewInitialPosition
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuElementAnimations), "UIAniNudgeX", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class MenuElementAnimationsUIAniNudgeX
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuElementAnimations), "UIAniNudgeY", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class MenuElementAnimationsUIAniNudgeY
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuElementAnimations), "UIAniRotate", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class MenuElementAnimationsUIAniRotate
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuElementAnimations), "UIAniScale", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class MenuElementAnimationsUIAniScale
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(SemiLaser), "LaserActive", new Type[]
	{
		typeof(Vector3),
		typeof(Vector3),
		typeof(bool)
	})]
	public static class SemiLaserLaserActive
	{
		public static void Postfix(SemiLaser __instance)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			List<LineRenderer> list = ((Component)__instance).GetComponentsInChildren<LineRenderer>().ToList();
			Color val = default(Color);
			((Color)(ref val))..ctor(0f, 0f, 0f, 0.05f);
			if (((Object)((Component)__instance).transform.parent).name.Contains("Item Cart Laser") || ((Object)((Component)__instance).transform.parent).name.Contains("Item Gun Laser"))
			{
				((Color)(ref val))..ctor(0f, 0f, 0f, 0.01f);
			}
			for (int i = 0; i < list.Count; i++)
			{
				switch (i)
				{
				case 0:
					list.ElementAt(i).startColor = Color.clear;
					list.ElementAt(i).endColor = Color.clear;
					break;
				case 1:
					list.ElementAt(i).startColor = val;
					list.ElementAt(i).endColor = val;
					break;
				}
			}
			foreach (Light item in ((Component)__instance).GetComponentsInChildren<Light>().ToList())
			{
				item.color = Color.clear;
			}
			List<ParticleSystem> list2 = ((Component)__instance).GetComponentsInChildren<ParticleSystem>().ToList();
			list2.AddRange(((Component)__instance.graceTransform).GetComponentsInChildren<ParticleSystem>().ToList());
			foreach (ParticleSystem item2 in list2)
			{
				((Component)item2).gameObject.SetActive(false);
			}
			foreach (MeshRenderer item3 in ((Component)__instance).GetComponentsInChildren<MeshRenderer>().ToList())
			{
				((Renderer)item3).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(SlowWalkerSparkEffect), "PlaySparkEffect")]
	public static class SlowWalkerSparkEffectPlaySparkEffect
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(SlowWalkerSparkEffect), "ToggleSparkEffect")]
	public static class SlowWalkerSparkEffectToggleSparkEffect
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(SlowWalkerAttack), "Start")]
	public static class SlowWalkerAttackStart
	{
		public static void Postfix(SlowWalkerAttack __instance)
		{
			//IL_0077: 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)
			string[] source = new string[8] { "Particle Cracks Buildup", "Particle Cracks Suck In", "Particle Shockwave", "Particle Ding", "Particle Ding Red", "Particle Ding White", "Particle Cracks", "Particle Shockwave 2" };
			foreach (ParticleSystem item in ((Component)__instance).GetComponentsInChildren<ParticleSystem>().ToList())
			{
				if (source.Contains(((Object)item).name))
				{
					EmissionModule emission = item.emission;
					((EmissionModule)(ref emission)).enabled = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyHunter), "OnInvestigate")]
	public static class EnemyHunterOnInvestigate
	{
		public static void Postfix(EnemyHunter __instance)
		{
			((Component)((Component)__instance).transform.parent.parent.Find("Always Active/Shoot Effect")).gameObject.SetActive(false);
			((Component)((Component)__instance).transform.parent.parent.Find("Always Active/Hit Effect")).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(EnemySlowMouth), "OnSpawn")]
	public static class EnemySlowMouthOnSpawn
	{
		public static void Postfix()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			SemiPuke[] array = Object.FindObjectsOfType<SemiPuke>(true);
			foreach (SemiPuke val in array)
			{
				ParticleSystem[] componentsInChildren = ((Component)((Component)val).transform.parent).GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem val2 in componentsInChildren)
				{
					if (((Object)val2).name == "Puke Bits")
					{
						Color black = Color.black;
						MainModule main = val2.main;
						((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(black);
						TrailModule trails = val2.trails;
						MinMaxGradient colorOverLifetime = ((TrailModule)(ref trails)).colorOverLifetime;
						((MinMaxGradient)(ref colorOverLifetime)).color = black;
						((MinMaxGradient)(ref colorOverLifetime)).colorMin = black;
						((MinMaxGradient)(ref colorOverLifetime)).colorMax = black;
						((TrailModule)(ref trails)).colorOverLifetime = colorOverLifetime;
						MinMaxGradient colorOverTrail = ((TrailModule)(ref trails)).colorOverTrail;
						((MinMaxGradient)(ref colorOverTrail)).color = black;
						((MinMaxGradient)(ref colorOverTrail)).colorMin = black;
						((MinMaxGradient)(ref colorOverTrail)).colorMax = black;
						((TrailModule)(ref trails)).colorOverTrail = colorOverTrail;
					}
					else
					{
						((Component)val2).gameObject.SetActive(false);
					}
				}
				Light[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<Light>(true);
				foreach (Light val3 in componentsInChildren2)
				{
					((Component)val3).gameObject.SetActive(false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(CameraZoom), "OverrideZoomSet", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float),
		typeof(float),
		typeof(GameObject),
		typeof(int)
	})]
	public static class CameraZoomOverrideZoomSet
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(CameraAim), "AimTargetSoftSet", new Type[]
	{
		typeof(Vector3),
		typeof(float),
		typeof(float),
		typeof(float),
		typeof(GameObject),
		typeof(int)
	})]
	public static class CameraAimAimTargetSoftSet
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(EnemySlowMouthCameraVisuals), "StateSet", new Type[] { typeof(State) })]
	public static class EnemySlowMouthCameraVisualsStateSet
	{
		public static void Postfix(EnemySlowMouthCameraVisuals __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			((Renderer)__instance.pukeCapsuleRenderer).enabled = false;
			ParticleSystem[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val in componentsInChildren)
			{
				if (((Object)val).name == "Puke Bits")
				{
					Color black = Color.black;
					MainModule main = val.main;
					((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(black);
					TrailModule trails = val.trails;
					MinMaxGradient colorOverLifetime = ((TrailModule)(ref trails)).colorOverLifetime;
					((MinMaxGradient)(ref colorOverLifetime)).color = black;
					((MinMaxGradient)(ref colorOverLifetime)).colorMin = black;
					((MinMaxGradient)(ref colorOverLifetime)).colorMax = black;
					((TrailModule)(ref trails)).colorOverLifetime = colorOverLifetime;
					MinMaxGradient colorOverTrail = ((TrailModule)(ref trails)).colorOverTrail;
					((MinMaxGradient)(ref colorOverTrail)).color = black;
					((MinMaxGradient)(ref colorOverTrail)).colorMin = black;
					((MinMaxGradient)(ref colorOverTrail)).colorMax = black;
					((TrailModule)(ref trails)).colorOverTrail = colorOverTrail;
				}
				else
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			Light[] componentsInChildren2 = ((Component)((Component)__instance).transform.Find("Positioning/Puke Correction/Puke")).GetComponentsInChildren<Light>(true);
			foreach (Light val2 in componentsInChildren2)
			{
				((Component)val2).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(Object), "Instantiate", new Type[]
	{
		typeof(Object),
		typeof(Vector3),
		typeof(Quaternion)
	})]
	public static class ObjectInstantiate
	{
		public static void Prefix(ref Object original)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			Object obj = original;
			GameObject val = (GameObject)(object)((obj is GameObject) ? obj : null);
			if (original == (Object)(object)AssetManager.instance.prefabTeleportEffect)
			{
				ParticleSystem[] componentsInChildren = val.GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem val2 in componentsInChildren)
				{
					EmissionModule emission = val2.emission;
					((EmissionModule)(ref emission)).enabled = false;
				}
			}
			if (original.name.Contains("Explosion") || original.name.Contains("Shockwave"))
			{
				ParticleSystem[] componentsInChildren2 = val.GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem val3 in componentsInChildren2)
				{
					if (((Object)val3).name != "Smoke")
					{
						EmissionModule emission2 = val3.emission;
						((EmissionModule)(ref emission2)).enabled = false;
					}
				}
				foreach (Light item in val.GetComponentsInChildren<Light>(true).ToList())
				{
					((Behaviour)item).enabled = false;
				}
				foreach (MeshRenderer item2 in val.GetComponentsInChildren<MeshRenderer>(true).ToList())
				{
					if (((Object)item2).name == "Sphere")
					{
						((Renderer)item2).enabled = false;
					}
				}
			}
			original = (Object)(object)val;
			if (!((Object)val).name.Contains("Uranium"))
			{
				return;
			}
			foreach (ParticleSystem item3 in val.GetComponentsInChildren<ParticleSystem>(true).ToList())
			{
				EmissionModule emission3 = item3.emission;
				((EmissionModule)(ref emission3)).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(ItemMineStun), "OnTriggered")]
	public static class ItemMineStunOnTriggered
	{
		public static void Prefix(ItemMineStun __instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			EmissionModule emission = __instance.particleFlash.emission;
			((EmissionModule)(ref emission)).enabled = false;
			EmissionModule emission2 = __instance.particleLightning.emission;
			((EmissionModule)(ref emission2)).enabled = false;
		}
	}
	[HarmonyPatch(typeof(Shader), "PropertyToID", new Type[] { typeof(string) })]
	public static class ShaderPropertyToID
	{
		public static bool Prefix(string name, ref int __result)
		{
			if (name == "_ColorOverlayAmount")
			{
				__result = 0;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(EnemyBang), "OnSpawn")]
	public static class EnemyBangOnSpawn
	{
		public static void Postfix(EnemyBang __instance)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val in componentsInChildren)
			{
				EmissionModule emission = val.emission;
				((EmissionModule)(ref emission)).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(FloaterAttackLogic), "StateSet", new Type[] { typeof(FloaterAttackState) })]
	public static class EnemyFloaterOnSpawn
	{
		public static void Postfix(FloaterAttackLogic __instance)
		{
			((Component)__instance.sphereEffects).gameObject.SetActive(false);
			((Component)__instance.upParticle).gameObject.SetActive(false);
			((Component)__instance.downParticle).gameObject.SetActive(false);
			__instance.linePrefab.gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(PlayerDeathEffects), "Trigger")]
	public static class PlayerDeathEffectsTrigger
	{
		public static void Prefix(PlayerDeathEffects __instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			EmissionModule emission = __instance.bitWeakParticles.emission;
			((EmissionModule)(ref emission)).enabled = false;
			EmissionModule emission2 = __instance.bitStrongParticles.emission;
			((EmissionModule)(ref emission2)).enabled = false;
			EmissionModule emission3 = __instance.fireParticles.emission;
			((EmissionModule)(ref emission3)).enabled = false;
			__instance.deathLight.color = Color.clear;
		}
	}
	[HarmonyPatch(typeof(ParticleScriptExplosion), "Spawn", new Type[]
	{
		typeof(Vector3),
		typeof(float),
		typeof(int),
		typeof(int),
		typeof(float),
		typeof(bool),
		typeof(bool),
		typeof(float)
	})]
	public static class ParticleScriptExplosionSpawn
	{
		public static void Postfix(ParticleScriptExplosion __instance, ref ParticlePrefabExplosion __result)
		{
			((Component)__result.light).gameObject.SetActive(false);
			((Component)__result.particleFire).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(TrapTV), "TrapActivate")]
	public static class TrapTVTrapActivate
	{
		public static void Postfix(TrapTV __instance)
		{
			__instance.TVScreen.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(LineBetweenTwoPoints), "DrawLine", new Type[]
	{
		typeof(Vector3),
		typeof(Vector3)
	})]
	public static class LineBetweenTwoPointsDrawLine
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerHealth), "MaterialEffectOverride", new Type[] { typeof(Effect) })]
	public static class PlayerHealthMaterialEffectOverride
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerHealth), "MaterialEffectOverrideRPC", new Type[] { typeof(int) })]
	public static class PlayerHealthMaterialEffectOverrideRPC
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemUpgrade), "PlayerUpgrade")]
	public static class ItemUpgradePlayerUpgrade
	{
		public static bool Prefix(ItemUpgrade __instance)
		{
			foreach (Light item in ((Component)__instance).GetComponentsInChildren<Light>(true).ToList())
			{
				((Behaviour)item).enabled = false;
			}
			foreach (ParticleSystem item2 in ((Component)__instance).GetComponentsInChildren<ParticleSystem>(true).ToList())
			{
				((Component)item2).gameObject.SetActive(false);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ValuableWizardTimeGlass), "SetStateRPC", new Type[] { typeof(States) })]
	public static class ValuableWizardTimeGlassSetStateRPC
	{
		public static void Postfix(ValuableWizardTimeGlass __instance)
		{
			foreach (ParticleSystem item in ((Component)__instance).GetComponentsInChildren<ParticleSystem>(true).ToList())
			{
				((Component)item).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerController), "OverrideLookSpeed", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float),
		typeof(float)
	})]
	public static class PlayerControllerOverrideLookSpeed
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(RoundDirector), "ExtractionCompletedAllCheck")]
	public static class RoundDirectorExtractionCompletedAllCheck
	{
		public static void Postfix()
		{
			EpiVision.Instance.turnLightsBackOn = true;
		}
	}
	[HarmonyPatch(typeof(IceSawValuable), "TrapActivate")]
	public static class IceSawValuableTrapActivate
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ClownTrap), "TouchNose")]
	public static class ClownTrapTouchNose
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ClownTrap), "TrapStop")]
	public static class ClownTrapTrapStop
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(BlenderValuable), "Update")]
	public static class BlenderValuableUpdate
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MusicBoxTrap), "MusicBoxStart")]
	public static class MusicBoxTrapMusicBoxStart
	{
		public static bool Prefix(MusicBoxTrap __instance)
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(StartRoom), "Start")]
	public static class StartRoomStart
	{
		public static void Postfix(StartRoom __instance)
		{
			Transform val = ((Component)__instance).transform.Find("Truck Shop/Audio Loop Distance");
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
			Transform val2 = ((Component)__instance).transform.Find("Grass/Truck Shop/Audio Loop Distance");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(ScreamDollValuable), "SetStateRPC")]
	public static class ScreamDollValuableSetStateRPC
	{
		public static void Prefix(ref States state)
		{
			state = (States)0;
		}
	}
	[HarmonyPatch(typeof(ScreamDollValuable), "SetState")]
	public static class ScreamDollValuableSetState
	{
		public static void Prefix(ref States state)
		{
			state = (States)0;
		}
	}
	[HarmonyPatch(typeof(IceSawValuable), "SetStateRPC")]
	public static class IceSawValuableSetStateRPC
	{
		public static void Prefix(ref States state)
		{
			state = (States)0;
		}
	}
	[HarmonyPatch(typeof(IceSawValuable), "SetState")]
	public static class IceSawValuableSetState
	{
		public static void Prefix(ref States state)
		{
			state = (States)0;
		}
	}
	[HarmonyPatch(typeof(TrapRadio), "RadioTrapActivated")]
	public static class TrapRadioRadioTrapActivated
	{
		public static void Postfix(TrapRadio __instance)
		{
			((Trap)__instance).trapActive = false;
		}
	}
	[HarmonyPatch(typeof(ValuablePropSwitch), "Setup")]
	public static class ValuablePropSwitchSetup
	{
		public static void Postfix(ValuablePropSwitch __instance)
		{
			AudioSource[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val in componentsInChildren)
			{
				val.mute = true;
			}
		}
	}
	[HarmonyPatch(typeof(PowerCrystalValuable), "GlowDim")]
	public static class PowerCrystalValuableGlowDim
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(PowerCrystalValuable), "GlowMed")]
	public static class PowerCrystalValuableGlowMed
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(PowerCrystalValuable), "GlowStrong")]
	public static class PowerCrystalValuableGlowStrong
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(GameDirector), "Update")]
	public static class GameDirectorUpdate
	{
		public static void Postfix(GameDirector __instance)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!((ButtonControl)Keyboard.current[(Key)20]).wasPressedThisFrame)
			{
				return;
			}
			Color clear = default(Color);
			foreach (PlayerAvatar player in __instance.PlayerList)
			{
				if (!SemiFunc.IsMultiplayer() || player.photonView.IsMine)
				{
					((Color)(ref clear))..ctor(1f, 0.6745f, 0.3821f, 1f);
					if (EpiVision.Instance.flashlightOn)
					{
						clear = Color.clear;
					}
					Light spotlight = ((Component)((Component)player).transform.parent.Find("Local Camera/Flashlight Target/Flashlight/")).GetComponent<FlashlightController>().spotlight;
					spotlight.color = clear;
					((Component)spotlight).gameObject.SetActive(!EpiVision.Instance.flashlightOn);
					EpiVision.Instance.flashlightOn = !EpiVision.Instance.flashlightOn;
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyGnome), "OnSpawn")]
	public static class EnemyGnomeOnSpawn
	{
		public static void Postfix(EnemyGnome __instance)
		{
			CapsuleCollider[] componentsInChildren = ((Component)((Component)__instance).transform.parent).GetComponentsInChildren<CapsuleCollider>(true);
			foreach (CapsuleCollider val in componentsInChildren)
			{
				val.radius = 2f;
			}
		}
	}
	[HarmonyPatch(typeof(ChargingStation), "ChargingEffects")]
	public static class ChargingStationChargingEffects
	{
		public static bool Prefix(ChargingStation __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			foreach (Light item in ((Component)__instance).GetComponentsInChildren<Light>().ToList())
			{
				item.color = Color.clear;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ChargingStation), "Start")]
	public static class ChargingStationStart
	{
		public static void Postfix(ParticleSystem ___lightParticle, ParticleSystem ___fireflyParticles)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			EmissionModule emission = ___lightParticle.emission;
			((EmissionModule)(ref emission)).enabled = false;
			EmissionModule emission2 = ___fireflyParticles.emission;
			((EmissionModule)(ref emission2)).enabled = false;
		}
	}
	[HarmonyPatch(typeof(Material), "SetColor", new Type[]
	{
		typeof(string),
		typeof(Color)
	})]
	public static class MaterialSetColor
	{
		public static bool Prefix(string name, Material __instance)
		{
			return (name != "_EmissionColor" && name != "_Color") || (!((Object)__instance).name.Contains("Charging Station") && !((Object)__instance).name.Contains("Mine") && !((Object)__instance).name.Contains("Floater Line"));
		}
	}
	[HarmonyPatch(typeof(ValuableBoombox), "Start")]
	public static class ValuableBoomboxStart
	{
		public static void Postfix(ValuableBoombox __instance)
		{
			((Behaviour)__instance).enabled = false;
		}
	}
	[HarmonyPatch(typeof(MenuPagePassword), "PasswordTextSet")]
	public static class MenuPagePasswordPasswordTextSet
	{
		public static void Postfix(MenuPagePassword __instance)
		{
			((Behaviour)__instance.passwordCursor).enabled = false;
		}
	}
	[HarmonyPatch(typeof(MenuElementRegion), "Update")]
	public static class MenuElementRegionUpdate
	{
		public static void Postfix(MenuElementRegion __instance)
		{
			((Behaviour)__instance.fadePanel).enabled = false;
		}
	}
	[HarmonyPatch(typeof(ValuableObject), "Discover", new Type[] { typeof(State) })]
	public static class ValuableObjectDiscover
	{
		public static void Postfix(ValuableObject __instance)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)__instance).name.Contains("Gem Burger"))
			{
				Material val = new Material(Shader.Find("Standard"));
				val.color = new Color(1f, 0f, 0.7f, 1f);
				((Renderer)((Component)((Component)__instance).transform.Find("Object/Mesh/Gem ")).GetComponent<MeshRenderer>()).material = val;
			}
			if (((Object)__instance).name.Contains("Uranium"))
			{
				Material val2 = new Material(Shader.Find("Standard"));
				val2.color = new Color(0f, 0.7f, 0f, 1f);
				MeshRenderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<MeshRenderer>();
				foreach (MeshRenderer val3 in componentsInChildren)
				{
					((Renderer)val3).material = val2;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemGunMuzzleFlash), "ActivateAllEffects")]
	public static class ItemGunMuzzleFlashActivateAllEffects
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemGunBullet), "ActivateAll")]
	public static class ItemGunBulletActivateAll
	{
		public static void Postfix(ItemGunBullet __instance)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance != (Object)null))
			{
				return;
			}
			Transform val = ((Component)__instance).transform.Find("Hit Effect");
			((Component)val.Find("Hit Light")).GetComponent<Light>().color = Color.clear;
			Transform val2 = ((Component)val).transform.Find("Extra Particles");
			if ((Object)(object)val2 != (Object)null)
			{
				ParticleSystem[] componentsInChildren = ((Component)val2).GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem val3 in componentsInChildren)
				{
					EmissionModule emission = val3.emission;
					((EmissionModule)(ref emission)).enabled = false;
				}
				((Component)val2).gameObject.SetActive(false);
			}
			Transform val4 = ((Component)val).transform.Find("Part Prefab Explosion");
			if ((Object)(object)val4 != (Object)null)
			{
				((Component)val4.Find("Point Light")).gameObject.SetActive(false);
				((Component)val4.Find("Fire")).gameObject.SetActive(false);
			}
			Transform val5 = ((Component)val).transform.Find("Particle Sparks");
			if ((Object)(object)val5 != (Object)null)
			{
				EmissionModule emission2 = ((Component)val5).GetComponent<ParticleSystem>().emission;
				((EmissionModule)(ref emission2)).enabled = false;
				((Component)val5).gameObject.SetActive(false);
			}
			Transform val6 = ((Component)val).transform.Find("Particle Smoke");
			if ((Object)(object)val5 != (Object)null)
			{
				EmissionModule emission3 = ((Component)val6).GetComponent<ParticleSystem>().emission;
				((EmissionModule)(ref emission3)).enabled = false;
				((Component)val6).gameObject.SetActive(false);
			}
			Transform val7 = ((Component)val).transform.Find("Particle Impact");
			if ((Object)(object)val7 != (Object)null)
			{
				EmissionModule emission4 = ((Component)val7).GetComponent<ParticleSystem>().emission;
				((EmissionModule)(ref emission4)).enabled = false;
				((Component)val7).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(ItemGunBullet), "Update")]
	public static class ItemGunBulletUpdate
	{
		public static void Postfix(ItemGunBullet __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance != (Object)null)
			{
				Transform val = ((Component)__instance).transform.Find("Hit Effect");
				((Component)val.Find("Hit Light")).GetComponent<Light>().color = Color.clear;
				Transform val2 = ((Component)__instance).transform.Find("Extra Particles");
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(false);
				}
				EmissionModule emission = ((Component)val.Find("Particle Smoke")).GetComponent<ParticleSystem>().emission;
				((EmissionModule)(ref emission)).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabCart), "GlitchyText")]
	public static class PhysGrabCartGlitchyText
	{
		public static bool Prefix(PhysGrabCart __instance, ref string __result)
		{
			TextMeshPro[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<TextMeshPro>(true);
			foreach (TextMeshPro val in componentsInChildren)
			{
				__result = ((TMP_Text)val).text;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PhysGrabCart), "ObjectsInCart")]
	public static class PhysGrabCartObjectsInCart
	{
		public static void Postfix(PhysGrabCart __instance)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)__instance.displayText).color = new Color(1f, 0.5529f, 0f, 1f);
		}
	}
	[HarmonyPatch(typeof(PhysGrabCart), "Start")]
	public static class PhysGrabCartStart
	{
		public static void Postfix(PhysGrabCart __instance)
		{
			((Component)__instance.thrustEffect).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(OverchargeRoundBarUI), "FlashColorLogic")]
	public static class OverchargeRoundBarUIFlashColorLogic
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(OverchargeRoundBarUI), "Show")]
	public static class OverchargeRoundBarUIShow
	{
		public static void Postfix()
		{
			EpiVision.Instance.showOvercharge = true;
		}
	}
	[HarmonyPatch(typeof(OverchargeRoundBarUI), "Update")]
	public static class OverchargeRoundBarUIUpdate
	{
		public static void Postfix(OverchargeRoundBarUI __instance)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((double)__instance.roundBar.fillAmount > 0.01)
			{
				__instance.roundBarObject.transform.localScale = Vector3.one;
				((Behaviour)__instance.roundBar).enabled = true;
			}
			else
			{
				__instance.roundBarObject.transform.localScale = Vector3.zero;
				((Behaviour)__instance.roundBar).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerAvatarOverchargeVisuals), "Start")]
	public static class PlayerAvatarOverchargeVisualsStart
	{
		public static void Postfix(PlayerAvatarOverchargeVisuals __instance)
		{
			((Component)((Component)__instance).transform.Find("PlayerAvatar Overcharge Particles")).gameObject.SetActive(false);
			((Component)((Component)__instance).transform.Find("PlayerAvatar Overcharge Light")).gameObject.SetActive(false);
			((Behaviour)__instance).enabled = false;
		}
	}
	[HarmonyPatch(typeof(PhysGrabBeam), "Start")]
	public static class PhysGrabBeamStart
	{
		public static bool Prefix(Transform ___overchargeImpact)
		{
			((Component)___overchargeImpact.Find("Particle Shockwave 2")).gameObject.SetActive(false);
			((Component)___overchargeImpact.Find("Particle Cracks")).gameObject.SetActive(false);
			((Component)___overchargeImpact.Find("Particle Ding Red")).gameObject.SetActive(false);
			((Component)___overchargeImpact.Find("Particle Ding White")).gameObject.SetActive(false);
			return true;
		}
	}
	[HarmonyPatch(typeof(GumballValuable), "InstantiateHypnosisLines")]
	public static class GumballValuableInstantiateHypnosisLines
	{
		public static void Postfix(GumballValuable __instance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			__instance.pointLight.color = new Color(0.25f, 0.25f, 0.25f);
			SizeOverLifetimeModule sizeOverLifetime = __instance.particles[1].sizeOverLifetime;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = false;
			MainModule main = __instance.particles[1].main;
			((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(new Color(0.8585f, 0.8585f, 0.8585f, 0.2f));
		}
	}
	[HarmonyPatch(typeof(GumballValuable), "OpenEyes")]
	public static class GumballValuableOpenEyes
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemCartLaser), "ShootParticles", new Type[] { typeof(bool) })]
	public static class ItemCartLaserShootParticles
	{
		public static bool Prefix(ItemCartLaser __instance)
		{
			((Component)((Component)__instance.warningLight1Light).transform.parent.parent).gameObject.SetActive(false);
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemCartCannon), "ShootParticlesPlay")]
	public static class ItemCartCannonShootParticlesPlay
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(TrafficLightValuable), "IsFlickering")]
	public static class TrafficLightValuableIsFlickering
	{
		public static void Postfix(ref bool __result)
		{
			__result = false;
		}
	}
	[HarmonyPatch(typeof(TrafficLightValuable), "RedState")]
	public static class TrafficLightValuableRedState
	{
		public static void Postfix(TrafficLightValuable __instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			EmissionModule emission = __instance.zapParticles.emission;
			((EmissionModule)(ref emission)).enabled = false;
			((Behaviour)__instance.zapLight).enabled = false;
		}
	}
	[HarmonyPatch(typeof(ItemCartCannonMain), "StateActive")]
	public static class ItemCartCannonMainStateActive
	{
		public static void Prefix(ItemCartCannonMain __instance)
		{
			Light[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Light>(true);
			foreach (Light val in componentsInChildren)
			{
				((Behaviour)val).enabled = false;
			}
			Transform val2 = ((Component)__instance).transform.Find("Mesh/Item Cannon Moving Piece /Animation Event/Particle Impact (2)");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(ItemCartLaserBuildupMeter), "Start")]
	public static class ItemCartLaserBuildupMeterStart
	{
		public static void Prefix(ItemCartLaserBuildupMeter __instance)
		{
			((Component)__instance).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(ParticlePrefabExplosion), "Start")]
	public static class ParticlePrefabExplosionStart
	{
		public static void Postfix(ParticlePrefabExplosion __instance)
		{
			((Component)((Component)__instance).transform.Find("Point Light")).gameObject.SetActive(false);
			((Component)((Component)__instance).transform.Find("Fire")).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(SpiralOnScreen), "FadeIn")]
	public static class SpiralOnScreenFadeIn
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemStunBaton), "PlayParticles")]
	public static class ItemStunBatonPlayParticles
	{
		public static void Prefix(ItemStunBaton __instance)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem[] componentsInChildren = ((Component)__instance.stunBatonEffects).GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem val in componentsInChildren)
			{
				EmissionModule emission = val.emission;
				((EmissionModule)(ref emission)).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(ItemGunLaser), "Start")]
	public static class ItemGunLaserStart
	{
		public static void Postfix(ItemGunLaser __instance)
		{
			((Component)((Component)__instance).transform.Find("Gun Muzzle")).gameObject.SetActive(false);
			((Component)__instance.particleBuildUp).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(BatteryBarEffect), "Start")]
	public static class BatteryBarEffectStart
	{
		public static void Postfix(BatteryBarEffect __instance)
		{
			((Component)__instance).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(BatteryVisualLogic), "BatteryVisualBounce")]
	public static class BatteryVisualLogicBatteryVisualBounce
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(BatteryVisualLogic), "BatteryChargeVisuals")]
	public static class BatteryVisualLogicBatteryChargeVisuals
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(GameDirector), "Start")]
	public static class GameDirectorStart
	{
		public static void Postfix(GameDirector __instance)
		{
			AudioSource component = ((Component)__instance).gameObject.GetComponent<AudioSource>();
			if ((Object)(object)component != (Object)null)
			{
				component.mute = true;
			}
		}
	}
	[HarmonyPatch(typeof(ArenaMessageUI), "ArenaText")]
	public static class ArenaMessageUIArenaText
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MuseumLaserLogic), "SetLightIntensities", new Type[] { typeof(float) })]
	public static class MuseumLaserLogicSetLightIntensities
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MuseumLaserLogic), "LaserVisuals")]
	public static class MuseumLaserLogicLaserVisuals
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(MuseumLaserLogic), "StatePoweringUp")]
	public static class MuseumLaserLogicStart
	{
		public static void Postfix(ParticleSystem __instance)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val in componentsInChildren)
			{
				EmissionModule emission = val.emission;
				((EmissionModule)(ref emission)).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(ItemLadder), "FlickerBridge")]
	public static class ItemLadderFlickerBridge
	{
		public static bool Prefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(DeathPitSaveEffect), "Start")]
	public static class DeathPitSaveEffectStart
	{
		public static void Postfix(DeathPitSaveEffect __instance)
		{
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(ItemOrbZeroGravity), "Start")]
	public static class ItemOrbZeroGravityStart
	{
		public static void Postfix(ItemOrbZeroGravity __instance)
		{
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
		}
	}
	[HarmonyPatch(typeof(ItemStunBaton), "Start")]
	public static class ItemStunBatonStart
	{
		public static void Postfix(ItemStunBaton __instance)
		{
			((Component)((Component)__instance).transform.Find("Particles")).gameObject.SetActive(false);
			((Component)((Component)__instance).transform.Find("Particles Ground Hit")).gameObject.SetActive(false);
			((Component)((Component)__instance).transform.Find("Extra Particles")).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch(typeof(Cauldron), "Start")]
	public static class CauldronStart
	{
		public static void Postfix(GameObject ___explosion, Light ___lightGreen)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			((Component)___explosion.transform.Find("Fire")).gameObject.SetActive(false);
			((Component)___explosion.transform.Find("Particle Impact")).gameObject.SetActive(false);
			___lightGreen.color = Color.clear;
		}
	}
	[HarmonyPatch(typeof(FlatScreenTV), "LateStart")]
	public static class FlatScreenTVLateStart
	{
		public static void Postfix(ref Transform ___regularPlane)
		{
			((Renderer)((Component)___regularPlane).GetComponent<MeshRenderer>()).enabled = false;
		}
	}
	[HarmonyPatch(typeof(AudioSource))]
	internal class AudioSourcePatch
	{
		[HarmonyPatch("Play", new Type[] { typeof(double) })]
		[HarmonyPatch("Play", new Type[] { })]
		[HarmonyPatch("Play", new Type[] { typeof(ulong) })]
		[HarmonyPatch("PlayDelayed", new Type[] { typeof(float) })]
		[HarmonyPatch("PlayScheduled", new Type[] { typeof(double) })]
		[HarmonyPrefix]
		public static bool Play_Patch(AudioSource __instance)
		{
			bool result = true;
			if ((Object)(object)__instance != (Object)null && (Object)(object)__instance.clip != (Object)null)
			{
				result = CheckIfMute(((Object)__instance.clip).name);
				__instance.clip = CheckIfReplace(((Object)__instance.clip).name, __instance.clip);
			}
			return result;
		}

		[HarmonyPatch("PlayOneShotHelper", new Type[]
		{
			typeof(AudioSource),
			typeof(AudioClip),
			typeof(float)
		})]
		[HarmonyPrefix]
		private static bool PlaySourceClip_Patch(AudioSource __instance, ref AudioSource source, ref AudioClip clip)
		{
			bool flag = true;
			bool flag2 = true;
			bool flag3 = true;
			if ((Object)(object)__instance != (Object)null && (Object)(object)__instance.clip != (Object)null)
			{
				flag = CheckIfMute(((Object)__instance.clip).name);
				__instance.clip = CheckIfReplace(((Object)__instance.clip).name, __instance.clip);
			}
			if ((Object)(object)source != (Object)null && (Object)(object)source.clip != (Object)null)
			{
				flag2 = CheckIfMute(((Object)source.clip).name);
				source.clip = CheckIfReplace(((Object)source.clip).name, source.clip);
			}
			if ((Object)(object)clip != (Object)null)
			{
				flag3 = CheckIfMute(((Object)clip).name);
				clip = CheckIfReplace(((Object)clip).name, clip);
			}
			return flag && flag2 && flag3;
		}

		[HarmonyPatch("PlayHelper", new Type[]
		{
			typeof(AudioSource),
			typeof(ulong)
		})]
		[HarmonyPrefix]
		private static bool PlaySource_Patch(AudioSource __instance, ref AudioSource source)
		{
			bool flag = true;
			bool flag2 = true;
			if ((Object)(object)__instance != (Object)null && (Object)(object)__instance.clip != (Object)null)
			{
				flag = CheckIfMute(((Object)__instance.clip).name);
				__instance.clip = CheckIfReplace(((Object)__instance.clip).name, __instance.clip);
			}
			if ((Object)(object)source != (Object)null && (Object)(object)source.clip != (Object)null)
			{
				flag2 = CheckIfMute(((Object)source.clip).name);
				source.clip = CheckIfReplace(((Object)source.clip).name, source.clip);
			}
			return flag && flag2;
		}

		[HarmonyPatch("PlayOneShot", new Type[] { typeof(AudioClip) })]
		[HarmonyPatch("PlayOneShot", new Type[]
		{
			typeof(AudioClip),
			typeof(float)
		})]
		[HarmonyPatch("PlayClipAtPoint", new Type[]
		{
			typeof(AudioClip),
			typeof(Vector3)
		})]
		[HarmonyPatch("PlayClipAtPoint", new Type[]
		{
			typeof(AudioClip),
			typeof(Vector3),
			typeof(float)
		})]
		[HarmonyPrefix]
		private static bool PlayClip_Patch(AudioSource __instance, ref AudioClip clip)
		{
			bool flag = true;
			bool flag2 = true;
			if ((Object)(object)__instance != (Object)null && (Object)(object)__instance.clip != (Object)null)
			{
				flag = CheckIfMute(((Object)__instance.clip).name);
				__instance.clip = CheckIfReplace(((Object)__instance.clip).name, __instance.clip);
			}
			if ((Object)(object)clip != (Object)null)
			{
				flag2 = CheckIfMute(((Object)clip).name);
				clip = CheckIfReplace(((Object)clip).name, clip);
			}
			return flag && flag2;
		}

		private static AudioClip CheckIfReplace(string name, AudioClip clip)
		{
			return clip;
		}

		private static bool CheckIfMute(string name)
		{
			string[] source = new string[172]
			{
				"extraction point locator ping", "Drone Close", "menu truck engine loop", "Ambience Loop Truck Driving", "Ambience Loop Arctic Outside", "Ambience Loop Arctic Default", "Ambience Loop Arctic Distant Mechanical", "Ambience Loop Manor Default", "Ambience Loop Wizard Default", "Ambience Loop Shop Default",
				"Ambience Loop Manor Outside", "Ambience Loop Manor Outside Creaky Metal", "Ambience Loop Museum2", "menu truck fire pass", "fire loop", "fridge loop", "prop loop furnace", "prop loop lab vat", "snd_dirt_tracker_loop", "extraction point jingle 2 local",
				"extraction point jingle 2 global", "extraction point jingle complete 2 local", "extraction point jingle complete 2 global", "extraction point activate03", "msc player do not look at", "phys grabber off01", "Glass Liquid Big - Impact - Light01", "Glass Liquid Big - Impact - Light02", "Glass Liquid Big - Impact - Light03", "Glass Liquid Big - Impact - Medium01",
				"Glass Liquid Big - Impact - Medium02", "Glass Liquid Big - Impact - Medium03", "Glass Liquid Big - Impact - Heavy01", "Glass Liquid Big - Impact - Heavy02", "Glass Liquid Big - Impact - Heavy03", "Glass Liquid Big - Break - Medium03", "Glass Liquid Big - Break - Heavy01", "Glass Liquid Big - Break - Heavy02", "Glass Liquid Big - Break - Heavy03", "Glass Liquid Big - Destroy02",
				"valuable hour glass loop", "valuable fan loop", "enemy beamer laser grace01", "enemy beamer laser grace02", "enemy beamer laser grace03", "enemy beamer attack intro", "enemy beamer attack outro", "enemy beamer attack loop", "enemy beamer laser end", "enemy beamer laser end global",
				"enemy beamer laser hit start", "enemy beamer laser hit loop", "enemy beamer laser start", "enemy beamer laser start global", "enemy ceiling eye staring loop", "enemy bowtie scream loop", "enemy bowtie scream loop global", "enemy bowtie scream stop global", "enemy floater move long01", "enemy floater clap local",
				"enemy floater clap global", "enemy floater delay attack loop", "enemy floater attack up", "enemy floater attack up global", "enemy floater attack down", "enemy floater attack down global", "enemy floater move short01", "enemy floater move short02", "enemy floater move short03", "enemy floater move long01",
				"enemy floater move long02", "enemy floater charge attack start", "enemy floater charge attack loop", "truck return", "truck return global", "truck healer close", "menu window close", "headman chase loop", "headman chase loop 2", "extraction point suck loop2",
				"extraction point suck end", "extraction point surplus light outro", "grenade shockwave countdown", "grenade shockwave explosion01", "grenade shockwave explosion02", "grenade shockwave explosion03", "grenade stun countdown", "grenade countdown", "Drone Idle Loop", "electricity zap medium01",
				"electricity zap medium02", "electricity zap medium03", "gramophone music", "trap grandfather clock bell", "geiger loop", "geiger big loop", "uranium toxic cloud small", "uranium toxic cloud big", "charging station start", "charging station loop",
				"charging station end", "player overcharge loop", "valuable gumball loop", "item laser cannon grace01", "item laser cannon grace02", "item laser cannon grace03", "item laser cannon buildup loop", "item laser cannon buildup start", "item laser cannon shoot loop", "item laser cannon laser hit loop",
				"item laser cannon laser hit start", "item laser cannon shoot start", "item laser cannon shoot start global", "item laser cannon laser hit stop", "item laser cannon shoot stop", "item laser cannon shoot stop global", "item ladder beam loop", "item ladder grow", "Phase Bridge ON - Impact - Light01", "Phase Bridge ON - Impact - Light02",
				"Phase Bridge ON - Impact - Light03", "Phase Bridge ON - Impact - Medium01", "Phase Bridge ON - Impact - Medium02", "Phase Bridge ON - Impact - Medium03", "Phase Bridge ON - Impact - Heavy01", "Phase Bridge ON - Impact - Heavy02", "Phase Bridge ON - Impact - Heavy03", "arena player dead sound", "ui moon show", "ui moon turn start",
				"ui moon turn turning", "ui moon turn end", "ui moon hide", "ambience breaker global01", "ambience breaker global02", "ambience breaker global03", "ambience breaker global04", "ambience breaker global05", "ambience breaker global06", "ambience breaker global07",
				"ambience breaker global08", "ambience breaker global09", "ambience breaker global10", "ambience breaker global11", "ambience breaker global12", "ambience breaker global13", "ambience breaker global14", "ambience breaker wizard01", "ambience breaker wizard03", "ambience breaker wizard04",
				"ambience breaker arctic03", "ambience breaker arctic04", "ambience breaker arctic05", "ambience breaker arctic06", "ambience breaker arctic08", "ambience breaker arctic10", "ambience breaker arctic12", "ambience breaker arctic13", "ambience breaker arctic14", "ambience breaker manor02",
				"ambience breaker manor03", "ambience breaker manor05", "ambience breaker manor08", "ambience breaker manor09", "ambience breaker manor10", "ambience breaker manor11", "ambience breaker manor12", "ambience breaker manor13", "ambience breaker manor14", "ambience breaker museum03",
				"ambience breaker museum06", "ambience breaker museum07"
			};
			return !source.Contains(name);
		}
	}
}