using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
[BepInPlugin("local.profile.keybindcompat", "4P Keybind Compatibility", "1.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class KeybindCompat : BaseUnityPlugin
{
	private static KeybindCompat self;

	private static BaseUnityPlugin riding;

	private Harmony harmony;

	private void Awake()
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Expected O, but got Unknown
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Expected O, but got Unknown
		//IL_00da: Expected O, but got Unknown
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Expected O, but got Unknown
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Expected O, but got Unknown
		self = this;
		if (!Chainloader.PluginInfos.TryGetValue("Ygg.BetterRiding", out var value))
		{
			return;
		}
		if (value.Metadata.Version != new Version(1, 0, 3))
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Better Riding key correction skipped: only version 1.0.3 is verified.");
			return;
		}
		riding = value.Instance;
		harmony = new Harmony("local.profile.keybindcompat");
		try
		{
			Assembly assembly = ((object)value.Instance).GetType().Assembly;
			MethodInfo methodInfo = AccessTools.Method(assembly.GetType("BetterRiding.Patches.CallOwnedPetPatch+Player_Update_Patch", throwOnError: true), "Postfix", (Type[])null, (Type[])null);
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(KeybindCompat), "AllowCompanionCommands", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(KeybindCompat), "RemapRecall", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			Type type = assembly.GetType("BetterRiding.Compendium.BetterRidingCompendium", throwOnError: true);
			harmony.Patch((MethodBase)AccessTools.Method(type, "Unlock", (Type[])null, (Type[])null), new HarmonyMethod(typeof(KeybindCompat), "FixHelpText", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(type, "RefreshKnownText", (Type[])null, (Type[])null), new HarmonyMethod(typeof(KeybindCompat), "FixHelpText", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Key correction ready: ground recall Shift+Q; existing Shift+F/Shift+V kept; inventory/build/chat contexts excluded; help text reflects configured controls.");
		}
		catch (Exception ex)
		{
			harmony.UnpatchSelf();
			((BaseUnityPlugin)this).Logger.LogError((object)("Key correction could not be applied; original mod left intact: " + ex));
		}
	}

	public static bool AllowCompanionCommands()
	{
		Player localPlayer = Player.m_localPlayer;
		if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead() || ((Character)localPlayer).InPlaceMode() || ((Character)localPlayer).IsRiding())
		{
			return false;
		}
		if (InventoryGui.IsVisible() || Minimap.IsOpen() || Menu.IsVisible() || Console.IsVisible() || StoreGui.IsVisible() || TextInput.IsVisible())
		{
			return false;
		}
		if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
		{
			return false;
		}
		if ((Object)(object)TextViewer.instance != (Object)null && TextViewer.instance.IsVisible())
		{
			return false;
		}
		if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.InPasswordDialog())
		{
			return false;
		}
		return !Input.GetKey((KeyCode)306) && !Input.GetKey((KeyCode)305) && !Input.GetKey((KeyCode)308) && !Input.GetKey((KeyCode)307);
	}

	public static IEnumerable<CodeInstruction> RemapRecall(IEnumerable<CodeInstruction> instructions)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		int num = 0;
		int index = -1;
		for (int i = 0; i < list.Count; i++)
		{
			if (CodeInstructionExtensions.LoadsConstant(list[i], 98L) && i + 2 < list.Count)
			{
				MethodInfo methodInfo = list[i + 2].operand as MethodInfo;
				if (methodInfo != null && methodInfo.DeclaringType == typeof(ZInput) && methodInfo.Name == "GetKeyDown")
				{
					num++;
					index = i;
				}
			}
		}
		if (num != 1)
		{
			throw new InvalidOperationException("Expected exactly one hardcoded B recall input; found " + num);
		}
		list[index].opcode = OpCodes.Ldc_I4;
		list[index].operand = 113;
		return list;
	}

	private static string KeyLabel(string section, string key, string fallback)
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)riding == (Object)null)
		{
			return fallback;
		}
		ConfigDefinition val = new ConfigDefinition(section, key);
		if (!riding.Config.ContainsKey(val))
		{
			return fallback;
		}
		object boxedValue = riding.Config[val].BoxedValue;
		if (boxedValue is KeyCode)
		{
			return ((object)(KeyCode)boxedValue).ToString();
		}
		if (boxedValue is KeyboardShortcut val2)
		{
			return ((object)((KeyboardShortcut)(ref val2)).MainKey).ToString();
		}
		return fallback;
	}

	public static void FixHelpText(ref string body)
	{
		if (!string.IsNullOrEmpty(body))
		{
			body = body.Replace("Shift + B", "Shift + Q").Replace("<color=#7CFC00>F</color>", "<color=#7CFC00>" + KeyLabel("5 - Mount Controls", "Flight Toggle Key (Keyboard)", "U") + "</color>").Replace("<color=#7CFC00>Z</color>", "<color=#7CFC00>" + KeyLabel("09 - Aiming", "01 - Aim Toggle Key", "K") + "</color>")
				.Replace("<color=#7CFC00>X</color>", "<color=#7CFC00>" + KeyLabel("09 - Aiming", "02 - Aim Mode Key", "L") + "</color>")
				.Replace("V - Third Attack", KeyLabel("7 - Mount Attacks", "Third Attack Key", "N") + " - Third Attack")
				.Replace("Middle Click - Secondary Attack", "Your Valheim Secondary Attack key - Secondary Attack");
		}
	}

	private void OnDestroy()
	{
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
	}
}

using System;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using ServerSideMapReborn;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
[BepInPlugin("local.profile.mapsavefix", "Profile Map Save Compatibility", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class MapSaveFix : BaseUnityPlugin
{
	private static ManualLogSource log;

	private void Awake()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Expected O, but got Unknown
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Expected O, but got Unknown
		log = ((BaseUnityPlugin)this).Logger;
		Harmony val = new Harmony("local.profile.mapsavefix");
		val.Patch((MethodBase)AccessTools.Method("ServerSideMapReborn.SaveWorld+ZnetPatchLoadMap:Postfix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(MapSaveFix), "Load", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method("ServerSideMapReborn.SaveWorld+ZnetPatchSaveWorldThread:Postfix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(MapSaveFix), "Save", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Cloud-safe exploration sidecar path fix active");
	}

	private static World WorldNow()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		return (World)AccessTools.Field(typeof(ZNet), "m_world").GetValue(null);
	}

	private static string SavePath()
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Invalid comparison between Unknown and I4
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Invalid comparison between Unknown and I4
		World val = WorldNow();
		string text = SaveSystem.GetWorldsSaveRootPath((FileSource)2);
		if ((int)val.m_fileSource == 4)
		{
			text = Path.Combine(text, "ServerSideMapCloud");
		}
		Directory.CreateDirectory(text);
		return Path.Combine(text, ((int)val.m_fileSource == 4) ? (val.m_uid + ".mod.serversidemap.explored") : (val.m_worldName + ".mod.serversidemap.explored"));
	}

	private static bool Load()
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		try
		{
			string text = SavePath();
			byte[] array = (File.Exists(text) ? File.ReadAllBytes(text) : null);
			if (array != null && array.Length > 0)
			{
				ExplorationDatabase.SetMapData(new ZPackage(array));
			}
			else
			{
				ExplorationDatabase.SetMapData(ExplorationDatabase.Default());
			}
			log.LogInfo((object)("Exploration sidecar loaded: " + text));
		}
		catch (Exception ex)
		{
			log.LogError((object)ex);
			ExplorationDatabase.SetMapData(ExplorationDatabase.Default());
		}
		return false;
	}

	private static bool Save()
	{
		try
		{
			byte[] array = ExplorationDatabase.GetMapData().GetArray();
			if (array.Length > 0)
			{
				AtomicFile.Write(SavePath(), array);
			}
		}
		catch (Exception ex)
		{
			log.LogError((object)("Exploration save failed (world save retained): " + ex));
		}
		return false;
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyVersion("0.0.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("local.profile.periodicstutterfix", "Periodic Stutter Fix", "1.7.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class PeriodicStutterFix : BaseUnityPlugin
{
	private static readonly object gate = new object();

	private static readonly HashSet<string> missing = new HashSet<string>();

	private static ConfigEntry<bool> cacheEnabled;

	private static ConfigEntry<bool> ridingEnabled;

	private static ConfigEntry<bool> containerCleanup;

	private static ConfigEntry<bool> keyboardVibration;

	private static ConfigEntry<bool> blueprintPolling;

	private static ConfigEntry<bool> optionalBridge;

	private static FieldInfo blueprintWatcher;

	private static FieldInfo blueprintFault;

	private static float nextBlueprintEnsure;

	private static volatile bool dataForgePresent;

	private static ConfigEntry<bool> skipIdleSummonScans;

	private static ConfigEntry<bool> skipZeroRainWork;

	private static ConfigEntry<bool> quietRecipeMisses;

	private static ConfigEntry<bool> skipUnusedFoodEnumeration;

	private static ConfigEntry<bool> guardKinematicFloaters;

	private static ConfigEntry<KeyboardShortcut> unsummonKey;

	private static ConfigEntry<float> maxRainDamage;

	private static readonly List<Character> emptyCharacters = new List<Character>();

	private static readonly List<IList> containerRegistries = new List<IList>();

	private static PeriodicStutterFix self;

	private FileSystemWatcher watcher;

	private Harmony harmony;

	private static ConfigEntry<bool> fixWizardryEffects;

	private static bool wizardrySupported;

	private static readonly HashSet<string> WizardrySounds = new HashSet<string>(StringComparer.Ordinal) { "sfx_summonsurtling_cast_TW", "sfx_summonsurtling_prespawn_TW", "sfx_surtling_pet_TW", "sfx_summonsurtling_spawn_TW" };

	private static readonly FieldInfo timedView = AccessTools.Field(typeof(TimedDestruction), "m_nview");

	public static int SkippedFoodEnumerations { get; private set; }

	public static int SkippedKinematicWrites { get; private set; }

	public static int SkippedSummonScans { get; private set; }

	public static int SkippedRainChecks { get; private set; }

	public static int SuppressedRecipeMessages { get; private set; }

	public static bool BlueprintPollingApplied { get; private set; }

	public static bool OptionalBridgeApplied { get; private set; }

	public static int SkippedBlueprintPolls { get; private set; }

	public static int SkippedMissingBridgeLookups { get; private set; }

	public static int ReleasedContainerReferences { get; private set; }

	public static int SkippedKeyboardVibrations { get; private set; }

	public static int RegistryCount => containerRegistries.Count;

	public static int RepairedMaterialBlocks { get; private set; }

	public static bool RidingPatchApplied { get; private set; }

	public static int RepairedSoundNetworkViews { get; private set; }

	public static int PreventedNestedSoundViews { get; private set; }

	private void Awake()
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Expected O, but got Unknown
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Expected O, but got Unknown
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Expected O, but got Unknown
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Expected O, but got Unknown
		//IL_01c0: Expected O, but got Unknown
		//IL_0337: Unknown result type (might be due to invalid IL or missing references)
		//IL_0343: Expected O, but got Unknown
		//IL_0430: Unknown result type (might be due to invalid IL or missing references)
		//IL_043e: Expected O, but got Unknown
		self = this;
		cacheEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Enable DataForge Cache", true, "Cache unsuccessful optional DataForge assembly lookups. Installing or loading an assembly invalidates the cache.");
		ridingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Enable Better Riding Optimization", true, "Use Valheim's live character registry for Better Riding 1.0.3 dragon tracking. Keeps bonding rules and map pins.");
		harmony = new Harmony("local.profile.periodicstutterfix");
		containerCleanup = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Enable Container Registry Cleanup", true, "Remove only unloaded Container references from AutomaticFuel registry. Keeps inventories and access checks unchanged.");
		keyboardVibration = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Skip Keyboard UI Vibration Objects", true, "Do not instantiate controller-only UI vibration sound objects for mouse/keyboard input. Normal UI/world sound and active controller/touch feedback remain unchanged.");
		RegisterContainerList("TastyChickenLegs.AutomaticFuel", "AutomaticFuel.AutomaticFuelPlugin", "ContainerList");
		RegisterContainerList("TastyChickenLegs.AutomaticFuel", "AutomaticFuel.Configs", "ContainerList");
		harmony.Patch((MethodBase)AccessTools.Method(typeof(Container), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "TrackContainerLifetime", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(GamepadRumble), "PlayGlobalSelectVibration", (Type[])null, (Type[])null), new HarmonyMethod(typeof(PeriodicStutterFix), "AllowGlobalSelectVibration", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo method = typeof(Utility).GetMethod("TryResolveDllAssembly", new Type[3]
		{
			typeof(AssemblyName),
			typeof(string),
			typeof(Assembly).MakeByRefType()
		});
		harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(PeriodicStutterFix), "Before", (Type[])null), new HarmonyMethod(typeof(PeriodicStutterFix), "After", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		AppDomain.CurrentDomain.AssemblyLoad += Loaded;
		InstallMeasuredOptimizations();
		InstallCombatRainOptimizations();
		InstallAdditionalOptimizations();
		InstallNetworkEffectFix();
		try
		{
			watcher = new FileSystemWatcher(Paths.PluginPath, "DataForge.dll");
			watcher.IncludeSubdirectories = true;
			watcher.Created += Changed;
			watcher.Changed += Changed;
			watcher.Deleted += Changed;
			watcher.Renamed += Renamed;
			watcher.EnableRaisingEvents = true;
		}
		catch (Exception ex)
		{
			cacheEnabled.Value = false;
			((BaseUnityPlugin)this).Logger.LogWarning((object)("DataForge cache disabled because file monitoring failed: " + ex.Message));
		}
		if (Chainloader.PluginInfos.TryGetValue("Ygg.BetterRiding", out var value))
		{
			if (value.Metadata.Version == new Version(1, 0, 3))
			{
				try
				{
					Type type = ((object)value.Instance).GetType().Assembly.GetType("BetterRiding.Behaviour.BondedDragonMapTracker", throwOnError: true);
					harmony.Patch((MethodBase)AccessTools.Method(type, "UpdateLoadedDragons", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "OptimizeCharacterLookup", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Better Riding optimization was not applied: " + ex.Message));
				}
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Better Riding optimization skipped for untested version " + value.Metadata.Version));
			}
		}
		Type nestedType = typeof(MaterialMan).GetNestedType("PropertyContainer", BindingFlags.NonPublic);
		MethodInfo methodInfo = ((nestedType == null) ? null : AccessTools.Method(nestedType, "UpdateBlock", (Type[])null, (Type[])null));
		FieldInfo fieldInfo = ((nestedType == null) ? null : AccessTools.Field(nestedType, "m_propertyBlock"));
		if (methodInfo != null && fieldInfo != null && fieldInfo.FieldType == typeof(MaterialPropertyBlock))
		{
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(PeriodicStutterFix), "EnsureMaterialBlock", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"MaterialMan missing property-block initialization guard ready.");
		}
		else
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"MaterialMan guard skipped: unsupported layout.");
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)("DataForge lookup cache ready; Better Riding registry optimization applied=" + RidingPatchApplied + ". Gameplay rules unchanged."));
	}

	private void InstallMeasuredOptimizations()
	{
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a3: Expected O, but got Unknown
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e2: Expected O, but got Unknown
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Expected O, but got Unknown
		blueprintPolling = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Throttle Blueprint Directory Checks", true, "Check Homestead's healthy blueprint directory once per second instead of every rendered frame. File change callbacks still run every frame. Reconnect errors and initial setup keep their original behavior.");
		optionalBridge = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Skip Missing DataForge Bridge Lookups", true, "Skip BossRules optional DataForge API discovery only while DataForge is absent. Assembly loads or a DataForge.dll filesystem event re-enable original discovery. Does not change boss rules.");
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		foreach (Assembly assembly in assemblies)
		{
			if (assembly.GetName().Name == "DataForge")
			{
				dataForgePresent = true;
			}
		}
		try
		{
			using IEnumerator<string> enumerator = Directory.EnumerateFiles(Paths.PluginPath, "DataForge.dll", SearchOption.AllDirectories).GetEnumerator();
			if (enumerator.MoveNext())
			{
				string current = enumerator.Current;
				dataForgePresent = true;
			}
		}
		catch
		{
			dataForgePresent = true;
		}
		if (Chainloader.PluginInfos.TryGetValue("sighsorry.Homestead", out var value) && (value.Metadata.Version == new Version(1, 3, 5) || value.Metadata.Version == new Version(1, 3, 7)))
		{
			Type type = ((object)value.Instance).GetType().Assembly.GetType("Homestead.ZoneBlueprintDirectoryWatcher");
			blueprintWatcher = AccessTools.Field(type, "_watcher");
			blueprintFault = AccessTools.Field(type, "_watcherFaulted");
			if (blueprintWatcher != null && blueprintFault != null)
			{
				harmony.Patch((MethodBase)AccessTools.Method(type, "Ensure", (Type[])null, (Type[])null), new HarmonyMethod(typeof(PeriodicStutterFix), "AllowBlueprintEnsure", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)AccessTools.Method(type, "Reset", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "ResetBlueprintSchedule", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				BlueprintPollingApplied = true;
			}
		}
		if (Chainloader.PluginInfos.TryGetValue("sighsorry.BossRules", out value) && value.Metadata.Version == new Version(1, 1, 8))
		{
			Type type = ((object)value.Instance).GetType().Assembly.GetType("BossRules.DataForgeStatusEffectBridge");
			harmony.Patch((MethodBase)AccessTools.Method(type, "TryResolveAndSubscribe", (Type[])null, (Type[])null), new HarmonyMethod(typeof(PeriodicStutterFix), "AllowOptionalBridgeLookup", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			OptionalBridgeApplied = true;
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)("Measured optimizations ready: blueprint polling=" + BlueprintPollingApplied + ", optional bridge=" + OptionalBridgeApplied));
	}

	private void InstallCombatRainOptimizations()
	{
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Expected O, but got Unknown
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Expected O, but got Unknown
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Expected O, but got Unknown
		skipIdleSummonScans = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Skip Idle Summon Dismiss Scans", true, "MagicRevamp 1.5.1: scan characters for dismissing summons only when the existing unsummon shortcut is pressed. Spell cycling is unchanged.");
		skipZeroRainWork = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Skip Disabled Rain Decay Work", true, "No Rain Damage 1.3.1: skip rain-decay-only checks when Max Damage is zero. Rain visuals, structural support, snow, fire and other damage remain unchanged.");
		quietRecipeMisses = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Suppress Repeated Recipe Miss Debug Logs", true, "Suppress only Recycle N Reclaim's repeated missing-recipe debug messages. Recipe analysis, UI explanations, warnings and errors remain active.");
		if (Chainloader.PluginInfos.TryGetValue("blacks7ar.MagicRevamp", out var value) && value.Metadata.Version == new Version(1, 5, 1))
		{
			Type type = ((object)value.Instance).GetType();
			unsummonKey = (ConfigEntry<KeyboardShortcut>)AccessTools.Field(type, "_unSummonKey").GetValue(null);
			harmony.Patch((MethodBase)AccessTools.Method(type, "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "GateSummonEnumeration", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
		}
		if (Chainloader.PluginInfos.TryGetValue("uk.co.oliapps.valheim.noraindamage", out value) && value.Metadata.Version == new Version(1, 3, 1))
		{
			Type type = ((object)value.Instance).GetType();
			maxRainDamage = (ConfigEntry<float>)AccessTools.Field(type, "maxRainDamagePercentage").GetValue(null);
			harmony.Patch((MethodBase)AccessTools.Method(type, "Prefix", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "GateRainDecay", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
		}
		if (Chainloader.PluginInfos.TryGetValue("Azumatt.Recycle_N_Reclaim", out value) && value.Metadata.Version == new Version(1, 4, 5))
		{
			Type type = ((object)value.Instance).GetType().Assembly.GetType("Recycle_N_Reclaim.GamePatches.Recycling.Reclaimer", throwOnError: true);
			harmony.Patch((MethodBase)AccessTools.Method(type, "TryFindRecipeForItem", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "QuietMissingRecipeLog", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
		}
	}

	private void InstallAdditionalOptimizations()
	{
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Expected O, but got Unknown
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0189: Expected O, but got Unknown
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: Expected O, but got Unknown
		skipUnusedFoodEnumeration = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Skip Unused Renegade Food Enumeration", true, "RenegadeVikings 1.4.2: skip the unused food filter inside nearby-container discovery. Actual food selection, feeding, container search order, range and frequency remain unchanged.");
		guardKinematicFloaters = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Guard Kinematic Magic Item Physics", true, "MagicRevamp 1.5.1: avoid unsupported velocity writes and forces on kinematic floating items. Dynamic item physics, visual bobbing and terrain/height positioning remain unchanged.");
		if (Chainloader.PluginInfos.TryGetValue("blacks7ar.RenegadeVikings", out var value) && value.Metadata.Version == new Version(1, 4, 2))
		{
			try
			{
				Type type = ((object)value.Instance).GetType().Assembly.GetType("RenegadeVikings.Utilities.Helper", throwOnError: true);
				harmony.Patch((MethodBase)AccessTools.Method(type, "GetNearbyContainers", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "RemoveUnusedFoodFilter", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"RenegadeVikings unused container-food enumeration optimization ready.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("RenegadeVikings optimization skipped: " + ex.Message));
			}
		}
		if (Chainloader.PluginInfos.TryGetValue("blacks7ar.MagicRevamp", out value) && value.Metadata.Version == new Version(1, 5, 1))
		{
			try
			{
				Type type = ((object)value.Instance).GetType().Assembly.GetType("MagicRevamp.Functions.CustomFloater", throwOnError: true);
				harmony.Patch((MethodBase)AccessTools.Method(type, "FixedUpdate", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "GuardFloaterPhysics", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)AccessTools.Method(type, "TerrainCheck", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "GuardFloaterTerrainVelocity", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"MagicRevamp kinematic item physics guards ready.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("MagicRevamp floater guards skipped: " + ex.Message));
			}
		}
	}

	public static IEnumerable<CodeInstruction> RemoveUnusedFoodFilter(IEnumerable<CodeInstruction> instructions)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		int num = 0;
		foreach (CodeInstruction item in list)
		{
			MethodInfo methodInfo = item.operand as MethodInfo;
			if (item.opcode == OpCodes.Call && methodInfo != null && methodInfo.DeclaringType == typeof(Enumerable) && methodInfo.Name == "Where" && methodInfo.IsGenericMethod && methodInfo.GetGenericArguments()[0] == typeof(ItemData) && methodInfo.GetParameters().Length == 2 && methodInfo.GetParameters()[1].ParameterType == typeof(Func<ItemData, bool>))
			{
				item.operand = AccessTools.Method(typeof(PeriodicStutterFix), "UnusedFoodFilter", (Type[])null, (Type[])null);
				num++;
			}
		}
		if (num != 1)
		{
			throw new InvalidOperationException("Expected exactly one unused food Where filter, found " + num);
		}
		return list;
	}

	public static IEnumerable<ItemData> UnusedFoodFilter(IEnumerable<ItemData> source, Func<ItemData, bool> predicate)
	{
		if (!skipUnusedFoodEnumeration.Value)
		{
			return source.Where(predicate);
		}
		SkippedFoodEnumerations++;
		return Enumerable.Empty<ItemData>();
	}

	public static IEnumerable<CodeInstruction> GuardFloaterPhysics(IEnumerable<CodeInstruction> instructions)
	{
		return ReplaceFloaterPhysics(instructions, 2, 1, 1);
	}

	public static IEnumerable<CodeInstruction> GuardFloaterTerrainVelocity(IEnumerable<CodeInstruction> instructions)
	{
		return ReplaceFloaterPhysics(instructions, 1, 0, 0);
	}

	private static IEnumerable<CodeInstruction> ReplaceFloaterPhysics(IEnumerable<CodeInstruction> instructions, int expectedLinear, int expectedAngular, int expectedForce)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		MethodInfo objB = AccessTools.PropertySetter(typeof(Rigidbody), "linearVelocity");
		MethodInfo objB2 = AccessTools.PropertySetter(typeof(Rigidbody), "angularVelocity");
		MethodInfo objB3 = AccessTools.Method(typeof(Rigidbody), "AddForce", new Type[2]
		{
			typeof(Vector3),
			typeof(ForceMode)
		}, (Type[])null);
		foreach (CodeInstruction item in list)
		{
			if (!(item.opcode != OpCodes.Call) || !(item.opcode != OpCodes.Callvirt))
			{
				string text = null;
				if (object.Equals(item.operand, objB))
				{
					text = "SetFloaterLinearVelocity";
					num++;
				}
				else if (object.Equals(item.operand, objB2))
				{
					text = "SetFloaterAngularVelocity";
					num2++;
				}
				else if (object.Equals(item.operand, objB3))
				{
					text = "AddFloaterForce";
					num3++;
				}
				if (text != null)
				{
					item.opcode = OpCodes.Call;
					item.operand = AccessTools.Method(typeof(PeriodicStutterFix), text, (Type[])null, (Type[])null);
				}
			}
		}
		if (num != expectedLinear || num2 != expectedAngular || num3 != expectedForce)
		{
			throw new InvalidOperationException("Floater call layout changed: " + num + "," + num2 + "," + num3);
		}
		return list;
	}

	private static bool UnsupportedKinematicWrite(Rigidbody body)
	{
		if (!guardKinematicFloaters.Value || (Object)(object)body == (Object)null || !body.isKinematic)
		{
			return false;
		}
		SkippedKinematicWrites++;
		return true;
	}

	public static void SetFloaterLinearVelocity(Rigidbody body, Vector3 velocity)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		if (!UnsupportedKinematicWrite(body))
		{
			body.linearVelocity = velocity;
		}
	}

	public static void SetFloaterAngularVelocity(Rigidbody body, Vector3 velocity)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		if (!UnsupportedKinematicWrite(body))
		{
			body.angularVelocity = velocity;
		}
	}

	public static void AddFloaterForce(Rigidbody body, Vector3 force, ForceMode mode)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		if (!UnsupportedKinematicWrite(body))
		{
			body.AddForce(force, mode);
		}
	}

	private static IEnumerable<CodeInstruction> ReplaceOne(IEnumerable<CodeInstruction> code, MethodInfo from, MethodInfo to)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(code);
		int num = 0;
		foreach (CodeInstruction item in list)
		{
			if ((item.opcode == OpCodes.Call || item.opcode == OpCodes.Callvirt) && object.Equals(item.operand, from))
			{
				item.opcode = OpCodes.Call;
				item.operand = to;
				num++;
			}
		}
		if (num != 1)
		{
			throw new InvalidOperationException(string.Concat("Scoped optimization expected one call to ", from, ", found ", num));
		}
		return list;
	}

	public static IEnumerable<CodeInstruction> GateSummonEnumeration(IEnumerable<CodeInstruction> code)
	{
		return ReplaceOne(code, AccessTools.Method(typeof(Character), "GetAllCharacters", (Type[])null, (Type[])null), AccessTools.Method(typeof(PeriodicStutterFix), "CharactersForDismiss", (Type[])null, (Type[])null));
	}

	public static List<Character> CharactersForDismiss()
	{
		//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)
		if (skipIdleSummonScans.Value)
		{
			KeyboardShortcut value = unsummonKey.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown())
			{
				SkippedSummonScans++;
				return emptyCharacters;
			}
		}
		return Character.GetAllCharacters();
	}

	public static IEnumerable<CodeInstruction> GateRainDecay(IEnumerable<CodeInstruction> code)
	{
		return ReplaceOne(code, AccessTools.Method(typeof(WearNTear), "IsWet", (Type[])null, (Type[])null), AccessTools.Method(typeof(PeriodicStutterFix), "RainDecayNeedsWetCheck", (Type[])null, (Type[])null));
	}

	public static bool RainDecayNeedsWetCheck(WearNTear piece)
	{
		if (skipZeroRainWork.Value && maxRainDamage.Value <= 0f)
		{
			SkippedRainChecks++;
			return false;
		}
		return piece.IsWet();
	}

	public static IEnumerable<CodeInstruction> QuietMissingRecipeLog(IEnumerable<CodeInstruction> code)
	{
		return ReplaceOne(code, AccessTools.Method(typeof(ManualLogSource), "LogDebug", new Type[1] { typeof(object) }, (Type[])null), AccessTools.Method(typeof(PeriodicStutterFix), "RecipeMissLog", (Type[])null, (Type[])null));
	}

	public static void RecipeMissLog(ManualLogSource source, object message)
	{
		if (quietRecipeMisses.Value)
		{
			SuppressedRecipeMessages++;
		}
		else
		{
			source.LogDebug(message);
		}
	}

	public static bool AllowBlueprintEnsure()
	{
		if (!blueprintPolling.Value || blueprintWatcher.GetValue(null) == null || (bool)blueprintFault.GetValue(null))
		{
			return true;
		}
		float realtimeSinceStartup = Time.realtimeSinceStartup;
		if (realtimeSinceStartup >= nextBlueprintEnsure)
		{
			nextBlueprintEnsure = realtimeSinceStartup + 1f;
			return true;
		}
		SkippedBlueprintPolls++;
		return false;
	}

	public static void ResetBlueprintSchedule()
	{
		nextBlueprintEnsure = 0f;
	}

	public static bool AllowOptionalBridgeLookup()
	{
		if (!optionalBridge.Value || dataForgePresent)
		{
			return true;
		}
		SkippedMissingBridgeLookups++;
		return false;
	}

	public static void EnsureMaterialBlock(ref MaterialPropertyBlock ___m_propertyBlock)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Expected O, but got Unknown
		if (___m_propertyBlock == null)
		{
			___m_propertyBlock = new MaterialPropertyBlock();
			RepairedMaterialBlocks++;
			if (RepairedMaterialBlocks == 1)
			{
				((BaseUnityPlugin)self).Logger.LogInfo((object)"Initialized a missing MaterialMan property block; original rendering update will continue.");
			}
		}
	}

	private void RegisterContainerList(string guid, string type, string field)
	{
		if (Chainloader.PluginInfos.TryGetValue(guid, out var value))
		{
			Type type2 = ((object)value.Instance).GetType().Assembly.GetType(type);
			FieldInfo fieldInfo = ((type2 == null) ? null : AccessTools.Field(type2, field));
			IList list = ((fieldInfo == null) ? null : (fieldInfo.GetValue(null) as IList));
			if (list != null)
			{
				containerRegistries.Add(list);
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Container lifetime cleanup unavailable: " + guid));
			}
		}
	}

	public static void TrackContainerLifetime(Container __instance)
	{
		if (containerCleanup.Value && !((Object)(object)__instance == (Object)null) && !((Object)(object)((Component)__instance).GetComponent<LocalContainerRegistryLifetime>() != (Object)null))
		{
			((Component)__instance).gameObject.AddComponent<LocalContainerRegistryLifetime>().Target = __instance;
		}
	}

	public static void ReleaseContainer(Container container)
	{
		if (!containerCleanup.Value || object.ReferenceEquals(container, null))
		{
			return;
		}
		foreach (IList containerRegistry in containerRegistries)
		{
			for (int num = containerRegistry.Count - 1; num >= 0; num--)
			{
				if (object.ReferenceEquals(containerRegistry[num], container))
				{
					containerRegistry.RemoveAt(num);
					ReleasedContainerReferences++;
				}
			}
		}
	}

	public static bool AllowGlobalSelectVibration()
	{
		if (!keyboardVibration.Value || ZInput.IsGamepadActive() || ZInput.IsTouchActive())
		{
			return true;
		}
		SkippedKeyboardVibrations++;
		return false;
	}

	private static void Clear()
	{
		lock (gate)
		{
			missing.Clear();
		}
	}

	private static void Loaded(object s, AssemblyLoadEventArgs e)
	{
		if (e.LoadedAssembly.GetName().Name == "DataForge")
		{
			dataForgePresent = true;
		}
		Clear();
	}

	private static void Changed(object s, FileSystemEventArgs e)
	{
		dataForgePresent = true;
		Clear();
	}

	private static void Renamed(object s, RenamedEventArgs e)
	{
		dataForgePresent = true;
		Clear();
	}

	private static bool Before(AssemblyName assemblyName, string directory, ref Assembly assembly, ref bool __result)
	{
		if (!cacheEnabled.Value || assemblyName.Name != "DataForge")
		{
			return true;
		}
		lock (gate)
		{
			if (missing.Contains(assemblyName.FullName + "|" + directory))
			{
				assembly = null;
				__result = false;
				return false;
			}
		}
		return true;
	}

	private static void After(AssemblyName assemblyName, string directory, bool __result)
	{
		if (cacheEnabled.Value && assemblyName.Name == "DataForge" && !__result)
		{
			lock (gate)
			{
				missing.Add(assemblyName.FullName + "|" + directory);
			}
		}
	}

	private static IEnumerable<CodeInstruction> OptimizeCharacterLookup(IEnumerable<CodeInstruction> instructions)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		int num = 0;
		int index = -1;
		for (int i = 0; i < list.Count; i++)
		{
			MethodInfo methodInfo = list[i].operand as MethodInfo;
			if (list[i].opcode == OpCodes.Call && methodInfo != null && methodInfo.DeclaringType == typeof(Object) && methodInfo.Name == "FindObjectsOfType" && methodInfo.IsGenericMethod && methodInfo.GetGenericArguments()[0] == typeof(Character) && methodInfo.GetParameters().Length == 0)
			{
				num++;
				index = i;
			}
		}
		if (num != 1)
		{
			((BaseUnityPlugin)self).Logger.LogWarning((object)"Better Riding lookup signature changed; optimization skipped.");
			return list;
		}
		list[index].operand = AccessTools.Method(typeof(PeriodicStutterFix), "GetActiveCharacters", (Type[])null, (Type[])null);
		RidingPatchApplied = true;
		return list;
	}

	public static Character[] GetActiveCharacters()
	{
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Invalid comparison between Unknown and I4
		if (!ridingEnabled.Value)
		{
			return Object.FindObjectsOfType<Character>();
		}
		List<Character> list = new List<Character>();
		foreach (Character allCharacter in Character.GetAllCharacters())
		{
			if ((Object)(object)allCharacter != (Object)null && ((Component)allCharacter).gameObject.activeInHierarchy && (((Object)allCharacter).hideFlags & 0x34) == 0 && (((Object)((Component)allCharacter).gameObject).hideFlags & 0x34) == 0)
			{
				list.Add(allCharacter);
			}
		}
		list.Sort((Character a, Character b) => ((Object)a).GetInstanceID().CompareTo(((Object)b).GetInstanceID()));
		return list.ToArray();
	}

	private void InstallNetworkEffectFix()
	{
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Expected O, but got Unknown
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Expected O, but got Unknown
		fixWizardryEffects = ((BaseUnityPlugin)this).Config.Bind<bool>("Optimizations", "Repair Wizardry Summon Sound Networking", true, "Wizardry 1.2.3: materialize the two Surtling sound prefabs whose incoming ZDOs have no root ZNetView. Skip only nested network views of the four audited temporary Surtling sounds. Sound, timeout and summon statistics remain unchanged. Install on every peer.");
		wizardrySupported = Chainloader.PluginInfos.TryGetValue("Therzie.Wizardry", out var value) && value.Metadata.Version == new Version(1, 2, 3);
		if (wizardrySupported && timedView != null)
		{
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ZNetScene), "CreateObject", new Type[1] { typeof(ZDO) }, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(PeriodicStutterFix), "RepairIncomingSoundClone", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ZNetView), "Awake", (Type[])null, (Type[])null), new HarmonyMethod(typeof(PeriodicStutterFix), "AllowSoundNetworkView", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Wizardry 1.2.3 Surtling sound network-object repair ready.");
		}
	}

	public static IEnumerable<CodeInstruction> RepairIncomingSoundClone(IEnumerable<CodeInstruction> instructions)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		int num = 0;
		foreach (CodeInstruction item in list)
		{
			MethodInfo methodInfo = item.operand as MethodInfo;
			if (item.opcode == OpCodes.Call && methodInfo != null && methodInfo.DeclaringType == typeof(Object) && methodInfo.Name == "Instantiate" && methodInfo.IsGenericMethod && methodInfo.GetGenericArguments()[0] == typeof(GameObject) && methodInfo.GetParameters().Length == 3 && methodInfo.GetParameters()[1].ParameterType == typeof(Vector3) && methodInfo.GetParameters()[2].ParameterType == typeof(Quaternion))
			{
				item.operand = AccessTools.Method(typeof(PeriodicStutterFix), "InstantiateNetworkSound", (Type[])null, (Type[])null);
				num++;
			}
		}
		if (num != 1)
		{
			throw new InvalidOperationException("Expected one network Instantiate<GameObject>, found " + num);
		}
		return list;
	}

	public static GameObject InstantiateNetworkSound(GameObject prefab, Vector3 position, Quaternion rotation)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Object.Instantiate<GameObject>(prefab, position, rotation);
		if (!fixWizardryEffects.Value || !wizardrySupported || (Object)(object)val == (Object)null || ZNetView.m_initZDO == null || (((Object)prefab).name != "sfx_summonsurtling_cast_TW" && ((Object)prefab).name != "sfx_summonsurtling_prespawn_TW") || (Object)(object)val.GetComponent<ZNetView>() != (Object)null)
		{
			return val;
		}
		ZNetView value = val.AddComponent<ZNetView>();
		TimedDestruction component = val.GetComponent<TimedDestruction>();
		if ((Object)(object)component != (Object)null)
		{
			timedView.SetValue(component, value);
		}
		RepairedSoundNetworkViews++;
		return val;
	}

	public static bool AllowSoundNetworkView(ZNetView __instance)
	{
		if (!wizardrySupported || !fixWizardryEffects.Value || (Object)(object)__instance == (Object)null)
		{
			return true;
		}
		string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
		if (!WizardrySounds.Contains(prefabName) || (Object)(object)((Component)__instance).transform.parent == (Object)null)
		{
			return true;
		}
		ZNetView componentInParent = ((Component)((Component)__instance).transform.parent).GetComponentInParent<ZNetView>();
		if ((Object)(object)componentInParent == (Object)null)
		{
			return true;
		}
		Object.Destroy((Object)(object)__instance);
		PreventedNestedSoundViews++;
		return false;
	}

	private void OnDestroy()
	{
		AppDomain.CurrentDomain.AssemblyLoad -= Loaded;
		if (watcher != null)
		{
			watcher.Dispose();
		}
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		Clear();
		containerRegistries.Clear();
	}
}
public sealed class LocalContainerRegistryLifetime : MonoBehaviour
{
	public Container Target;

	private void OnDestroy()
	{
		PeriodicStutterFix.ReleaseContainer(Target);
	}
}