using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using AssetsTools.NET;
using AssetsTools.NET.Extra;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using ShaderHelperForMac.Commands;
using ShaderHelperForMac.Config;
using ShaderHelperForMac.Diagnostics;
using ShaderHelperForMac.Provenance;
using ShaderHelperForMac.Replacement;
using ShaderHelperForMac.Shaders;
using ShaderHelperForMac.Sweep;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ShaderHelperForMac")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("3.2.0.0")]
[assembly: AssemblyInformationalVersion("3.2.0+ed52adef9958d16b08ea973bab179130d4c353bc")]
[assembly: AssemblyProduct("ShaderHelperForMac")]
[assembly: AssemblyTitle("ShaderHelperForMac")]
[assembly: AssemblyVersion("3.2.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ShaderHelperForMac
{
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	internal static class PatchZNetSceneAwake
	{
		private static void Prefix()
		{
			Plugin.RetroactiveBundleSweep("ZNetScene.Awake prefix");
		}

		private static void Postfix()
		{
			Plugin.Log.LogDebug((object)"[ZNetScene.Awake] Postfix — running post-ZNetScene sweep.");
			Plugin._zNetSceneAwakeFired = true;
			Plugin.TryUpgradeFallbackShader();
			Plugin.TryUpgradeTransparentShader();
			Plugin.RefreshCanonicalShaderIdsFromLoadedAssets();
			Plugin.CheckCachedVanillaCacheVersionDrift();
			if ((Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Plugin.Instance.SweepMaterialsCoroutine("ZNetScene.Awake"));
			}
		}
	}
	[HarmonyPatch(typeof(Location), "Awake")]
	internal static class PatchLocationAwake
	{
		private static void Postfix()
		{
			Plugin.Log.LogDebug((object)"[Location.Awake] Postfix — sweeping materials after location/dungeon spawn.");
			if ((Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Plugin.Instance.SweepMaterialsCoroutine("Location.Awake"));
			}
		}
	}
	[HarmonyPatch]
	internal static class PatchMeleeWeaponTrailStartProbe
	{
		private static readonly FieldInfo? _materialField = AccessTools.Field(AccessTools.TypeByName("MeleeWeaponTrail"), "_material");

		private static readonly FieldInfo? _trailObjectField = AccessTools.Field(AccessTools.TypeByName("MeleeWeaponTrail"), "m_trailObject");

		private static readonly FieldInfo[] _colorFields = ResolveColorFields();

		private static readonly FieldInfo? _colorsArrayField = ResolveColorsArrayField();

		private static FieldInfo? ResolveColorsArrayField()
		{
			FieldInfo[] colorFields = _colorFields;
			foreach (FieldInfo fieldInfo in colorFields)
			{
				if (fieldInfo.Name == "_colors" && fieldInfo.FieldType == typeof(Color[]))
				{
					return fieldInfo;
				}
			}
			return null;
		}

		private static FieldInfo[] ResolveColorFields()
		{
			Type type = AccessTools.TypeByName("MeleeWeaponTrail");
			if (type == null)
			{
				return Array.Empty<FieldInfo>();
			}
			List<FieldInfo> list = new List<FieldInfo>();
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				Type fieldType = fieldInfo.FieldType;
				if (fieldType == typeof(Color) || fieldType == typeof(Gradient) || fieldType == typeof(Color[]))
				{
					list.Add(fieldInfo);
				}
			}
			return list.ToArray();
		}

		private static string FormatColorField(object? value)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_006e: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			if (value != null)
			{
				if (!(value is Color val))
				{
					if (!(value is Color[] array))
					{
						Gradient val2 = (Gradient)((value is Gradient) ? value : null);
						if (val2 != null)
						{
							StringBuilder stringBuilder = new StringBuilder();
							stringBuilder.Append("Gradient{");
							GradientColorKey[] colorKeys = val2.colorKeys;
							for (int i = 0; i < colorKeys.Length; i++)
							{
								if (i > 0)
								{
									stringBuilder.Append(',');
								}
								Color color = colorKeys[i].color;
								stringBuilder.Append($"@{colorKeys[i].time:F2}=({color.r:F2},{color.g:F2},{color.b:F2})");
							}
							stringBuilder.Append("}");
							return stringBuilder.ToString();
						}
						return "<" + value.GetType().Name + ">";
					}
					if (array.Length == 0)
					{
						return "Color[0]";
					}
					StringBuilder stringBuilder2 = new StringBuilder();
					stringBuilder2.Append("Color[").Append(array.Length).Append("]{");
					int num = Math.Min(array.Length, 4);
					for (int j = 0; j < num; j++)
					{
						if (j > 0)
						{
							stringBuilder2.Append(',');
						}
						Color val3 = array[j];
						stringBuilder2.Append($"({val3.r:F2},{val3.g:F2},{val3.b:F2},{val3.a:F2})");
					}
					if (array.Length > num)
					{
						stringBuilder2.Append(",…");
					}
					stringBuilder2.Append('}');
					return stringBuilder2.ToString();
				}
				return $"Color({val.r:F3},{val.g:F3},{val.b:F3},{val.a:F3})";
			}
			return "<null>";
		}

		private static bool IsAdditiveParticleShaderName(string? shaderName)
		{
			if (string.IsNullOrEmpty(shaderName))
			{
				return false;
			}
			switch (shaderName)
			{
			case "Legacy Shaders/Particles/Additive":
			case "Legacy Shaders/Particles/Additive (Soft)":
			case "Legacy Shaders/Particles/~Additive-Multiply":
			case "Mobile/Particles/Additive":
			case "Particles/Additive":
			case "Particles/Additive (Soft)":
				return true;
			default:
				return false;
			}
		}

		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type t = AccessTools.TypeByName("MeleeWeaponTrail");
			if (!(t == null))
			{
				MethodInfo m = AccessTools.Method(t, "Start", Type.EmptyTypes, (Type[])null);
				if (m != null)
				{
					yield return m;
				}
			}
		}

		private static void Postfix(object __instance)
		{
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_054c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Component val = (Component)((__instance is Component) ? __instance : null);
				string text = (((Object)(object)val != (Object)null) ? TransformPath(val.transform) : "<no-transform>");
				string text2 = "<field-unreadable>";
				string text3 = "<field-unreadable>";
				if (_materialField != null)
				{
					object? value = _materialField.GetValue(__instance);
					Material val2 = (Material)((value is Material) ? value : null);
					if ((Object)(object)val2 == (Object)null)
					{
						text2 = "<null>";
						text3 = "<null>";
					}
					else
					{
						text2 = Plugin.StripCloneSuffix(((Object)val2).name);
						text3 = (((Object)(object)val2.shader != (Object)null) ? ((Object)val2.shader).name : "<null-shader>");
					}
				}
				string arg = "<none>";
				if (_colorFields.Length != 0)
				{
					StringBuilder stringBuilder = new StringBuilder();
					FieldInfo[] colorFields = _colorFields;
					foreach (FieldInfo fieldInfo in colorFields)
					{
						object value2 = null;
						try
						{
							value2 = fieldInfo.GetValue(__instance);
						}
						catch
						{
						}
						if (stringBuilder.Length > 0)
						{
							stringBuilder.Append("  ");
						}
						stringBuilder.Append(fieldInfo.Name).Append('=').Append(FormatColorField(value2));
					}
					arg = stringBuilder.ToString();
				}
				string text4 = "<trail-object-unreadable>";
				if (_trailObjectField != null)
				{
					object? value3 = _trailObjectField.GetValue(__instance);
					GameObject val3 = (GameObject)((value3 is GameObject) ? value3 : null);
					if ((Object)(object)val3 == (Object)null)
					{
						text4 = "<trail-object-null>";
					}
					else
					{
						Renderer component = val3.GetComponent<Renderer>();
						Material val4 = (((Object)(object)component != (Object)null) ? component.sharedMaterial : null);
						if ((Object)(object)val4 == (Object)null)
						{
							text4 = "<clone-mat-null>";
						}
						else
						{
							string text5 = (((Object)(object)val4.shader != (Object)null) ? ((Object)val4.shader).name : "<null-shader>");
							string text6 = (val4.HasProperty("_TintColor") ? FormatColorField(val4.GetColor("_TintColor")) : "<absent>");
							string text7 = (val4.HasProperty("_EmissionColor") ? FormatColorField(val4.GetColor("_EmissionColor")) : "<absent>");
							string text8 = (val4.HasProperty("_Color") ? FormatColorField(val4.color) : "<absent>");
							string[] shaderKeywords = val4.shaderKeywords;
							string text9 = ((shaderKeywords == null || shaderKeywords.Length == 0) ? "<none>" : string.Join("|", shaderKeywords));
							text4 = "name='" + Plugin.StripCloneSuffix(((Object)val4).name) + "' shader='" + text5 + "'" + $" matId={((Object)val4).GetInstanceID()}" + " _TintColor=" + text6 + " _EmissionColor=" + text7 + " _Color=" + text8 + " keywords=" + text9;
							if ((Object)(object)val4.shader != (Object)null && !val4.shader.isSupported && IsAdditiveParticleShaderName(text5))
							{
								Shader val5 = Plugin.FindShaderByNameInternal(text5);
								if ((Object)(object)val5 != (Object)null && ((Object)val5).GetInstanceID() != ((Object)val4.shader).GetInstanceID())
								{
									int instanceID = ((Object)val4.shader).GetInstanceID();
									val4.shader = val5;
									Plugin.Log.LogInfo((object)("[TrailRebind] '" + text5 + "' on mat '" + Plugin.StripCloneSuffix(((Object)val4).name) + "'" + $" rebound from broken instance id={instanceID} (supported=False)" + $" → canonical id={((Object)val5).GetInstanceID()} (supported=True)."));
								}
								if (val4.HasProperty("_TintColor"))
								{
									Color val6 = default(Color);
									((Color)(ref val6))..ctor(0.5f, 0.5f, 0.5f, 0.5f);
									Color color = val4.GetColor("_TintColor");
									if (!(Math.Abs(color.r - val6.r) < 0.01f) || !(Math.Abs(color.g - val6.g) < 0.01f) || !(Math.Abs(color.b - val6.b) < 0.01f) || !(Math.Abs(color.a - val6.a) < 0.01f))
									{
										val4.SetColor("_TintColor", val6);
										Plugin.Log.LogInfo((object)("[TrailRebind] '" + text5 + "' on mat '" + Plugin.StripCloneSuffix(((Object)val4).name) + "'" + $" had _TintColor=({color.r:F3},{color.g:F3}," + $"{color.b:F3},{color.a:F3}) → neutralized to" + " vanilla grey (0.5,0.5,0.5,0.5) so the trail matches vanilla with no edge color (Option B: full vanilla match)."));
									}
								}
							}
						}
					}
				}
				if (Plugin.TrailProbe)
				{
					Plugin.Log.LogInfo((object)("[TrailProbe] MeleeWeaponTrail.Start  go='" + text + "'  trailMaterial='" + text2 + "'  shader='" + text3 + "'" + $"  colorFields[{_colorFields.Length}]: {arg}" + "  liveClone: " + text4));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[TrailProbe] swallowed exception: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static string TransformPath(Transform? t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return "<null>";
			}
			List<string> list = new List<string>();
			Transform val = t;
			int num = 0;
			while ((Object)(object)val != (Object)null && num++ < 64)
			{
				list.Add(Plugin.StripCloneSuffix(((Object)val).name));
				val = val.parent;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int num2 = list.Count - 1; num2 >= 0; num2--)
			{
				stringBuilder.Append('/').Append(list[num2]);
			}
			return stringBuilder.ToString();
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "AttachItem")]
	internal static class PatchVisEquipmentAttachItem
	{
		private static readonly HashSet<int> _autoPolishedEquippedMatIds = new HashSet<int>();

		private static void Postfix(VisEquipment __instance)
		{
			if ((Object)(object)Plugin.Instance == (Object)null)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("[AttachItem] " + ((Object)__instance).name + " renderers:");
			Renderer[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						string[] obj = new string[7]
						{
							"  [",
							((object)val).GetType().Name,
							"] mat='",
							((Object)val2).name,
							"' shader='",
							null,
							null
						};
						Shader shader = val2.shader;
						obj[5] = ((shader != null) ? ((Object)shader).name : null);
						obj[6] = "'";
						stringBuilder.Append(string.Concat(obj));
						if (!Plugin.IsMaterialProcessedPublic(val2))
						{
							Plugin.DumpMatPropertiesPublic(val2, "AttachItem");
							Plugin.TryReplaceMaterialPublic(val2);
						}
					}
				}
			}
			if (Plugin.AutoPolishEquippedMetal)
			{
				Renderer[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val3 in componentsInChildren2)
				{
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					Material[] sharedMaterials2 = val3.sharedMaterials;
					foreach (Material val4 in sharedMaterials2)
					{
						if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.shader == (Object)null) && !(((Object)val4.shader).name != "Custom/Creature") && val4.HasProperty("_MetallicGlossMap") && !((Object)(object)val4.GetTexture("_MetallicGlossMap") == (Object)null))
						{
							int instanceID = ((Object)val4).GetInstanceID();
							if (_autoPolishedEquippedMatIds.Add(instanceID))
							{
								val4.SetFloat("_UseGlossmap", Plugin.AutoPolishUseGlossmap ? 1f : 0f);
								val4.SetFloat("_MetalGloss", Plugin.AutoPolishMetalGloss);
								val4.SetFloat("_Glossiness", Plugin.AutoPolishGlossiness);
								val4.SetFloat("_Metallic", Plugin.AutoPolishMetalAmount);
								ManualLogSource log = Plugin.Log;
								string[] obj2 = new string[9]
								{
									$"[AutoPolishEquippedMetal] polished mat='{((Object)val4).name}'  matId={instanceID}",
									"  shader='",
									((Object)val4.shader).name,
									"'  metallicGlossMap='",
									null,
									null,
									null,
									null,
									null
								};
								Texture texture = val4.GetTexture("_MetallicGlossMap");
								obj2[4] = ((texture != null) ? ((Object)texture).name : null);
								obj2[5] = "'";
								obj2[6] = $"  → _UseGlossmap={(Plugin.AutoPolishUseGlossmap ? 1 : 0)}";
								obj2[7] = $" _MetalGloss={Plugin.AutoPolishMetalGloss:F2} _Glossiness={Plugin.AutoPolishGlossiness:F2}";
								obj2[8] = $" _Metallic={Plugin.AutoPolishMetalAmount:F2}";
								log.LogDebug((object)string.Concat(obj2));
							}
						}
					}
				}
			}
			Plugin.Log.LogDebug((object)stringBuilder.ToString());
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadFromFile
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type t = typeof(AssetBundle);
			MethodInfo sync = AccessTools.Method(t, "LoadFromFile", new Type[1] { typeof(string) }, (Type[])null);
			if (sync != null)
			{
				yield return sync;
			}
			MethodInfo crc = AccessTools.Method(t, "LoadFromFile", new Type[2]
			{
				typeof(string),
				typeof(uint)
			}, (Type[])null);
			if (crc != null)
			{
				yield return crc;
			}
			MethodInfo off = AccessTools.Method(t, "LoadFromFile", new Type[3]
			{
				typeof(string),
				typeof(uint),
				typeof(ulong)
			}, (Type[])null);
			if (off != null)
			{
				yield return off;
			}
		}

		private static void Postfix(AssetBundle __result, string path)
		{
			Plugin.OnBundleLoadedFromFile(__result, path);
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadFromMemory
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type t = typeof(AssetBundle);
			MethodInfo one = AccessTools.Method(t, "LoadFromMemory", new Type[1] { typeof(byte[]) }, (Type[])null);
			if (one != null)
			{
				yield return one;
			}
			MethodInfo two = AccessTools.Method(t, "LoadFromMemory", new Type[2]
			{
				typeof(byte[]),
				typeof(uint)
			}, (Type[])null);
			if (two != null)
			{
				yield return two;
			}
		}

		private static void Postfix(AssetBundle __result)
		{
			Plugin.OnBundleLoadedFromMemoryOrStream(__result);
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadFromStream
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type t = typeof(AssetBundle);
			MethodInfo one = AccessTools.Method(t, "LoadFromStream", new Type[1] { typeof(Stream) }, (Type[])null);
			if (one != null)
			{
				yield return one;
			}
			MethodInfo two = AccessTools.Method(t, "LoadFromStream", new Type[2]
			{
				typeof(Stream),
				typeof(uint)
			}, (Type[])null);
			if (two != null)
			{
				yield return two;
			}
			MethodInfo three = AccessTools.Method(t, "LoadFromStream", new Type[3]
			{
				typeof(Stream),
				typeof(uint),
				typeof(uint)
			}, (Type[])null);
			if (three != null)
			{
				yield return three;
			}
		}

		private static void Postfix(AssetBundle __result)
		{
			Plugin.OnBundleLoadedFromMemoryOrStream(__result);
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadFromFileAsync
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type t = typeof(AssetBundle);
			MethodInfo one = AccessTools.Method(t, "LoadFromFileAsync", new Type[1] { typeof(string) }, (Type[])null);
			if (one != null)
			{
				yield return one;
			}
			MethodInfo two = AccessTools.Method(t, "LoadFromFileAsync", new Type[2]
			{
				typeof(string),
				typeof(uint)
			}, (Type[])null);
			if (two != null)
			{
				yield return two;
			}
			MethodInfo three = AccessTools.Method(t, "LoadFromFileAsync", new Type[3]
			{
				typeof(string),
				typeof(uint),
				typeof(ulong)
			}, (Type[])null);
			if (three != null)
			{
				yield return three;
			}
		}

		private static void Postfix(AssetBundleCreateRequest __result, string path)
		{
			if (__result != null)
			{
				((AsyncOperation)__result).completed += delegate
				{
					Plugin.OnBundleLoadedFromFile(__result.assetBundle, path);
				};
			}
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadFromMemoryAsync
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type t = typeof(AssetBundle);
			MethodInfo one = AccessTools.Method(t, "LoadFromMemoryAsync", new Type[1] { typeof(byte[]) }, (Type[])null);
			if (one != null)
			{
				yield return one;
			}
			MethodInfo two = AccessTools.Method(t, "LoadFromMemoryAsync", new Type[2]
			{
				typeof(byte[]),
				typeof(uint)
			}, (Type[])null);
			if (two != null)
			{
				yield return two;
			}
		}

		private static void Postfix(AssetBundleCreateRequest __result)
		{
			if (__result != null)
			{
				((AsyncOperation)__result).completed += delegate
				{
					Plugin.OnBundleLoadedFromMemoryOrStream(__result.assetBundle);
				};
			}
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadFromStreamAsync
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type t = typeof(AssetBundle);
			MethodInfo one = AccessTools.Method(t, "LoadFromStreamAsync", new Type[1] { typeof(Stream) }, (Type[])null);
			if (one != null)
			{
				yield return one;
			}
			MethodInfo two = AccessTools.Method(t, "LoadFromStreamAsync", new Type[2]
			{
				typeof(Stream),
				typeof(uint)
			}, (Type[])null);
			if (two != null)
			{
				yield return two;
			}
			MethodInfo three = AccessTools.Method(t, "LoadFromStreamAsync", new Type[3]
			{
				typeof(Stream),
				typeof(uint),
				typeof(uint)
			}, (Type[])null);
			if (three != null)
			{
				yield return three;
			}
		}

		private static void Postfix(AssetBundleCreateRequest __result)
		{
			if (__result != null)
			{
				((AsyncOperation)__result).completed += delegate
				{
					Plugin.OnBundleLoadedFromMemoryOrStream(__result.assetBundle);
				};
			}
		}
	}
	internal static class AssetBundleMethodResolver
	{
		public static MethodInfo? FindNonGeneric(string name, Type[] paramTypes)
		{
			MethodInfo[] methods = typeof(AssetBundle).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.IsGenericMethodDefinition || methodInfo.Name != name)
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				if (parameters.Length != paramTypes.Length)
				{
					continue;
				}
				bool flag = true;
				for (int j = 0; j < parameters.Length; j++)
				{
					if (parameters[j].ParameterType != paramTypes[j])
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return methodInfo;
				}
			}
			return null;
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadAssetNoType
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo m = AssetBundleMethodResolver.FindNonGeneric("LoadAsset", new Type[1] { typeof(string) });
			if (m != null)
			{
				yield return m;
			}
		}

		private static void Postfix(AssetBundle __instance, Object __result)
		{
			if (!(__result == (Object)null))
			{
				Plugin.OnLoadAssetResult(__instance, __result);
				Material val = (Material)(object)((__result is Material) ? __result : null);
				if (val != null)
				{
					Plugin.TryReplaceMaterialPublic(val);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadAsset
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo m = AssetBundleMethodResolver.FindNonGeneric("LoadAsset", new Type[2]
			{
				typeof(string),
				typeof(Type)
			});
			if (m != null)
			{
				yield return m;
			}
		}

		private static void Postfix(AssetBundle __instance, Object __result)
		{
			if (!(__result == (Object)null))
			{
				Plugin.OnLoadAssetResult(__instance, __result);
				Material val = (Material)(object)((__result is Material) ? __result : null);
				if (val != null)
				{
					Plugin.TryReplaceMaterialPublic(val);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadAllAssets
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo none = AssetBundleMethodResolver.FindNonGeneric("LoadAllAssets", new Type[0]);
			if (none != null)
			{
				yield return none;
			}
			MethodInfo typed = AssetBundleMethodResolver.FindNonGeneric("LoadAllAssets", new Type[1] { typeof(Type) });
			if (typed != null)
			{
				yield return typed;
			}
		}

		private static void Postfix(AssetBundle __instance, Object[] __result)
		{
			if (__result == null)
			{
				return;
			}
			foreach (Object val in __result)
			{
				if (!(val == (Object)null))
				{
					Plugin.OnLoadAssetResult(__instance, val);
					Material val2 = (Material)(object)((val is Material) ? val : null);
					if (val2 != null)
					{
						Plugin.TryReplaceMaterialPublic(val2);
					}
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadAssetAsync
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo one = AssetBundleMethodResolver.FindNonGeneric("LoadAssetAsync", new Type[1] { typeof(string) });
			if (one != null)
			{
				yield return one;
			}
			MethodInfo two = AssetBundleMethodResolver.FindNonGeneric("LoadAssetAsync", new Type[2]
			{
				typeof(string),
				typeof(Type)
			});
			if (two != null)
			{
				yield return two;
			}
		}

		private static void Postfix(AssetBundle __instance, AssetBundleRequest __result)
		{
			if (__result == null)
			{
				return;
			}
			((AsyncOperation)__result).completed += delegate
			{
				Object asset = __result.asset;
				if (!(asset == (Object)null))
				{
					Plugin.OnLoadAssetResult(__instance, asset);
					Material val = (Material)(object)((asset is Material) ? asset : null);
					if (val != null)
					{
						Plugin.TryReplaceMaterialPublic(val);
					}
				}
			};
		}
	}
	[HarmonyPatch]
	internal static class PatchAssetBundleLoadAllAssetsAsync
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo none = AssetBundleMethodResolver.FindNonGeneric("LoadAllAssetsAsync", new Type[0]);
			if (none != null)
			{
				yield return none;
			}
			MethodInfo typed = AssetBundleMethodResolver.FindNonGeneric("LoadAllAssetsAsync", new Type[1] { typeof(Type) });
			if (typed != null)
			{
				yield return typed;
			}
		}

		private static void Postfix(AssetBundle __instance, AssetBundleRequest __result)
		{
			if (__result == null)
			{
				return;
			}
			((AsyncOperation)__result).completed += delegate
			{
				Object[] allAssets = __result.allAssets;
				if (allAssets != null)
				{
					Object[] array = allAssets;
					foreach (Object val in array)
					{
						if (!(val == (Object)null))
						{
							Plugin.OnLoadAssetResult(__instance, val);
							Material val2 = (Material)(object)((val is Material) ? val : null);
							if (val2 != null)
							{
								Plugin.TryReplaceMaterialPublic(val2);
							}
						}
					}
				}
			};
		}
	}
	internal static class PatchEffectListCreateSwingProbe
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo m = AccessTools.Method(typeof(EffectList), "Create", new Type[5]
			{
				typeof(Vector3),
				typeof(Quaternion),
				typeof(Transform),
				typeof(float),
				typeof(int)
			}, (Type[])null);
			if (m != null)
			{
				yield return m;
			}
		}

		private static void Postfix(GameObject[] __result)
		{
			try
			{
				if (__result == null)
				{
					return;
				}
				foreach (GameObject val in __result)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val2 in componentsInChildren)
					{
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						Material[] sharedMaterials = val2.sharedMaterials;
						foreach (Material val3 in sharedMaterials)
						{
							if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.shader == (Object)null) && ((Object)val3.shader).name.StartsWith("Hidden/InternalErrorShader", StringComparison.OrdinalIgnoreCase))
							{
								Plugin.Log.LogInfo((object)("[SwingProbe] EffectList.Create spawned error-shader material: mat='" + ((Object)val3).name + "' shader='" + ((Object)val3.shader).name + "'" + $" matId={((Object)val3).GetInstanceID()}" + " rendererType=" + ((object)val2).GetType().Name + " go='" + ((Object)((Component)val2).gameObject).name + "' rootGo='" + ((Object)val).name + "'" + $" alreadyProcessed={Plugin.IsMaterialProcessedPublic(val3)}" + $" isErrorPink={Plugin.IsErrorPinkPublic(val3)}"));
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[SwingProbe] swallowed exception: " + ex.GetType().Name + ": " + ex.Message));
			}
		}
	}
	internal static class PatchAttackSwingProbe2
	{
		private const int HeartbeatCap = 8;

		private static int _heartbeatCount;

		private const int SceneScanCap = 4;

		private static int _sceneScanCount;

		private const int WindowCap = 2;

		private const int WindowFrames = 30;

		private static int _windowCount;

		private static bool _windowRunning;

		private static IEnumerable<MethodBase> TargetMethods()
		{
			MethodInfo trigger = AccessTools.Method(typeof(Attack), "OnAttackTrigger", Type.EmptyTypes, (Type[])null);
			if (trigger != null)
			{
				yield return trigger;
			}
			MethodInfo melee = AccessTools.Method(typeof(Attack), "DoMeleeAttack", Type.EmptyTypes, (Type[])null);
			if (melee != null)
			{
				yield return melee;
			}
		}

		private static string TransformPath(Transform t)
		{
			StringBuilder stringBuilder = new StringBuilder();
			List<string> list = new List<string>();
			Transform val = t;
			int num = 0;
			while ((Object)(object)val != (Object)null && num++ < 64)
			{
				list.Add(Plugin.StripCloneSuffix(((Object)val).name));
				val = val.parent;
			}
			for (int num2 = list.Count - 1; num2 >= 0; num2--)
			{
				stringBuilder.Append('/').Append(list[num2]);
			}
			return stringBuilder.ToString();
		}

		private static void Postfix(MethodBase __originalMethod)
		{
			try
			{
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return;
				}
				string text = __originalMethod?.Name ?? "Attack";
				int num = 0;
				int num2 = 0;
				Renderer[] componentsInChildren = ((Component)localPlayer).GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val in componentsInChildren)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					num++;
					Material[] sharedMaterials = val.sharedMaterials;
					foreach (Material val2 in sharedMaterials)
					{
						if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null) && ((Object)val2.shader).name.StartsWith("Hidden/InternalErrorShader", StringComparison.OrdinalIgnoreCase))
						{
							num2++;
							Plugin.Log.LogInfo((object)("[SwingProbe2] hook=" + text + " error-shader material under local player: mat='" + ((Object)val2).name + "' shader='" + ((Object)val2.shader).name + "'" + $" matId={((Object)val2).GetInstanceID()}" + " rendererType=" + ((object)val).GetType().Name + " go='" + ((Object)((Component)val).gameObject).name + "'" + $" alreadyProcessed={Plugin.IsMaterialProcessedPublic(val2)}" + $" isErrorPink={Plugin.IsErrorPinkPublic(val2)}"));
						}
					}
				}
				if (_sceneScanCount < 4)
				{
					_sceneScanCount++;
					int num3 = 0;
					int num4 = 0;
					Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
					foreach (Renderer val3 in array)
					{
						if ((Object)(object)val3 == (Object)null)
						{
							continue;
						}
						num3++;
						Material[] sharedMaterials2 = val3.sharedMaterials;
						foreach (Material val4 in sharedMaterials2)
						{
							if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.shader == (Object)null) && ((Object)val4.shader).name.StartsWith("Hidden/InternalErrorShader", StringComparison.OrdinalIgnoreCase))
							{
								num4++;
								Plugin.Log.LogInfo((object)($"[SwingProbe2-Scene] scan #{_sceneScanCount}/{4} hook={text}" + " mat='" + ((Object)val4).name + "' shader='" + ((Object)val4.shader).name + "'" + $" matId={((Object)val4).GetInstanceID()}" + " rendererType=" + ((object)val3).GetType().Name + " path='" + TransformPath(((Component)val3).transform) + "'" + $" activeInHierarchy={((Component)val3).gameObject.activeInHierarchy}" + $" rendererEnabled={val3.enabled}" + $" alreadyProcessed={Plugin.IsMaterialProcessedPublic(val4)}" + $" isErrorPink={Plugin.IsErrorPinkPublic(val4)}"));
							}
						}
					}
					Plugin.Log.LogInfo((object)($"[SwingProbe2-Scene] scan #{_sceneScanCount}/{4} hook={text}" + $" sceneRenderers={num3} sceneErrorShaderMatches={num4}"));
				}
				if (_windowCount < 2 && !_windowRunning && (Object)(object)Plugin.Instance != (Object)null)
				{
					_windowCount++;
					_windowRunning = true;
					((MonoBehaviour)Plugin.Instance).StartCoroutine(PerFrameWindowScan(text, _windowCount));
				}
				if (_heartbeatCount < 8)
				{
					_heartbeatCount++;
					Plugin.Log.LogInfo((object)($"[SwingProbe2] heartbeat #{_heartbeatCount}/{8} hook={text}" + $" renderersScanned={num} errorShaderMatches={num2}"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[SwingProbe2] swallowed exception: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static IEnumerator PerFrameWindowScan(string hook, int windowIndex)
		{
			Plugin.Log.LogInfo((object)($"[SwingProbe2-Window] window #{windowIndex}/{2} OPEN hook={hook}" + " — DE-ASSUMED per-frame scan (error-pink-by-color OR trail/line/particle" + $" renderer; reads sharedMaterials AND materials) for up to {30} frames"));
			HashSet<string> loggedKeys = new HashSet<string>(StringComparer.Ordinal);
			int distinctLogged = 0;
			MaterialPropertyBlock mpbScratch = new MaterialPropertyBlock();
			HashSet<string> pinkSourceKeys = new HashSet<string>(StringComparer.Ordinal);
			int pinkSourceLogged = 0;
			for (int frame = 0; frame < 30; frame++)
			{
				yield return (object)new WaitForEndOfFrame();
				Renderer[] all;
				try
				{
					all = Resources.FindObjectsOfTypeAll<Renderer>();
				}
				catch (Exception ex)
				{
					Plugin.Log.LogDebug((object)$"[SwingProbe2-Window] enumerate failed frame={frame}: {ex.Message}");
					continue;
				}
				Renderer[] array = all;
				foreach (Renderer r in array)
				{
					if ((Object)(object)r == (Object)null)
					{
						continue;
					}
					bool isTrailLikeRenderer = r is TrailRenderer || r is LineRenderer || r is ParticleSystemRenderer;
					Material[] shared;
					try
					{
						shared = r.sharedMaterials;
					}
					catch
					{
						shared = Array.Empty<Material>();
					}
					bool sharedHasPink = false;
					Material[] array2 = shared;
					foreach (Material mat in array2)
					{
						if (!((Object)(object)mat == (Object)null))
						{
							bool pink = false;
							try
							{
								pink = Plugin.IsErrorPinkPublic(mat);
							}
							catch
							{
							}
							if (pink)
							{
								sharedHasPink = true;
							}
							if (pink || isTrailLikeRenderer)
							{
								EmitWindowMatch(windowIndex, frame, "shared", r, mat, pink, loggedKeys, ref distinctLogged);
							}
						}
					}
					if (isTrailLikeRenderer || sharedHasPink)
					{
						Material[] inst;
						try
						{
							inst = r.materials;
						}
						catch
						{
							inst = Array.Empty<Material>();
						}
						Material[] array3 = inst;
						foreach (Material mat2 in array3)
						{
							if (!((Object)(object)mat2 == (Object)null))
							{
								bool pink2 = false;
								try
								{
									pink2 = Plugin.IsErrorPinkPublic(mat2);
								}
								catch
								{
								}
								if (pink2 || isTrailLikeRenderer)
								{
									EmitWindowMatch(windowIndex, frame, "instance", r, mat2, pink2, loggedKeys, ref distinctLogged);
								}
							}
						}
					}
					if (isTrailLikeRenderer)
					{
						try
						{
							EmitPinkSourceMatch(windowIndex, frame, r, mpbScratch, pinkSourceKeys, ref pinkSourceLogged);
						}
						catch (Exception ex2)
						{
							Exception ex3 = ex2;
							Plugin.Log.LogDebug((object)("[PinkSourceProbe] swallowed exception: " + ex3.GetType().Name + ": " + ex3.Message));
						}
					}
				}
			}
			Plugin.Log.LogInfo((object)($"[SwingProbe2-Window] window #{windowIndex} CLOSED at frame cap ({30})" + $" — distinctLogged={distinctLogged} (each line is a candidate for what the pink" + " swing arc actually is; 0 means neither error-pink-by-color nor any trail/line/ particle material appeared in the window — next probe widens render technique)."));
			_windowRunning = false;
		}

		private static void EmitWindowMatch(int windowIndex, int frame, string slot, Renderer r, Material mat, bool pink, HashSet<string> loggedKeys, ref int distinctLogged)
		{
			//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)
			string text = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).name : "<null-shader>");
			string text2;
			try
			{
				text2 = TransformPath(((Component)r).transform);
			}
			catch
			{
				text2 = "<path-failed>";
			}
			string item = $"{((object)r).GetType().Name}|{text}|{text2}|{pink}|{slot}";
			if (!loggedKeys.Add(item))
			{
				return;
			}
			distinctLogged++;
			string arg = "n/a";
			try
			{
				if (mat.HasProperty("_Color"))
				{
					arg = ((object)mat.color/*cast due to .constrained prefix*/).ToString();
				}
			}
			catch
			{
			}
			Plugin.Log.LogInfo((object)($"[SwingProbe2-Window] window #{windowIndex} frame=+{frame} CANDIDATE slot={slot}" + " mat='" + ((Object)mat).name + "' shader='" + text + "'" + $" matId={((Object)mat).GetInstanceID()}" + " rendererType=" + ((object)r).GetType().Name + " path='" + text2 + "'" + $" isErrorPinkByColor={pink} color={arg}" + $" activeInHierarchy={((Component)r).gameObject.activeInHierarchy}" + $" rendererEnabled={r.enabled}" + $" alreadyProcessed={Plugin.IsMaterialProcessedPublic(mat)}"));
		}

		private static bool IsMagenta(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return MaterialClassifier.IsMagenta(c);
		}

		private static void EmitPinkSourceMatch(int windowIndex, int frame, Renderer r, MaterialPropertyBlock mpbScratch, HashSet<string> pinkSourceKeys, ref int pinkSourceLogged)
		{
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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)
			List<(string, Color)> list = new List<(string, Color)>(4);
			Material val = null;
			string text = "<none>";
			string text2 = "<none>";
			try
			{
				Material[] sharedMaterials = r.sharedMaterials;
				if (sharedMaterials != null)
				{
					Material[] array = sharedMaterials;
					foreach (Material val2 in array)
					{
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						val = val2;
						text = ((Object)val2).name;
						text2 = (((Object)(object)val2.shader != (Object)null) ? ((Object)val2.shader).name : "<null-shader>");
						if (val2.HasProperty("_Color"))
						{
							Color color = val2.color;
							if (IsMagenta(color))
							{
								list.Add(("mat._Color", color));
							}
						}
						if (val2.HasProperty("_TintColor"))
						{
							Color color2 = val2.GetColor("_TintColor");
							if (IsMagenta(color2))
							{
								list.Add(("mat._TintColor", color2));
							}
						}
						if (val2.HasProperty("_EmissionColor"))
						{
							Color color3 = val2.GetColor("_EmissionColor");
							if (IsMagenta(color3))
							{
								list.Add(("mat._EmissionColor", color3));
							}
						}
						break;
					}
				}
			}
			catch
			{
			}
			try
			{
				if (r.HasPropertyBlock())
				{
					mpbScratch.Clear();
					r.GetPropertyBlock(mpbScratch);
					Color color4 = mpbScratch.GetColor("_Color");
					Color color5 = mpbScratch.GetColor("_MainColor");
					Color color6 = mpbScratch.GetColor("_TintColor");
					if (IsMagenta(color4))
					{
						list.Add(("mpb._Color", color4));
					}
					if (IsMagenta(color5))
					{
						list.Add(("mpb._MainColor", color5));
					}
					if (IsMagenta(color6))
					{
						list.Add(("mpb._TintColor", color6));
					}
				}
			}
			catch
			{
			}
			try
			{
				ParticleSystem component = ((Component)r).gameObject.GetComponent<ParticleSystem>();
				if ((Object)(object)component != (Object)null)
				{
					MainModule main = component.main;
					MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
					Color color7 = ((MinMaxGradient)(ref startColor)).color;
					if (IsMagenta(color7))
					{
						list.Add(("ps.startColor", color7));
					}
				}
			}
			catch
			{
			}
			if (list.Count == 0)
			{
				return;
			}
			string text3;
			try
			{
				text3 = TransformPath(((Component)r).transform);
			}
			catch
			{
				text3 = "<path-failed>";
			}
			string text4 = string.Join("+", list.ConvertAll(((string src, Color col) h) => h.src));
			string item = ((object)r).GetType().Name + "|" + text2 + "|" + text3 + "|" + text4;
			if (pinkSourceKeys.Add(item))
			{
				pinkSourceLogged++;
				bool flag = list.Exists(((string src, Color col) h) => ((Color)(ref h.col)).maxColorComponent > 1f);
				string arg = string.Join("  ", list.ConvertAll(((string src, Color col) h) => $"{h.src}=RGBA({h.col.r:F2},{h.col.g:F2},{h.col.b:F2},{h.col.a:F2})|HDR={((Color)(ref h.col)).maxColorComponent > 1f}"));
				Plugin.Log.LogInfo((object)($"[PinkSourceProbe] window #{windowIndex} frame=+{frame} MAGENTA-SOURCE={text4}" + $" anyHDR={flag} values=[{arg}]" + " mat='" + text + "' shader='" + text2 + "'" + $" matId={(((Object)(object)val != (Object)null) ? ((Object)val).GetInstanceID() : 0)}" + " rendererType=" + ((object)r).GetType().Name + " path='" + text3 + "'" + $" activeInHierarchy={((Component)r).gameObject.activeInHierarchy}" + $" rendererEnabled={r.enabled}"));
			}
		}
	}
	internal static class PatchShaderFindBindProbe
	{
		private static readonly HashSet<string> _shaderFindProbeFiredNames = new HashSet<string>(StringComparer.Ordinal);

		private static void Postfix(string name, Shader __result)
		{
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__result == (Object)null)
				{
					return;
				}
				string text = ((Object)__result).name ?? string.Empty;
				if (string.IsNullOrEmpty(text) || !BundleAttribution.IsVanillaShaderName(text) || !_shaderFindProbeFiredNames.Add(text))
				{
					return;
				}
				Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
				int num = 0;
				List<int> list = new List<int>();
				int instanceID = ((Object)__result).GetInstanceID();
				Shader[] array2 = array;
				foreach (Shader val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !(((Object)val).name != text) && ((Object)val).GetInstanceID() != instanceID)
					{
						num++;
						if (list.Count < 8)
						{
							list.Add(((Object)val).GetInstanceID());
						}
					}
				}
				if (num >= 1)
				{
					string text2 = string.Join(",", list);
					string text3 = ((num > list.Count) ? ("+" + (num - list.Count) + "more") : string.Empty);
					string text4 = "n/a";
					try
					{
						int num2 = __result.FindPropertyIndex("_Color");
						text4 = ((num2 < 0) ? "no-_Color" : ((object)__result.GetPropertyType(num2)/*cast due to .constrained prefix*/).ToString());
					}
					catch (Exception)
					{
					}
					Plugin.Log.LogInfo((object)("[BindProbe-ShaderFind] requestedName='" + name + "' returnedName='" + text + "'" + $" returnedId={instanceID} peerCount={num} peerIds=[{text2}{text3}]" + $" returnedRQ={__result.renderQueue} returnedIsSupported={__result.isSupported}" + " schema=" + text4 + " vanillaName=true"));
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogDebug((object)("[BindProbe-ShaderFind] swallowed exception for Find request '" + (name ?? "<null>") + "': " + ex2.GetType().Name + ": " + ex2.Message));
			}
		}
	}
	[DefaultExecutionOrder(30000)]
	internal sealed class KeepRendererDisabled : MonoBehaviour
	{
		private Renderer? _renderer;

		private void Awake()
		{
			_renderer = ((Component)this).GetComponent<Renderer>();
		}

		private void LateUpdate()
		{
			if ((Object)(object)_renderer != (Object)null && _renderer.enabled)
			{
				_renderer.enabled = false;
			}
		}
	}
	internal enum ShaderAction
	{
		Transparent,
		Fallback,
		Original,
		UseShader
	}
	[BepInPlugin("aaa.drummercraig.shaderhelperformac", "ShaderHelperForMac", "3.2.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "aaa.drummercraig.shaderhelperformac";

		public const string PluginName = "ShaderHelperForMac";

		public const string PluginVersion = "3.2.0";

		internal static readonly string UseTransparentShaderFile = "usetransparentshader.txt";

		internal static readonly string UseFallbackShaderFile = "usefallbackshader.txt";

		internal static readonly string UseOriginalShaderFile = "useoriginalshader.txt";

		internal static HashSet<string> _useTransparentDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static HashSet<string> _useFallbackDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static HashSet<string> _useOriginalDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static HashSet<string> _transparentMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static HashSet<string> _fallbackMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static HashSet<string> _originalMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static List<string> _transparentMatSuffixes = new List<string>();

		internal static List<string> _fallbackMatSuffixes = new List<string>();

		internal static HashSet<string> _forceFallbackMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static List<string> _forceFallbackMatSuffixes = new List<string>();

		internal static HashSet<string> _forceTransparentMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static List<string> _forceTransparentMatSuffixes = new List<string>();

		internal static HashSet<string> _forceFallbackPrefixSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static HashSet<string> _forceTransparentPrefixSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static Dictionary<string, string> _matShaderOverrides = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		internal static Dictionary<string, List<(string prop, string value)>> _matShaderPropertyOverrides = new Dictionary<string, List<(string, string)>>(StringComparer.OrdinalIgnoreCase);

		internal static Dictionary<string, List<(string keyword, bool enable)>> _matShaderKeywordOverrides = new Dictionary<string, List<(string, bool)>>(StringComparer.OrdinalIgnoreCase);

		internal static HashSet<string> _hideRendererMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static List<string> _hideRendererMatSuffixes = new List<string>();

		private FileSystemWatcher? _watcher;

		private ConfigEntry<float> _cfgPeriodicSweepInterval = null;

		private ConfigEntry<string> _cfgBridgeTraceMatNames = null;

		private ConfigEntry<bool> _cfgSweepProgressTrace = null;

		private ConfigEntry<bool> _cfgVanillaRebindEnabled = null;

		private ConfigEntry<bool> _cfgPreserveAdditiveParticles = null;

		private ConfigEntry<bool> _cfgHunFXAutoDefault = null;

		private ConfigEntry<bool> _cfgRepairInternalErrorShader = null;

		private ConfigEntry<bool> _cfgTrailProbe = null;

		private ConfigEntry<bool> _cfgDiagnosticProbes = null;

		private ConfigEntry<bool> _cfgAutoPolishMetallic = null;

		private ConfigEntry<bool> _cfgAutoPolishEquippedMetal = null;

		private ConfigEntry<bool> _cfgAutoPolishUseGlossmap = null;

		private ConfigEntry<float> _cfgAutoPolishMetalGloss = null;

		private ConfigEntry<float> _cfgAutoPolishGlossiness = null;

		private ConfigEntry<float> _cfgAutoPolishMetalAmount = null;

		private static Plugin? _instance;

		internal static readonly Dictionary<string, string> ModShaderDlls = new Dictionary<string, string>();

		internal static readonly Dictionary<string, string> _bundleToDll = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		internal static readonly HashSet<string> _tocAttributedBundles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static readonly Dictionary<string, string> _prefabRootToDll = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		internal static readonly string[] FallbackChain = new string[2] { "Custom/Creature", "Custom/Piece" };

		internal static readonly string[] TransparentChain = new string[5] { "Particles/Standard Unlit", "Legacy Shaders/Particles/Alpha Blended", "Particles/Standard Surface2", "Sprites/Default", "UI/Default" };

		internal static readonly HashSet<int> CanonicalShaderIds = new HashSet<int>();

		internal static readonly HashSet<string> _vanillaBundleNames = new HashSet<string>(StringComparer.Ordinal);

		internal static bool _awakeVanillaSnapshotEmpty;

		internal static bool _zNetSceneAwakeFired;

		internal static readonly List<AssetBundle> _deferredMemoryStreamBundles = new List<AssetBundle>();

		internal static string? _valheimDataPath;

		internal static readonly HashSet<string> _modPrefabRootNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static readonly HashSet<int> _prefabScopedModMatIds = new HashSet<int>();

		internal static readonly HashSet<int> _particleRendererMatIdHints = new HashSet<int>();

		internal static readonly HashSet<int> _forceReplacedMaterialIds = new HashSet<int>();

		internal static readonly Dictionary<int, (bool intent, Color color, Texture? map, bool keyword)> _originalEmissionByMat = new Dictionary<int, (bool, Color, Texture, bool)>();

		internal static readonly HashSet<string> _baselineMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static readonly HashSet<string> _vanillaShaderNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static readonly string[] ValheimShaderNames = new string[55]
		{
			"Custom/Piece", "Custom/Creature", "Custom/Vegetation", "Custom/StaticRock", "Custom/Lit", "Custom/LitParticles", "Custom/FlowOpaque", "Custom/Billboard", "Custom/DistantLod", "Custom/WaterLily",
			"Custom/Trilinear", "Custom/Decal", "Custom/Cliff", "Custom/Skybox", "Custom/Distortion", "Custom/Player", "Custom/Blob", "Custom/Bonemass", "Custom/Grass", "Custom/Heightmap",
			"Custom/Rug", "Custom/ShadowBlob", "Custom/Tar", "Custom/Trilinearmap", "Custom/Yggdrasil", "Custom/Yggdrasil_root", "Custom/Water", "Custom/WaterBottom", "Custom/WaterMask", "Custom/Clouds",
			"Custom/Flow", "Custom/SkyboxProcedural", "Custom/SkyObject", "Custom/icon", "Custom/LitGui", "Custom/mapshader", "Custom/UI/AntiAliasedCircle", "Custom/UI_BGBlur", "Custom/AlphaParticle", "Custom/Gradient Mapped Particle (Unlit)",
			"Custom/Mesh Flipbook Particle", "Custom/Particle (Unlit)", "Custom/ParticleDecal", "Particles/Standard Unlit2", "Particles/Standard Surface2", "Standard TwoSided", "FX/Glass/Stained BumpDistort", "FX/Glass/Stained", "Unlit/Lighting", "ToonDeferredShading",
			"ToonDeferredShading2017", "Earthquake/Tree", "Earthquake/Leaf", "Hovl/Particles/Additive", "Hovl/Particles/AlphaBlend"
		};

		internal static readonly HashSet<string> ValheimShaderNameSet = new HashSet<string>(ValheimShaderNames, StringComparer.OrdinalIgnoreCase);

		internal static readonly string[] UnityBuiltInShaderNames = new string[36]
		{
			"Standard", "Standard (Specular setup)", "Standard (Roughness setup)", "Sprites/Default", "Sprites/Mask", "UI/Default", "UI/DefaultFont", "UI/Unlit/Text", "UI/Unlit/Transparent", "Unlit/Color",
			"Unlit/Texture", "Unlit/Transparent", "Unlit/Transparent Cutout", "Diffuse", "Mobile/Diffuse", "Transparent/Diffuse", "VertexLit", "Mobile/VertexLit", "Legacy Shaders/Particles/Alpha Blended", "Legacy Shaders/Particles/Additive",
			"Legacy Shaders/Particles/Additive (Soft)", "Legacy Shaders/Particles/Multiply", "Legacy Shaders/Particles/VertexLit Blended", "Particles/Standard Unlit", "Particles/Standard Surface", "TextMeshPro/Distance Field", "TextMeshPro/Distance Field (Surface)", "TextMeshPro/Distance Field Overlay", "TextMeshPro/Distance Field SSD", "TextMeshPro/Mobile/Distance Field",
			"TextMeshPro/Mobile/Distance Field - Masking", "TextMeshPro/Mobile/Distance Field Overlay", "TextMeshPro/Bitmap", "TextMeshPro/Mobile/Bitmap", "TextMeshPro/Sprite", "GUI/Text Shader"
		};

		internal static readonly HashSet<string> UnityBuiltInShaderNameSet = new HashSet<string>(UnityBuiltInShaderNames, StringComparer.OrdinalIgnoreCase);

		internal static Material? _transparentMat;

		internal static Material? _fallbackMat;

		internal bool _initialized;

		internal bool _sweepRunning;

		internal static bool _sweepDisabled;

		internal static string? _cachedValheimVersionForDriftCheck;

		internal static int _consecutiveSweepSkips;

		internal static bool _forceNextPeriodicSweep;

		internal static ManualLogSource Log { get; private set; } = null;

		internal static Plugin Instance { get; private set; } = null;

		internal static string ConfigDir => Path.Combine(Paths.ConfigPath, "ShaderHelperForMac");

		internal static float PeriodicSweepInterval => _instance?._cfgPeriodicSweepInterval.Value ?? 30f;

		internal static HashSet<string> BridgeTraceMatNames
		{
			get
			{
				string text = _instance?._cfgBridgeTraceMatNames.Value ?? string.Empty;
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				if (string.IsNullOrWhiteSpace(text))
				{
					return hashSet;
				}
				string[] array = text.Split(new char[1] { ',' });
				foreach (string text2 in array)
				{
					string text3 = text2.Trim();
					if (text3.Length > 0)
					{
						hashSet.Add(text3);
					}
				}
				return hashSet;
			}
		}

		internal static bool SweepProgressTrace => _instance?._cfgSweepProgressTrace?.Value == true;

		internal static bool VanillaRebindEnabled => _instance?._cfgVanillaRebindEnabled?.Value ?? true;

		internal static bool PreserveAdditiveParticles => _instance?._cfgPreserveAdditiveParticles?.Value == true;

		internal static bool HunFXAutoDefault => _instance?._cfgHunFXAutoDefault?.Value ?? true;

		internal static bool AutoPolishMetallic => _instance?._cfgAutoPolishMetallic?.Value == true;

		internal static bool AutoPolishEquippedMetal => _instance?._cfgAutoPolishEquippedMetal?.Value ?? true;

		internal static float AutoPolishMetalAmount => _instance?._cfgAutoPolishMetalAmount?.Value ?? 1f;

		internal static bool AutoPolishUseGlossmap => _instance?._cfgAutoPolishUseGlossmap?.Value ?? true;

		internal static float AutoPolishMetalGloss => _instance?._cfgAutoPolishMetalGloss?.Value ?? 0.7f;

		internal static float AutoPolishGlossiness => _instance?._cfgAutoPolishGlossiness?.Value ?? 0.9f;

		internal static bool RepairInternalErrorShader => _instance?._cfgRepairInternalErrorShader?.Value ?? true;

		internal static bool TrailProbe => _instance?._cfgTrailProbe?.Value == true;

		internal static bool DiagnosticProbes => _instance?._cfgDiagnosticProbes?.Value == true;

		internal static bool _transparentShaderIsParticleCapable { get; set; }

		internal static Shader? FallbackShader { get; set; }

		internal static string StripCloneSuffix(string name)
		{
			while (name.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				name = name.Substring(0, name.Length - "(Clone)".Length);
			}
			return name;
		}

		internal static void PopulateLane5FromSceneWalk()
		{
			_prefabScopedModMatIds.Clear();
			if (_modPrefabRootNames.Count == 0)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			Renderer[] array2 = array;
			foreach (Renderer val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				bool flag = false;
				Transform val2 = ((Component)val).transform;
				while ((Object)(object)val2 != (Object)null)
				{
					string item = StripCloneSuffix(((Object)val2).name);
					if (_modPrefabRootNames.Contains(item))
					{
						flag = true;
						break;
					}
					val2 = val2.parent;
				}
				if (!flag)
				{
					continue;
				}
				num++;
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val3 in sharedMaterials)
				{
					if (!((Object)(object)val3 == (Object)null) && _prefabScopedModMatIds.Add(((Object)val3).GetInstanceID()))
					{
						num2++;
					}
				}
			}
			if (num > 0)
			{
				Log.LogDebug((object)$"[Provenance] Lane-5 prefab scope: {num} renderer(s) under declared [prefab] ancestor(s), admitting {num2} material instance(s)");
			}
		}

		internal static void CheckCachedVanillaCacheVersionDrift()
		{
			if (_cachedValheimVersionForDriftCheck != null)
			{
				string valheimVersionViaReflection = VanillaBaselineCache.GetValheimVersionViaReflection();
				if (!string.Equals(_cachedValheimVersionForDriftCheck, valheimVersionViaReflection, StringComparison.Ordinal))
				{
					Log.LogWarning((object)("[VanillaCache] version drift: cache was produced for Valheim '" + _cachedValheimVersionForDriftCheck + "' but this install reports '" + valheimVersionViaReflection + "'. Keeping the cache loaded; if you observe vanilla materials being replaced, run `shaderhelper capturevanilla` from a clean install to refresh."));
				}
				_cachedValheimVersionForDriftCheck = null;
			}
		}

		private void Awake()
		{
			Instance = this;
			_instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			BundleAttribution.EmitBaselineSnapshot("Awake-Start");
			_cfgPeriodicSweepInterval = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Periodic Sweep Interval", 600f, "How often (in seconds) to re-sweep all materials. The periodic sweep is now a safety net for unobserved bundle-load / prefab-spawn events; the primary mechanisms are Harmony postfixes on ZNetScene.Awake, Location.Awake, AssetBundle.Load*, VisEquipment.AttachItem, and the scene-load handler. Default raised to 600 s in v3.0.63 because the v2.1.17 admission-epoch skip-gate already short-circuits every periodic sweep on a stable scene; the cadence only matters when the safety cap (10 consecutive skips) forces a full sweep. Lower this (e.g. 120 or 30) if you run VFX-heavy mods that spawn materials frequently and you observe pink materials between sweeps. Set to 0 to disable the periodic timer entirely.");
			_cfgBridgeTraceMatNames = ((BaseUnityPlugin)this).Config.Bind<string>("Diagnostics", "Bridge Trace Mat Names", "", "Diagnostic-only. Comma-separated list of material base names (case-insensitive, after StripInstance normalization). When a material's name is in this list, BridgeMaterialProperties emits one [BridgeTrace] log line per bridge call with the source _EmissionColor, IsHdrEmission result, _EMISSION keyword state, and HasEmissiveIntent result. Empty disables the trace (default). Used to gather evidence for the v3.0.7 emission-bridge timing investigation; see LESSONS_LEARNED.md and CHANGELOG v3.0.7. Pure read-only observation — does not affect any gate, sweep, or resolver decision.");
			_cfgSweepProgressTrace = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Sweep Progress Trace", false, "Diagnostic-only. When true, SweepMaterialsCoroutine emits one [SweepProgress] log line per SweepBatchSize (=100) renderer batch, reporting per-batch wall-clock, cumulative sweep time, renderer index, mats processed, and replacement count. Used to identify where periodic-sweep wall-clock cost is concentrated when investigating frame-time stutter. Default false; enable for one diagnostic session, then disable. Pure read-only observation — does not affect any gate, sweep decision, or resolver outcome. See CHANGELOG v3.0.16.");
			_cfgVanillaRebindEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Vanilla Rebind Enabled", true, "When true (DEFAULT), TryReplaceMaterial rebinds any material to the canonical Unity instance of its vanilla-named shader, ONCE per material per session, AND ONLY when the material is on a ParticleSystemRenderer this sweep. Fixes the dropped-item particle indicator (item_particle on Magic_Supremacy drops) without re-introducing the v2.1.27-class weapon flicker that v3.0.27's unscoped rebind caused. Set to false to disable the rebind entirely (restoring v3.0.28 behaviour: item_particle renders pink on dropped items, but no weapon flicker risk). The flag is provided as a kill-switch only — flipping to false is intended for users who observe regressions on materials this rebind class shouldn't have touched. See CHANGELOG v3.0.30 for the v3.0.29 evidence and v3.0.30 design.");
			_cfgPreserveAdditiveParticles = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Preserve Additive Particles", true, "Default ON (v3.1.33). When true, a gate-admitted mod material whose current shader is already a supported additive / alpha-blended particle shader (e.g. 'Legacy Shaders/Particles/Additive', 'Particles/Standard Unlit') AND has no hard mat:/suffix: rule is LEFT ON ITS OWN SHADER instead of being routed through the aggressive-family Fallback bind to Custom/Creature (which drops the additive _TintColor/_InvFade controls — the flame_TW 'good look' loss). This reproduces, without a rule, what '[useshader] Legacy Shaders/Particles/Additive' achieves. Any user [forcefallback]/[forcetransparent]/[useshader] rule still wins (the branch is gated on no-hard-rule). Vanilla materials are unaffected (the provenance veto runs first). The v3.1.32 default-OFF opt-in was validated in-game (2165 [PreserveAdditive] fires across 36 distinct VFX materials on 4 shader families, zero solid geometry caught) and flipped to default-ON in v3.1.33. Set to false to disable the preservation branch and route additive particles through the aggressive-family Fallback. See CHANGELOG v3.1.32 + v3.1.33.");
			_cfgHunFXAutoDefault = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "HunFX Auto Default", true, "Default ON (v3.1.54, validated in-game). When true, a gate-admitted mod material whose current shader is in the 'HunFX/' family (the HunFX VFX shader pack — bursts / fire / embers / slashes, shader names 'HunFX/SH_HunFX_common', 'HunFX/SH_HunFX_simple', etc.) is automatically bridged to 'Legacy Shaders/Particles/Additive' — the same target users hand-write '[useshader]' rules for on these materials, applied automatically. This branch runs BEFORE the [useshader] consumption block, so it decides purely from the material's shader identity and ignores any [useshader] rule for HunFX materials by construction. Vanilla materials are unaffected (the provenance veto runs first). The v3.1.53 default-OFF opt-in was validated in-game (449 [HunFXAutoDefault] fires across 51 distinct VFX materials on 3 HunFX shaders, all landing Additive, zero solid geometry caught) and flipped to default-ON in v3.1.54. Set to false to disable the auto-default and route HunFX materials through the aggressive-family Fallback (or your own [useshader] rules). See CHANGELOG v3.1.53 + v3.1.54.");
			_cfgRepairInternalErrorShader = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Repair Internal Error Shader", true, "Default ON. When true, a material whose runtime shader is Unity's 'Hidden/InternalErrorShader' placeholder (the magenta error shader Unity substitutes when a real shader fails to compile or load on Metal) is admitted to the sweep and bound to the Fallback shader (Custom/Creature) so it renders visibly instead of staying pink. Set to false to leave such materials magenta — the opt-in 'show me the pink items that were on this shader' diagnostic: both recognition sites (MaterialClassifier.NeedsReplacement and ActionResolver.ResolveByShaderName) fall through, and because 'Hidden/' is on the safe-shader prefix list NeedsReplacement returns false, leaving the material on its error-shader binding. This is a sweep-side filter toggle, NOT a provenance-gate change — vanilla materials rendering correctly are never affected (their shader is not Hidden/InternalErrorShader). See CHANGELOG v3.1.34.");
			_cfgTrailProbe = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Trail Probe", false, "Diagnostic-only (default OFF). When true, a read-only Harmony postfix on Valheim's MeleeWeaponTrail.Start emits one [TrailProbe] log line per weapon-trail component as it is created, reporting the trail material's name + shader + the owning GameObject path. The vanilla weapon swing/sweep trail is a runtime-generated mesh on a detached GameObject('Trail') with a MeshRenderer — NOT a TrailRenderer, NOT a particle — so it cannot be named by `nearby` / `capture` / `watchr` or by the offline bundle tools. Enable this, swing a weapon, then read the [TrailProbe] lines in LogOutput.log to get the material name. Pure read-only observation — mutates no material, renderer, gate, sweep, resolver, or cache. Disable when done. See CHANGELOG v3.1.56.");
			_cfgDiagnosticProbes = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Diagnostic Probes", false, "Diagnostic-only (default OFF). When true, the [BindProbe-*] shader-collision diagnostics in the bundle-load / Awake paths (OnLoadAsset, MaterialLoad, GameObjectMaterial, ShaderLoad, Baseline, RetroactiveSweep) emit [BindProbe-*] LogInfo lines and run their Resources.FindObjectsOfTypeAll<Shader>() peer-count scans. These are pure read-only observation used to localize vanilla-shader-name collisions during development; they mutate no material, gate, sweep, resolver, baseline, or cache state. Left OFF, the plugin skips the scan + log work entirely on every bundle load and Awake snapshot — recommended for normal play. Enable only for one diagnostic session when asked to capture [BindProbe-*] evidence, then disable. See CHANGELOG v3.1.65.");
			_cfgAutoPolishMetallic = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Auto Polish Metallic Materials", false, "Default OFF (opt-in). When true, a gate-admitted mod material whose source _Metallic >= 0.5 AND that has a metallic-gloss map bound (_MetallicGlossMap / _MetallicMap) has its smoothness slots written (_UseGlossmap=1, _MetalGloss=0.7, _Glossiness=0.9, _Smoothness=0.9) after the Fallback bridge so the matte-metal blade (e.g. BronzeClaymore_mat_TW: _Metallic=1 + metallic-roughness map + smoothness 0 = dark diffuse metal on Metal) reads polished instead of dark. This automates, without a per-sword rule, the fix the user validated by hand via '[useshader] mat:<Blade> Custom/Creature _UseGlossmap=1 _MetalGloss=0.7 _Glossiness=0.9'. The write lands at the POST-BRIDGE Frame-B site the v3.1.49 probe proved has the writable slots (the reverted v3.1.45–47 wrote inside the bridge against a different, slot-less Custom/Creature instance and no-op'd three times). Non-metals (antler/leather/wood, all _Metallic=0) never enter the branch. Any per-mod [useshader] rule still wins (a ruled material returns before reaching this branch). Vanilla materials are unaffected (the provenance veto runs first). Sweep-side property write, NOT a provenance-gate change. Set to true to enable; validate that the intended blades polish and no non-metal changes, then a future release may flip the default ON. See CHANGELOG v3.1.49 + v3.1.50.");
			_cfgAutoPolishEquippedMetal = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Auto Polish Equipped Metal", true, "Default ON (v3.1.52, validated in-game). When true, an equipped-item material the plugin has already bridged to Custom/Creature that carries an ASSIGNED metallic-gloss texture (_MetallicGlossMap has a real texture, not just the empty property slot) has its smoothness slots written so mod-metal weapons (e.g. Warfare IronSledge_mat_TW / bronzedark_mat_TW) read polished without a per-weapon [useshader] rule. The assigned-texture gate cleanly separates metal from equipped wood/leather (whose _MetallicGlossMap is null), which the v3.1.50 'Auto Polish Metallic Materials' _Metallic>=0.5 gate could not (mod authors ship metal weapons at _Metallic 0–0.2). The written values are the tunable 'Auto Polish Use Glossmap' / 'Auto Polish MetalGloss' / 'Auto Polish Glossiness' entries below. Does NOT raise _Metallic and does NOT touch emission (a glowing mod weapon needs a per-mod [useshader] _EmissionColor rule). Only materials already on Custom/Creature (gate-admitted, mod-owned, plugin-bridged) are touched — a correctly-rendering vanilla item is never affected. Sweep-side property write at the equip hook, NOT a provenance-gate change. See CHANGELOG v3.1.51.");
			_cfgAutoPolishMetalAmount = ((BaseUnityPlugin)this).Config.Bind<float>("Diagnostics", "Auto Polish Metallic", 1f, "Tuning for 'Auto Polish Equipped Metal'. The _Metallic value written to polished equipped-metal materials (0 = dielectric/plastic, 1 = fully metallic). Default 1.0. Mods routinely ship metal weapons at _Metallic 0–0.2 (the validated iron-knife knifeironblade_mat_TW = 0), which on a PBR lit shader renders as a glossy dielectric rather than metal even after the gloss writes land — so raising metalness is needed in addition to the smoothness values. Edit, then re-equip the weapon (or reload + sweep) to see the change. Only has effect when 'Auto Polish Equipped Metal' is enabled. See CHANGELOG v3.1.52.");
			_cfgAutoPolishUseGlossmap = ((BaseUnityPlugin)this).Config.Bind<bool>("Diagnostics", "Auto Polish Use Glossmap", true, "Tuning for 'Auto Polish Equipped Metal'. When true (default), the auto-polish writes _UseGlossmap=1 so the bound metallic-gloss map's alpha drives per-texel smoothness; false writes _UseGlossmap=0 (uniform smoothness from the MetalGloss/Glossiness values). Only has effect when 'Auto Polish Equipped Metal' is enabled. See CHANGELOG v3.1.51.");
			_cfgAutoPolishMetalGloss = ((BaseUnityPlugin)this).Config.Bind<float>("Diagnostics", "Auto Polish MetalGloss", 0.7f, "Tuning for 'Auto Polish Equipped Metal'. The _MetalGloss value written to polished equipped-metal materials (0 = matte, 1 = mirror). Default 0.7. Edit, then re-equip the weapon (or reload + sweep) to see the change. Only has effect when 'Auto Polish Equipped Metal' is enabled. See CHANGELOG v3.1.51.");
			_cfgAutoPolishGlossiness = ((BaseUnityPlugin)this).Config.Bind<float>("Diagnostics", "Auto Polish Glossiness", 0.9f, "Tuning for 'Auto Polish Equipped Metal'. The _Glossiness value written to polished equipped-metal materials (0 = matte, 1 = mirror). Default 0.9. Edit, then re-equip the weapon (or reload + sweep) to see the change. Only has effect when 'Auto Polish Equipped Metal' is enabled. See CHANGELOG v3.1.51.");
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				if (!((Object)(object)allLoadedAssetBundle == (Object)null))
				{
					_vanillaBundleNames.Add(((Object)allLoadedAssetBundle).name);
				}
			}
			VanillaBaselineCache.TryExtractEmbeddedBaseline(ConfigDir, Log);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (VanillaBaselineCache.TryLoad(ConfigDir, Log, hashSet, hashSet2, hashSet3, out string cachedValheimVersion))
			{
				foreach (string item in hashSet)
				{
					_baselineMatNames.Add(item);
				}
				foreach (string item2 in hashSet2)
				{
					_vanillaBundleNames.Add(item2);
				}
				foreach (string item3 in hashSet3)
				{
					_vanillaShaderNames.Add(item3);
				}
				Log.LogDebug((object)$"[VanillaCache] loaded as authoritative baseline: {_baselineMatNames.Count} material name(s), {_vanillaShaderNames.Count} shader name(s), {_vanillaBundleNames.Count} bundle name(s).");
				_cachedValheimVersionForDriftCheck = cachedValheimVersion;
				ReplacementCore.BumpAdmissionEpoch("Awake.VanillaCacheLoaded");
			}
			else
			{
				Log.LogWarning((object)"[VanillaCache] WARNING: no on-disk vanilla baseline found. The vanilla-name veto is DISARMED for this session — mod-name collisions with Valheim materials may be replaced unsafely. The plugin ships a pre-populated baseline as an embedded resource; if it failed to extract, run `shaderhelper capturevanilla` from a clean install:");
				Log.LogWarning((object)"[VanillaCache]   1. Move all non-ShaderHelperForMac DLLs out of BepInEx/plugins/.");
				Log.LogWarning((object)"[VanillaCache]   2. Launch Valheim and load any world.");
				Log.LogWarning((object)"[VanillaCache]   3. F5 console: shaderhelper capturevanilla");
				Log.LogWarning((object)"[VanillaCache]   4. Quit, restore your mod DLLs, relaunch.");
			}
			_sweepDisabled = _baselineMatNames.Count == 0 && _vanillaShaderNames.Count == 0;
			if (_sweepDisabled)
			{
				Log.LogWarning((object)"[v3.0] SWEEP DISABLED — vanilla truth file is empty (zero baseline mat names AND zero vanilla shader names). The option-3 admission gate cannot run safely without truth data; admitting everything would include vanilla materials. The replacement sweep will refuse on every trigger this session. Diagnostic commands remain functional. Run `shaderhelper capturevanilla` from a clean install to populate the cache (see [VanillaCache] WARNING above for the 4-step remediation), then relaunch.");
			}
			ReplacementCore.BumpAdmissionEpoch("Awake.PostCacheFlip");
			_awakeVanillaSnapshotEmpty = _vanillaBundleNames.Count == 0;
			Log.LogDebug((object)($"Vanilla bundles snapshotted: {_vanillaBundleNames.Count}" + (_awakeVanillaSnapshotEmpty ? "  (empty ⇒ memory/stream bundle tagging deferred to ZNetScene.Awake retroactive sweep)" : "")));
			_valheimDataPath = Application.dataPath.Replace('\\', '/').TrimEnd(new char[1] { '/' });
			Log.LogDebug((object)("Valheim data path: " + _valheimDataPath));
			int num = ShaderScanner.ScanPlugins(Paths.PluginPath, ModShaderDlls, Log);
			Log.LogDebug((object)$"Scanned plugins: {num} mod shader(s) recorded across {ModShaderDlls.Values.Distinct().Count()} DLL(s).");
			foreach (string item4 in ModShaderDlls.Values.Distinct())
			{
				Log.LogDebug((object)("  Shaders found in: '" + item4 + "'"));
			}
			ConfigLoader.EnsureConfigFiles();
			ReloadConfigFiles();
			StartConfigWatcher();
			BundleAttribution.EmitBaselineSnapshot("Awake-End");
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			_watcher?.Dispose();
		}

		internal static int IndexOfInlineComment(string line)
		{
			return ConfigLoader.IndexOfInlineComment(line);
		}

		internal static void ReloadConfigFiles()
		{
			ConfigLoader.ReloadConfigFiles();
		}

		private void StartConfigWatcher()
		{
			try
			{
				_watcher = new FileSystemWatcher(ConfigDir, "*.txt")
				{
					NotifyFilter = NotifyFilters.LastWrite,
					EnableRaisingEvents = true
				};
				_watcher.Changed += delegate
				{
					ReloadConfigFiles();
				};
			}
			catch
			{
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (!_initialized)
			{
				((MonoBehaviour)this).StartCoroutine(SweepCoordinator.InitAfterFrame(this));
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(SweepCoordinator.SweepAfterFrame(this));
			}
		}

		private void RegisterCommands()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			new ConsoleCommand("shaderhelper", "[patch|patches|undo|sweep|nearby|status|…]  ShaderHelperForMac — run `shaderhelper` alone for full usage.", (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				switch ((args.Length > 1) ? args[1].ToLowerInvariant() : "help")
				{
				case "reload":
					BasicCommands.HandleReload(this, args);
					break;
				case "capturevanilla":
					CaptureVanillaCommand.Handle(this, args);
					break;
				case "sweep":
					BasicCommands.HandleSweep(this, args);
					break;
				case "dumpmod":
					BasicCommands.HandleDumpMod(this, args);
					break;
				case "scan":
					DllFilteredCommands.HandleScan(this, args);
					break;
				case "pink":
					GateAuditCommands.HandlePink(this, args);
					break;
				case "shaders":
					BasicCommands.HandleShaders(this, args);
					break;
				case "renderers":
					BasicCommands.HandleRenderers(this, args);
					break;
				case "all":
					BasicCommands.HandleAll(this, args);
					break;
				case "nearby":
					GateAuditCommands.HandleNearby(this, args);
					break;
				case "transparent":
					DllFilteredCommands.HandleTransparent(this, args);
					break;
				case "loaded":
					DllFilteredCommands.HandleLoaded(this, args);
					break;
				case "checkvanilla":
					GateAuditCommands.HandleCheckVanilla(this, args);
					break;
				case "whymat":
					WhymatCommand.Handle(this, args);
					break;
				case "explain":
					GateAuditCommands.HandleExplain(this, args);
					break;
				case "status":
					StatusCommand.Handle(this, args);
					break;
				case "fallbackchain":
					FallbackChainCommand.Handle(this, args);
					break;
				case "resolveshader":
					ResolveShaderCommand.Handle(this, args);
					break;
				case "bindprobe":
					BindProbeCommand.Handle(this, args);
					break;
				case "patch":
					ConfigAuthoringCommands.HandlePatch(this, args);
					break;
				case "patches":
					ConfigAuthoringCommands.HandlePatches(this, args);
					break;
				case "undo":
					ConfigAuthoringCommands.HandleUndo(this, args);
					break;
				case "dlls":
					DllFilteredCommands.HandleDlls(this, args);
					break;
				case "classify":
					InfoCommands.HandleClassify(this, args);
					break;
				case "dumpprefabmap":
					InfoCommands.HandleDumpPrefabMap(this, args);
					break;
				case "suggest":
					InfoCommands.HandleSuggest(this, args);
					break;
				case "prefab":
					InfoCommands.HandlePrefab(this, args);
					break;
				case "modprefabs":
					InfoCommands.HandleModPrefabs(this, args);
					break;
				case "bundles":
					InfoCommands.HandleBundles(this, args);
					break;
				case "watch":
					ObserverCommands.HandleWatch(this, args);
					break;
				case "watchr":
					ObserverCommands.HandleWatchr(this, args);
					break;
				case "matdump":
					MatDumpCommand.Handle(this, args);
					break;
				case "checkredesign":
					GateAuditCommands.HandleCheckRedesign(this, args);
					break;
				case "psprobe":
					PsProbeCommand.Handle(this, args);
					break;
				case "capture":
				{
					string text = ((args.Length > 2) ? args[2].ToLowerInvariant() : string.Empty);
					if (text == "stop")
					{
						CaptureCommand.HandleStop(this, args);
					}
					else if (text == "start")
					{
						CaptureCommand.HandleStart(this, args);
					}
					else
					{
						args.Context.AddString("Usage: shaderhelper capture start [radius]   — begin continuous nearby-material capture");
						args.Context.AddString("       shaderhelper capture stop             — end capture and emit per-material summary");
					}
					break;
				}
				default:
					args.Context.AddString("Usage:  shaderhelper patch [radius] [DllName]  — stand near pink object; auto-adds a rule to the owning mod's .txt (default radius 15). Pass DllName for large-DLL mods.");
					args.Context.AddString("        shaderhelper patches             — list every batch previously added by `patch`");
					args.Context.AddString("        shaderhelper undo [id|all|last]  — revert the most recent patch batch (or a specific id, or all)");
					args.Context.AddString("        shaderhelper sweep               — run a material sweep immediately (reloads config first)");
					args.Context.AddString("        shaderhelper reload              — reload all config files without running a sweep");
					args.Context.AddString("        shaderhelper nearby [radius] [DllName|mod] — log materials near the player; shows patch=yes when patch would add a rule");
					args.Context.AddString("        shaderhelper transparent <DllName>  — log materials made (or to be made) transparent for a mod");
					args.Context.AddString("        shaderhelper loaded [DllName]    — log all in-memory materials incl. prefabs; optionally filter by mod DLL name");
					args.Context.AddString("        shaderhelper scan <DllName>      — log all materials from a mod with shader/support info");
					args.Context.AddString("        shaderhelper pink                — log all unhandled pink/unsupported materials");
					args.Context.AddString("        shaderhelper renderers           — log materials from active scene renderers");
					args.Context.AddString("        shaderhelper all                 — log ALL loaded materials regardless of action (diagnostics)");
					args.Context.AddString("        shaderhelper explain <MatName>   — audit why a material lands on Fallback/Transparent/Original");
					args.Context.AddString("        shaderhelper checkvanilla <Name> [Name2] ...  — report which vanilla / mod-attribution sets contain each name");
					args.Context.AddString("        shaderhelper whymat <MatName>    — report which lane(s) admitted a material (legacy diagnostic)");
					args.Context.AddString("        shaderhelper watch <MatName> [seconds] — log per-frame material state for N seconds (default 5, max 30); diagnoses flicker invisible to `explain`");
					args.Context.AddString("        shaderhelper watchr <RendererPattern> [seconds] — log per-frame renderer state for N seconds; diagnoses renderer.enabled toggling");
					args.Context.AddString("        shaderhelper matdump <MatName> [--save=<label>] — dump every shader property slot; --save writes to matdump/<label>.txt for later diffing");
					args.Context.AddString("        shaderhelper matdump --diff <labelA> <labelB>   — diff two saved matdumps");
					args.Context.AddString("        shaderhelper checkredesign       — audit the live gate's per-material decisions; reports vanilla-leaks (should always be 0)");
					args.Context.AddString("        shaderhelper classify [N]        — read-only scene walk + histogram of which IsParticleLike signal drives the auto-default");
					args.Context.AddString("        shaderhelper dlls [DllName]      — dump bundle→DLL and shader→DLL attribution tables");
					args.Context.AddString("        shaderhelper dumpprefabmap [DllName] — dump captured prefab-root → DLL attribution map");
					args.Context.AddString("        shaderhelper modprefabs <ModName>   — list every prefab root attributed to one mod with their child materials");
					args.Context.AddString("        shaderhelper bundles             — enumerate every loaded AssetBundle with attribution + TOC sample");
					args.Context.AddString("        shaderhelper suggest <DllName> [write] — dry-run (or write) auto-generated [prefab] lines for a mod");
					args.Context.AddString("        shaderhelper prefab <PrefabName> — list every material (incl. ParticleSystemRenderer effects) under a GameObject by name");
					args.Context.AddString("        shaderhelper capturevanilla      — force-rebuild the vanilla-baseline cache (run after a Valheim update; clean install only)");
					args.Context.AddString("        shaderhelper status              — show current plugin state (fallback shader, rule counts, gate inputs)");
					args.Context.AddString("        shaderhelper fallbackchain       — dump FallbackChain + TransparentChain resolution state (Shader.Find result, Resources matches, isSupported per entry, ACTIVE marker)");
					args.Context.AddString("        shaderhelper resolveshader <ShaderName> — enumerate every Shader instance + Material binding for a given shader name; reveals cross-bundle name-collision splits");
					args.Context.AddString("        shaderhelper psprobe [radius] [seconds]  — read-only ParticleSystemRenderer probe; reports renderer/PS state, optionally watches over a duration");
					args.Context.AddString("        shaderhelper capture start [radius]  — begin continuous nearby-material capture (auto-stops at 60s)");
					args.Context.AddString("        shaderhelper capture stop            — end capture; emits per-material summary sorted by frames-seen ascending (transient FX first)");
					break;
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			Log.LogDebug((object)"Console command 'shaderhelper' registered.");
		}

		internal static void RegisterCommandsInternal(Plugin self)
		{
			self.RegisterCommands();
		}

		private static void CollectCanonicalShaderIds()
		{
			ReplacementCore.CollectCanonicalShaderIds();
		}

		internal static void RefreshCanonicalShaderIdsFromLoadedAssets()
		{
			BundleAttribution.RefreshCanonicalShaderIdsFromLoadedAssets();
		}

		private static void BuildTransparentMaterial()
		{
			ReplacementCore.BuildTransparentMaterial();
		}

		internal static bool IsParticleCapableShaderName(string name)
		{
			return MaterialClassifier.IsParticleCapableShaderName(name);
		}

		internal static bool NeedsReplacement(Shader shader)
		{
			return MaterialClassifier.NeedsReplacement(shader);
		}

		internal static bool IsErrorPink(Material mat)
		{
			return MaterialClassifier.IsErrorPink(mat);
		}

		internal static string? ExtractMatSuffix(string name)
		{
			return MaterialClassifier.ExtractMatSuffix(name);
		}

		internal static bool IsHdrEmission(Material mat)
		{
			return MaterialClassifier.IsHdrEmission(mat);
		}

		internal static bool HasEmissiveIntent(Material mat)
		{
			return MaterialClassifier.HasEmissiveIntent(mat);
		}

		private static Shader? GetEmissiveFallbackShader()
		{
			return MaterialClassifier.GetEmissiveFallbackShader();
		}

		internal static Shader? GetEmissiveFallbackShaderInternal()
		{
			return GetEmissiveFallbackShader();
		}

		internal static bool IsParticleLikeShaderName(string shaderName)
		{
			return MaterialClassifier.IsParticleLikeShaderName(shaderName);
		}

		internal static bool IsParticleLike(Material mat)
		{
			return MaterialClassifier.IsParticleLike(mat);
		}

		internal static bool NeedsReplacement(Material mat)
		{
			return MaterialClassifier.NeedsReplacement(mat);
		}

		internal static bool IsAggressivelySwappable(string shaderName)
		{
			return MaterialClassifier.IsAggressivelySwappable(shaderName);
		}

		internal static bool IsJVLMockShader(string shaderName)
		{
			return MaterialClassifier.IsJVLMockShader(shaderName);
		}

		internal static void TryUpgradeTransparentShader()
		{
			ReplacementCore.TryUpgradeTransparentShader();
		}

		private static void BuildReplacementMaterials()
		{
			ReplacementCore.BuildReplacementMaterials();
		}

		internal static void TryUpgradeFallbackShader()
		{
			ReplacementCore.TryUpgradeFallbackShader();
		}

		internal static Shader? GetReplacementShader(string shaderName)
		{
			ShaderAction action = GetAction(shaderName);
			if (1 == 0)
			{
			}
			Shader result;
			switch (action)
			{
			case ShaderAction.Transparent:
			{
				Material? transparentMat = _transparentMat;
				result = ((transparentMat != null) ? transparentMat.shader : null);
				break;
			}
			case ShaderAction.Fallback:
				result = FallbackShader;
				break;
			case ShaderAction.UseShader:
				result = null;
				break;
			default:
				result = null;
				break;
			}
			if (1 == 0)
			{
			}
			return result;
		}

		internal static bool ShouldReplace(string shaderName)
		{
			if (IsForceTransparent(shaderName))
			{
				return true;
			}
			ModShaderDlls.TryGetValue(shaderName, out string value);
			if (value != null && _useOriginalDlls.Contains(value))
			{
				return false;
			}
			if (value != null && (_useFallbackDlls.Contains(value) || _useTransparentDlls.Contains(value)))
			{
				return true;
			}
			return false;
		}

		internal static bool IsForceTransparentShader(string shaderName)
		{
			return IsForceTransparent(shaderName);
		}

		internal static bool IsForceTransparent(string shaderName)
		{
			foreach (string item in _forceTransparentPrefixSet)
			{
				if (shaderName.StartsWith(item, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsForceFallback(string shaderName)
		{
			foreach (string item in _forceFallbackPrefixSet)
			{
				if (shaderName.StartsWith(item, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static void OnBundleLoadedFromFile(AssetBundle? bundle, string? path)
		{
			BundleAttribution.OnBundleLoadedFromFile(bundle, path);
		}

		internal static void OnBundleLoadedFromMemoryOrStream(AssetBundle? bundle)
		{
			BundleAttribution.OnBundleLoadedFromMemoryOrStream(bundle);
		}

		internal static void OnLoadAssetResult(AssetBundle? bundle, Object? result)
		{
			BundleAttribution.OnLoadAssetResult(bundle, result);
		}

		internal static void RetroactiveBundleSweep(string label)
		{
			BundleAttribution.RetroactiveBundleSweep(label);
		}

		internal static ShaderAction GetAction(Material mat)
		{
			return ActionResolver.Resolve(mat);
		}

		internal static ShaderAction GetAction(string shaderName)
		{
			return ActionResolver.ResolveByShaderName(shaderName);
		}

		internal void SweepMaterials()
		{
			SweepCoordinator.RunSweepMaterials(this);
		}

		internal void SweepMaterialsWithNotify()
		{
			SweepCoordinator.RunSweepMaterialsWithNotify(this);
		}

		internal static void TryReplaceMaterialPublic(Material mat)
		{
			TryReplaceMaterial(mat);
		}

		internal static void DumpMatPropertiesPublic(Material mat, string label)
		{
			MatDump.DumpMatPropertiesIfTargeted(mat, label);
		}

		internal static bool IsMaterialProcessedPublic(Material mat)
		{
			if ((Object)(object)mat == (Object)null)
			{
				return false;
			}
			return ReplacementCore._processedMaterialIds.Contains(((Object)mat).GetInstanceID());
		}

		internal static string StripInstancePublic(string name)
		{
			return StripInstance(name);
		}

		internal static bool IsErrorPinkPublic(Material mat)
		{
			return IsErrorPink(mat);
		}

		internal static bool IsParticleLikePublic(Material mat)
		{
			return IsParticleLike(mat);
		}

		internal IEnumerator SweepMaterialsCoroutine()
		{
			return SweepCoordinator.SweepMaterialsCoroutine(this);
		}

		internal IEnumerator SweepMaterialsCoroutine(string trigger)
		{
			return SweepCoordinator.SweepMaterialsCoroutine(this, trigger);
		}

		private static Shader? FindShaderByName(string name)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			Shader val = Shader.Find(name);
			if ((Object)(object)val != (Object)null && val.isSupported)
			{
				return val;
			}
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			Shader val2 = null;
			Shader[] array2 = array;
			foreach (Shader val3 in array2)
			{
				if (!((Object)(object)val3 == (Object)null) && !(((Object)val3).name != name) && val3.isSupported)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = val3;
					}
					int num = val3.FindPropertyIndex("_Color");
					if (num >= 0 && (int)val3.GetPropertyType(num) == 0)
					{
						return val3;
					}
				}
			}
			return val2;
		}

		internal static Shader? FindShaderByNameInternal(string name)
		{
			return FindShaderByName(name);
		}

		internal static string StripInstance(string name)
		{
			while (name.EndsWith(" (Instance)", StringComparison.Ordinal))
			{
				name = name.Substring(0, name.Length - " (Instance)".Length);
			}
			return name;
		}

		private static bool IsSoftMatRule(Material mat)
		{
			return PatchBatch.IsSoftMatRule(mat);
		}

		internal static bool IsHardMatRule(Material mat)
		{
			return PatchBatch.IsHardMatRule(mat);
		}

		private static bool IsExplicitMatRule(Material mat)
		{
			return PatchBatch.IsExplicitMatRule(mat);
		}

		internal static bool CheckMatNameRules(string matName, out ShaderAction action, out string reason)
		{
			return PatchBatch.CheckMatNameRules(matName, out action, out reason);
		}

		internal static string GeneratePatchBatchId()
		{
			return PatchBatch.GeneratePatchBatchId();
		}

		internal static string AppendPatchBatch(string dllFile, Dictionary<string, List<string>> rulesBySection, string batchId)
		{
			return PatchBatch.AppendPatchBatch(dllFile, rulesBySection, batchId);
		}

		internal static List<(string filePath, string dllName, string batchId, string timestamp, List<string> bodyLines)> EnumeratePatchBatches()
		{
			return PatchBatch.EnumeratePatchBatches();
		}

		internal static bool RemovePatchBatch(string filePath, string batchId)
		{
			return PatchBatch.RemovePatchBatch(filePath, batchId);
		}

		internal static (string section, string matName, string line, string? dllFile)? ProposeMatRule(Material mat, float distance, string parentName)
		{
			return PatchBatch.ProposeMatRule(mat, distance, parentName);
		}

		internal static bool FileAlreadyHasMatRule(string filePath, string matName)
		{
			return PatchBatch.FileAlreadyHasMatRule(filePath, matName);
		}

		internal static int TryReplaceMaterial(Material? mat)
		{
			return ReplacementCore.TryReplaceMaterial(mat);
		}
	}
	internal static class ShaderScanner
	{
		private sealed class NullAssemblyResolver : IAssemblyResolver, IDisposable
		{
			public static readonly NullAssemblyResolver Instance = new NullAssemblyResolver();

			public AssemblyDefinition? Resolve(AssemblyNameReference name)
			{
				return null;
			}

			public AssemblyDefinition? Resolve(AssemblyNameReference name, ReaderParameters p)
			{
				return null;
			}

			public void Dispose()
			{
			}
		}

		private static readonly byte[] UnityMagic = Encoding.ASCII.GetBytes("Unity");

		private static readonly string[] SafePrefixes = new string[13]
		{
			"JVLmock_", "Standard", "Hidden/", "Sprites/", "GUI/", "Particles/", "TextMeshPro/", "UI/", "Skybox/", "Custom/",
			"Unlit/", "Autodesk Interactive", "Lux Lit Particles/"
		};

		public static int ScanPlugins(string pluginsPath, Dictionary<string, string> modShaderDlls, ManualLogSource log)
		{
			if (!Directory.Exists(pluginsPath))
			{
				return 0;
			}
			int num = 0;
			List<string> list = Directory.EnumerateFiles(pluginsPath, "*.dll", SearchOption.AllDirectories).ToList();
			List<string> list2 = Directory.EnumerateFiles(pluginsPath, "*.bundle", SearchOption.AllDirectories).ToList();
			log.LogInfo((object)$"Scanner: found {list.Count} DLL(s) and {list2.Count} bundle file(s) to scan.");
			int num2 = 0;
			foreach (string item in list)
			{
				num2++;
				long num3 = 0L;
				try
				{
					num3 = new FileInfo(item).Length;
				}
				catch
				{
				}
				if (num3 > 10485760)
				{
					log.LogInfo((object)$"[{num2}/{list.Count}] Skipping large DLL '{Path.GetFileNameWithoutExtension(item)}' ({num3 / 1024 / 1024} MB) — use suffix:/mat: rules in txt files instead.");
					continue;
				}
				int num4 = ScanDll(item, modShaderDlls, log);
				if (num4 > 0)
				{
					log.LogDebug((object)$"[{num2}/{list.Count}] '{Path.GetFileNameWithoutExtension(item)}' — {num4} shader(s)");
				}
				num += num4;
			}
			foreach (string item2 in list2)
			{
				num += ScanBundleFile(item2, modShaderDlls, log);
			}
			return num;
		}

		private static int ScanDll(string dllPath, Dictionary<string, string> modShaderDlls, ManualLogSource log)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			try
			{
				AssemblyDefinition val = AssemblyDefinition.ReadAssembly(dllPath, new ReaderParameters
				{
					ReadingMode = (ReadingMode)2,
					AssemblyResolver = (IAssemblyResolver)(object)NullAssemblyResolver.Instance
				});
				try
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(dllPath);
					int num = 0;
					foreach (EmbeddedResource item in ((IEnumerable)val.MainModule.Resources).OfType<EmbeddedResource>())
					{
						byte[] resourceData;
						try
						{
							resourceData = item.GetResourceData();
						}
						catch (Exception ex)
						{
							log.LogDebug((object)("[Diag] " + fileNameWithoutExtension + ": resource '" + ((Resource)item).Name + "' read failed: " + ex.Message));
							continue;
						}
						if (IsUnityBundle(resourceData))
						{
							log.LogDebug((object)$"[Diag] {fileNameWithoutExtension}: found Unity bundle in resource '{((Resource)item).Name}' ({resourceData.Length} bytes)");
							num += ScanBundleBytes(resourceData, fileNameWithoutExtension, modShaderDlls, log);
						}
					}
					return num;
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception ex2)
			{
				log.LogDebug((object)("[Diag] ScanDll failed for '" + Path.GetFileNameWithoutExtension(dllPath) + "': " + ex2.Message));
				return 0;
			}
		}

		private static int ScanBundleFile(string bundlePath, Dictionary<string, string> modShaderDlls, ManualLogSource log)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			try
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(bundlePath);
				AssetsManager val = new AssetsManager();
				BundleFileInstance bundle = val.LoadBundleFile(bundlePath, true);
				int result = ScanBundle(val, bundle, fileNameWithoutExtension, modShaderDlls, log);
				val.UnloadAllBundleFiles();
				return result;
			}
			catch
			{
				return 0;
			}
		}

		private static int ScanBundleBytes(byte[] data, string sourceName, Dictionary<string, string> modShaderDlls, ManualLogSource log)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			try
			{
				AssetsManager val = new AssetsManager();
				using MemoryStream memoryStream = new MemoryStream(data);
				BundleFileInstance val2 = val.LoadBundleFile((Stream)memoryStream, "embedded", true);
				log.LogDebug((object)$"[Diag] {sourceName}: bundle loaded, {val2.file.BlockAndDirInfo.DirectoryInfos.Count} dir entries");
				int result = ScanBundle(val, val2, sourceName, modShaderDlls, log);
				val.UnloadAllBundleFiles();
				return result;
			}
			catch (Exception ex)
			{
				log.LogDebug((object)("[Diag] " + sourceName + ": bundle load failed: " + ex.Message));
				return 0;
			}
		}

		private static int ScanBundle(AssetsManager manager, BundleFileInstance bundle, string sourceName, Dictionary<string, string> modShaderDlls, ManualLogSource log)
		{
			int num = 0;
			List<AssetBundleDirectoryInfo> directoryInfos = bundle.file.BlockAndDirInfo.DirectoryInfos;
			for (int i = 0; i < directoryInfos.Count; i++)
			{
				AssetsFileInstance val = null;
				try
				{
					val = manager.LoadAssetsFileFromBundle(bundle, i, false);
				}
				catch
				{
				}
				if (val == null)
				{
					continue;
				}
				List<AssetFileInfo> assetsOfType = val.file.GetAssetsOfType((AssetClassID)48);
				log.LogDebug((object)$"[Diag] {sourceName}: dir[{i}] has {assetsOfType.Count} shader asset(s)");
				bool flag = true;
				foreach (AssetFileInfo item in assetsOfType)
				{
					try
					{
						string text = ReadAssetName(val, item, flag ? log : null);
						flag = false;
						log.LogDebug((object)$"[Diag] {sourceName}: shader pathId={item.PathId} name='{text}'");
						if (!string.IsNullOrEmpty(text) && !IsLikelySafeShader(text))
						{
							modShaderDlls[text] = sourceName;
							log.LogDebug((object)("Scanner: recorded shader '" + text + "' from '" + sourceName + "'"));
							num++;
						}
					}
					catch (Exception ex)
					{
						log.LogDebug((object)("[Diag] " + sourceName + ": shader read exception: " + ex.Message));
					}
				}
			}
			return num;
		}

		private static string ReadAssetName(AssetsFileInstance af, AssetFileInfo info, ManualLogSource? diagLog = null)
		{
			AssetsFileReader reader = af.file.Reader;
			long absoluteByteOffset = info.GetAbsoluteByteOffset(af.file);
			if (diagLog != null)
			{
				try
				{
					reader.Position = absoluteByteOffset;
					byte[] array = ((BinaryReader)(object)reader).ReadBytes(Math.Min(32, (int)info.ByteSize));
					diagLog.LogDebug((object)$"[Diag] pathId={info.PathId} baseOffset={absoluteByteOffset} byteSize={info.ByteSize} bytes=[{BitConverter.ToString(array)}]");
				}
				catch (Exception ex)
				{
					diagLog.LogDebug((object)$"[Diag] pathId={info.PathId} peek failed: {ex.Message}");
				}
			}
			for (long num = absoluteByteOffset; num <= absoluteByteOffset + info.ByteSize - 4; num += 4)
			{
				try
				{
					reader.Position = num;
					int num2 = ((BinaryReader)(object)reader).ReadInt32();
					if (num2 >= 3 && num2 <= 200)
					{
						byte[] bytes = ((BinaryReader)(object)reader).ReadBytes(num2);
						string text = Encoding.UTF8.GetString(bytes);
						if (IsValidShaderName(text))
						{
							return text;
						}
					}
				}
				catch
				{
				}
			}
			return string.Empty;
		}

		private static bool IsValidShaderName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			if (!char.IsUpper(name[0]))
			{
				return false;
			}
			foreach (char c in name)
			{
				if (c < ' ' || c > '~')
				{
					return false;
				}
			}
			return Enumerable.Contains(name, '/');
		}

		internal static bool IsLikelySafeShader(string name)
		{
			string[] safePrefixes = SafePrefixes;
			foreach (string value in safePrefixes)
			{
				if (name.StartsWith(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsUnityBundle(byte[] data)
		{
			if (data.Length < UnityMagic.Length)
			{
				return false;
			}
			for (int i = 0; i < UnityMagic.Length; i++)
			{
				if (data[i] != UnityMagic[i])
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class VanillaBaselineCache
	{
		private const int SchemaVersion = 3;

		internal const string FileName = "_vanilla_baseline.cache";

		internal const string NoVersion = "<no-cache>";

		private const string EmbeddedResourceName = "ShaderHelperForMac.Resources._vanilla_baseline.cache";

		internal static string GetCachePath(string configDir)
		{
			return Path.Combine(configDir, "_vanilla_baseline.cache");
		}

		internal static bool TryExtractEmbeddedBaseline(string configDir, ManualLogSource log)
		{
			string cachePath = GetCachePath(configDir);
			if (File.Exists(cachePath))
			{
				return false;
			}
			try
			{
				Directory.CreateDirectory(configDir);
				Assembly assembly = typeof(VanillaBaselineCache).Assembly;
				using Stream stream = assembly.GetManifestResourceStream("ShaderHelperForMac.Resources._vanilla_baseline.cache");
				if (stream == null)
				{
					string text = string.Join(", ", assembly.GetManifestResourceNames());
					log.LogWarning((object)("[VanillaCache] embedded baseline resource 'ShaderHelperForMac.Resources._vanilla_baseline.cache' not found in plugin DLL. Available resources: [" + text + "]. Falling back to cold-start (no-cache) path; run `shaderhelper capturevanilla` from a clean install to populate."));
					return false;
				}
				using FileStream destination = File.Create(cachePath);
				stream.CopyTo(destination);
				log.LogInfo((object)("[VanillaCache] extracted shipped baseline cache to '" + cachePath + "' (first-run setup). Loading…"));
				return true;
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("[VanillaCache] embedded-baseline extraction failed at '" + cachePath + "': " + ex.GetType().Name + ": " + ex.Message + ". Falling back to cold-start (no-cache) path."));
				return false;
			}
		}

		internal static bool TryLoad(string configDir, ManualLogSource log, HashSet<string> matNames, HashSet<string> bundleNames, HashSet<string> shaderNames, out string cachedValheimVersion)
		{
			matNames.Clear();
			bundleNames.Clear();
			shaderNames.Clear();
			cachedValheimVersion = "<no-cache>";
			string cachePath = GetCachePath(configDir);
			if (!File.Exists(cachePath))
			{
				log.LogInfo((object)("[VanillaCache] miss: no cache file at '" + cachePath + "'. The plugin ships a pre-populated baseline that should auto-deploy on first run; if you see this message after a fresh install, run `shaderhelper capturevanilla` from a clean install."));
				return false;
			}
			try
			{
				using StreamReader streamReader = new StreamReader(cachePath);
				string text = streamReader.ReadLine();
				if (text == null || !text.StartsWith("# shaderhelper-vanilla-baseline", StringComparison.Ordinal))
				{
					log.LogWarning((object)("[VanillaCache] miss: cache file at '" + cachePath + "' has no magic header — discarding."));
					return false;
				}
				if (!TryParseSchema(text, out var schema))
				{
					log.LogWarning((object)("[VanillaCache] miss: cache header malformed — schema= field missing or unparseable, discarding. (header='" + text + "')"));
					return false;
				}
				if (schema != 3)
				{
					log.LogInfo((object)$"[VanillaCache] miss: cache schema v{schema} ≠ current v{3} — discarding (re-run `shaderhelper capturevanilla` from a clean install, or wait for the shipped pre-populated cache to extract on next plugin load).");
					return false;
				}
				if (!TryParseValheimVersion(text, out string valheimVersion))
				{
					log.LogWarning((object)$"[VanillaCache] miss: schema-v{3} cache header missing `valheim-version=` field — discarding. (header='{text}')");
					return false;
				}
				cachedValheimVersion = valheimVersion;
				string text2 = "";
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				string text3;
				while ((text3 = streamReader.ReadLine()) != null)
				{
					string text4 = text3.Trim();
					if (text4.Length == 0 || text4.StartsWith("#", StringComparison.Ordinal))
					{
						continue;
					}
					if (text4.StartsWith("[", StringComparison.Ordinal) && text4.EndsWith("]", StringComparison.Ordinal))
					{
						text2 = text4.Substring(1, text4.Length - 2).ToLowerInvariant();
						continue;
					}
					switch (text2)
					{
					case "bundles":
						if (bundleNames.Add(text4))
						{
							num2++;
						}
						break;
					case "mats":
						if (matNames.Add(text4))
						{
							num++;
						}
						break;
					case "shaders":
						if (shaderNames.Add(text4))
						{
							num3++;
						}
						break;
					}
				}
				log.LogInfo((object)$"[VanillaCache] HIT: loaded {num} material name(s), {num3} shader name(s), and {num2} bundle name(s) from '{cachePath}' (schema v{schema}, valheim-version='{valheimVersion}').");
				return true;
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("[VanillaCache] miss: unexpected error reading '" + cachePath + "' — treating as miss. (" + ex.GetType().Name + ": " + ex.Message + ")"));
				matNames.Clear();
				bundleNames.Clear();
				shaderNames.Clear();
				cachedValheimVersion = "<no-cache>";
				return false;
			}
		}

		internal static bool Write(string configDir, ManualLogSource log, IReadOnlyCollection<string> bundleNames, IReadOnlyCollection<string> matNames, IReadOnlyCollection<string> shaderNames, string valheimVersion)
		{
			string cachePath = GetCachePath(configDir);
			try
			{
				Directory.CreateDirectory(configDir);
				SortedSet<string> sortedSet = new SortedSet<string>(bundleNames, StringComparer.Ordinal);
				SortedSet<string> sortedSet2 = new SortedSet<string>(matNames, StringComparer.Ordinal);
				SortedSet<string> sortedSet3 = new SortedSet<string>(shaderNames, StringComparer.Ordinal);
				string text = (valheimVersion ?? string.Empty).Replace(' ', '_').Replace('\n', '_').Replace('\r', '_');
				if (text.Length == 0)
				{
					text = "<unknown-version>";
				}
				using StreamWriter streamWriter = new StreamWriter(cachePath, append: false);
				streamWriter.WriteLine($"# shaderhelper-vanilla-baseline schema={3} valheim-version={text}");
				streamWriter.WriteLine($"# Auto-generated at {DateTime.Now:yyyy-MM-dd HH:mm:ss}. Do not edit by hand; re-run `shaderhelper capturevanilla` from a clean install (or wait for the next plugin release) to regenerate.");
				streamWriter.WriteLine($"# {sortedSet.Count} vanilla bundle name(s), {sortedSet2.Count} vanilla material name(s), {sortedSet3.Count} vanilla shader name(s).");
				streamWriter.WriteLine("[bundles]");
				foreach (string item in sortedSet)
				{
					streamWriter.WriteLine(item);
				}
				streamWriter.WriteLine("[mats]");
				foreach (string item2 in sortedSet2)
				{
					streamWriter.WriteLine(item2);
				}
				streamWriter.WriteLine("[shaders]");
				foreach (string item3 in sortedSet3)
				{
					streamWriter.WriteLine(item3);
				}
				log.LogInfo((object)$"[VanillaCache] WROTE: {sortedSet2.Count} material name(s), {sortedSet3.Count} shader name(s), and {sortedSet.Count} bundle name(s) to '{cachePath}' (valheim-version='{text}').");
				return true;
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("[VanillaCache] write failed at '" + cachePath + "': " + ex.GetType().Name + ": " + ex.Message));
				return false;
			}
		}

		internal static void Delete(string configDir, ManualLogSource log)
		{
			string cachePath = GetCachePath(configDir);
			try
			{
				if (File.Exists(cachePath))
				{
					File.Delete(cachePath);
					log.LogInfo((object)("[VanillaCache] deleted '" + cachePath + "' — next `capturevanilla` will rebuild it."));
				}
				else
				{
					log.LogInfo((object)("[VanillaCache] delete requested but no file at '" + cachePath + "' — nothing to do."));
				}
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("[VanillaCache] delete failed at '" + cachePath + "': " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		internal static string GetValheimVersionViaReflection()
		{
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					string name = assembly.GetName().Name;
					if (!string.Equals(name, "assembly_valheim", StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					Type type = assembly.GetType("Version", throwOnError: false, ignoreCase: false);
					if (type == null)
					{
						continue;
					}
					MethodInfo method = type.GetMethod("GetVersionString", BindingFlags.Static | BindingFlags.Public);
					if (method != null)
					{
						string text = method.Invoke(null, null) as string;
						if (!string.IsNullOrEmpty(text))
						{
							return text;
						}
					}
					FieldInfo field = type.GetField("m_currentVersion", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						object value = field.GetValue(null);
						if (value != null)
						{
							return value.ToString() ?? string.Empty;
						}
					}
					PropertyInfo property = type.GetProperty("CurrentVersion", BindingFlags.Static | BindingFlags.Public);
					if (property != null)
					{
						object value2 = property.GetValue(null, null);
						if (value2 != null)
						{
							return value2.ToString() ?? string.Empty;
						}
						break;
					}
					break;
				}
			}
			catch
			{
			}
			return Application.version ?? "<unknown-version>";
		}

		private static bool TryParseSchema(string header, out int schema)
		{
			schema = -1;
			int num = header.IndexOf("schema=", StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			int num2 = num + "schema=".Length;
			int num3 = header.IndexOf(' ', num2);
			if (num3 < 0)
			{
				num3 = header.Length;
			}
			string s = header.Substring(num2, num3 - num2).Trim();
			return int.TryParse(s, out schema);
		}

		private static bool TryParseValheimVersion(string header, out string valheimVersion)
		{
			valheimVersion = string.Empty;
			int num = header.IndexOf("valheim-version=", StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			int num2 = num + "valheim-version=".Length;
			int num3 = header.IndexOf(' ', num2);
			if (num3 < 0)
			{
				num3 = header.Length;
			}
			valheimVersion = header.Substring(num2, num3 - num2).Trim();
			return valheimVersion.Length > 0;
		}
	}
}
namespace ShaderHelperForMac.Sweep
{
	internal static class SweepCoordinator
	{
		private static int _sweepCounter;

		private static string _previousSweepTrigger = "<none>";

		private static DateTime _previousSweepEndTime = DateTime.MinValue;

		internal static HashSet<int>? _currentSweepReplacedMatIds;

		private static HashSet<int> _previousSweepReplacedMatIds = new HashSet<int>();

		private static int _epochAtLastSweepEnd;

		private static bool _lastSweepSnapshotValid;

		private const int MaxConsecutivePeriodicSkips = 10;

		private const int SweepBatchSize = 100;

		internal static void RunSweepMaterials(Plugin self)
		{
			if (!self._sweepRunning)
			{
				((MonoBehaviour)self).StartCoroutine(SweepMaterialsCoroutine(self, "SweepMaterials-api"));
			}
		}

		internal static void RunSweepMaterialsWithNotify(Plugin self)
		{
			if (!self._sweepRunning)
			{
				((MonoBehaviour)self).StartCoroutine(SweepAndNotifyCoroutine(self));
			}
		}

		internal static IEnumerator SweepAndNotifyCoroutine(Plugin self)
		{
			yield return ((MonoBehaviour)self).StartCoroutine(SweepMaterialsCoroutine(self, "console-sweep"));
			MessageHud instance = MessageHud.instance;
			if (instance != null)
			{
				instance.ShowMessage((MessageType)2, "Shader sweep complete", 0, (Sprite)null, false);
			}
		}

		internal static IEnumerator InitAfterFrame(Plugin self)
		{
			yield return null;
			Shader[] allShaders = Resources.FindObjectsOfTypeAll<Shader>();
			Plugin.Log.LogDebug((object)$"Scanning {allShaders.Length} loaded shader objects for a supported fallback.");
			string[] fallbackChain = Plugin.FallbackChain;
			foreach (string name in fallbackChain)
			{
				Shader s = Shader.Find(name) ?? ((IEnumerable<Shader>)allShaders).FirstOrDefault((Func<Shader, bool>)((Shader sh) => ((Object)sh).name == name && sh.isSupported));
				if ((Object)(object)s != (Object)null && s.isSupported)
				{
					Plugin.FallbackShader = s;
					Plugin.Log.LogDebug((object)$"Using fallback shader (supported): '{name}'  id={((Object)Plugin.FallbackShader).GetInstanceID()}");
					break;
				}
			}
			if ((Object)(object)Plugin.FallbackShader == (Object)null)
			{
				string[] fallbackChain2 = Plugin.FallbackChain;
				foreach (string name2 in fallbackChain2)
				{
					Shader s2 = Shader.Find(name2) ?? ((IEnumerable<Shader>)allShaders).FirstOrDefault((Func<Shader, bool>)((Shader sh) => ((Object)sh).name == name2));
					if ((Object)(object)s2 != (Object)null)
					{
						Plugin.FallbackShader = s2;
						Plugin.Log.LogWarning((object)$"Using fallback shader (unsupported, last resort): '{name2}'  id={((Object)Plugin.FallbackShader).GetInstanceID()}");
						break;
					}
				}
			}
			ReplacementCore.BuildTransparentMaterial();
			if ((Object)(object)Plugin.FallbackShader == (Object)null)
			{
				Plugin.Log.LogWarning((object)"No fallback shader found — transparent-only sweep running; will retry full init on next scene load.");
				yield return null;
				yield return ((MonoBehaviour)self).StartCoroutine(SweepMaterialsCoroutine(self, "init"));
				yield break;
			}
			ReplacementCore.CollectCanonicalShaderIds();
			ReplacementCore.BuildReplacementMaterials();
			self._initialized = true;
			try
			{
				new Harmony("aaa.drummercraig.shaderhelperformac").PatchAll();
				Plugin.Log.LogDebug((object)"Harmony patches installed.");
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Plugin.Log.LogError((object)$"Harmony patching error (some patches may be missing): {ex2}");
			}
			BundleAttribution.EmitBaselineSnapshot("PostHarmony");
			Plugin.RegisterCommandsInternal(self);
			try
			{
				int rescuedCount = 0;
				KeepRendererDisabled[] allKeepDisabled = Resources.FindObjectsOfTypeAll<KeepRendererDisabled>();
				KeepRendererDisabled[] array = allKeepDisabled;
				foreach (KeepRendererDisabled kd in array)
				{
					if ((Object)(object)kd == (Object)null)
					{
						continue;
					}
					Renderer owningRenderer = ((Component)kd).gameObject.GetComponent<Renderer>();
					if (owningRenderer is ParticleSystemRenderer)
					{
						Object.Destroy((Object)(object)kd);
						if ((Object)(object)owningRenderer != (Object)null && !owningRenderer.enabled)
						{
							owningRenderer.enabled = true;
						}
						rescuedCount++;
					}
				}
				if (rescuedCount > 0)
				{
					Plugin.Log.LogDebug((object)$"[StartupRescue] Detached KeepRendererDisabled from {rescuedCount} ParticleSystemRenderer(s) — recovering FX renderers disabled by pre-Path-B sweep sites (b)/(c). See LESSONS_LEARNED.md \"Chalice_bubbles_DO root cause — VALIDATED (v3.0.24)\" for the full mechanism.");
				}
			}
			catch (Exception ex)
			{
				Exception ex3 = ex;
				Plugin.Log.LogWarning((object)("[StartupRescue] Cleanup pass threw: " + ex3.Message + " — plugin init continuing."));
			}
			yield return null;
			yield return ((MonoBehaviour)self).StartCoroutine(SweepMaterialsCoroutine(self, "init-post-harmony"));
			((MonoBehaviour)self).StartCoroutine(PeriodicSweepCoroutine(self));
		}

		internal static IEnumerator PeriodicSweepCoroutine(Plugin self)
		{
			while (true)
			{
				float interval = Plugin.PeriodicSweepInterval;
				if (interval <= 0f)
				{
					yield return (object)new WaitForSeconds(5f);
					continue;
				}
				yield return (object)new WaitForSeconds(interval);
				if (self._initialized && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					yield return ((MonoBehaviour)self).StartCoroutine(SweepMaterialsCoroutine(self, "periodic"));
				}
			}
		}

		internal static IEnumerator SweepAfterFrame(Plugin self)
		{
			yield return null;
			yield return ((MonoBehaviour)self).StartCoroutine(SweepMaterialsCoroutine(self, "scene-load"));
		}

		internal static IEnumerator SweepNextFrameCoroutine_Unused(Plugin self)
		{
			yield return null;
			RunSweepMaterials(self);
		}

		internal static IEnumerator SweepMaterialsCoroutine(Plugin self)
		{
			return SweepMaterialsCoroutine(self, "unspecified");
		}

		internal static IEnumerator SweepMaterialsCoroutine(Plugin self, string trigger)
		{
			if (self._sweepRunning || ((Object)(object)Plugin._transparentMat == (Object)null && (Object)(object)Plugin._fallbackMat == (Object)null))
			{
				yield break;
			}
			if (Plugin._sweepDisabled)
			{
				Plugin.Log.LogInfo((object)("[SweepRefused] trigger='" + trigger + "' — _sweepDisabled=true (vanilla truth file empty; see [v3.0] warning at Awake)."));
				yield break;
			}
			self._sweepRunning = true;
			_sweepCounter++;
			int sweepIndex = _sweepCounter;
			Stopwatch sweepStopwatch = Stopwatch.StartNew();
			Stopwatch batchStopwatch = Stopwatch.StartNew();
			int batchIndex = 0;
			DateTime sweepStartTime = DateTime.UtcNow;
			string deltaSince = ((_previousSweepEndTime == DateTime.MinValue) ? "0s" : $"{(sweepStartTime - _previousSweepEndTime).TotalSeconds:F1}s");
			if ((trigger == "periodic" || trigger == "Location.Awake") && _lastSweepSnapshotValid && ReplacementCore._admissionEpoch == _epochAtLastSweepEnd && !Plugin._forceNextPeriodicSweep && Plugin._consecutiveSweepSkips < 10)
			{
				Plugin._consecutiveSweepSkips++;
				Plugin.Log.LogDebug((object)$"[SweepSkip]  trigger='{trigger}' #{sweepIndex} epoch={ReplacementCore._admissionEpoch} no-change (skips={Plugin._consecutiveSweepSkips}/{10})");
				_previousSweepTrigger = trigger;
				_previousSweepEndTime = DateTime.UtcNow;
				self._sweepRunning = false;
				yield break;
			}
			Plugin._forceNextPeriodicSweep = false;
			Plugin._consecutiveSweepSkips = 0;
			Plugin.Log.LogDebug((object)$"[SweepStart] trigger='{trigger}' #{sweepIndex} (previous='{_previousSweepTrigger}', Δ={deltaSince})");
			_currentSweepReplacedMatIds = new HashSet<int>();
			int replaced = 0;
			int matsProcessed = 0;
			Plugin._prefabScopedModMatIds.Clear();
			Plugin._particleRendererMatIdHints.Clear();
			Renderer[] allRenderers = Resources.FindObjectsOfTypeAll<Renderer>();
			bool lane5Active = Plugin._modPrefabRootNames.Count > 0;
			for (int ri = 0; ri < allRenderers.Length; ri++)
			{
				Renderer r = allRenderers[ri];
				if ((Object)(object)r == (Object)null)
				{
					continue;
				}
				bool lane5Match = false;
				if (lane5Active)
				{
					Transform t = ((Component)r).transform;
					while ((Object)(object)t != (Object)null)
					{
						string ancestorName = Plugin.StripCloneSuffix(((Object)t).name);
						if (Plugin._modPrefabRootNames.Contains(ancestorName))
						{
							lane5Match = true;
							break;
						}
						t = t.parent;
					}
				}
				if (r is ParticleSystemRenderer)
				{
					Material[] sharedMaterials = r.sharedMaterials;
					foreach (Material psMat in sharedMaterials)
					{
						if (!((Object)(object)psMat == (Object)null))
						{
							Plugin._particleRendererMatIdHints.Add(((Object)psMat).GetInstanceID());
						}
					}
				}
				if (lane5Match)
				{
					Material[] sharedMaterials2 = r.sharedMaterials;
					foreach (Material mat in sharedMaterials2)
					{
						if (!((Object)(object)mat == (Object)null))
						{
							Plugin._prefabScopedModMatIds.Add(((Object)mat).GetInstanceID());
						}
					}
				}
				if (lane5Match && (Plugin._hideRendererMatNames.Count > 0 || Plugin._hideRendererMatSuffixes.Count > 0))
				{
					bool shouldHide = false;
					Material[] sharedMaterials3 = r.sharedMaterials;
					foreach (Material mat2 in sharedMaterials3)
					{
						if ((Object)(object)mat2 == (Object)null)
						{
							continue;
						}
						string baseName = Plugin.StripInstance(((Object)mat2).name);
						if (Plugin._hideRendererMatNames.Contains(baseName))
						{
							shouldHide = true;
							break;
						}
						foreach (string sfx in Plugin._hideRendererMatSuffixes)
						{
							if (baseName.EndsWith(sfx, StringComparison.OrdinalIgnoreCase))
							{
								shouldHide = true;
								break;
							}
						}
						if (shouldHide)
						{
							break;
						}
					}
					if (shouldHide)
					{
						if (r.enabled)
						{
							r.enabled = false;
						}
						if ((Object)(object)((Component)r).gameObject.GetComponent<KeepRendererDisabled>() == (Object)null)
						{
							((Component)r).gameObject.AddComponent<KeepRendererDisabled>();
						}
						Plugin.Log.LogDebug((object)("[HideRenderer] '" + ((Object)((Component)r).gameObject).name + "' — ancestor match + [hiderenderer] mat rule → disabled."));
						if (ri % 100 == 0)
						{
							if (Plugin.SweepProgressTrace)
							{
								Plugin.Log.LogInfo((object)$"[SweepProgress] #{sweepIndex} batch={batchIndex} site=hiderenderer ri={ri} batchMs={batchStopwatch.ElapsedMilliseconds} cumMs={sweepStopwatch.ElapsedMilliseconds} mats={matsProcessed} replaced={replaced}");
							}
							batchIndex++;
							batchStopwatch.Restart();
							yield return null;
						}
						continue;
					}
				}
				bool needsInstanceFix = false;
				Material[] sharedMaterials4 = r.sharedMaterials;
				foreach (Material mat3 in sharedMaterials4)
				{
					if (!((Object)(object)mat3 == (Object)null) && !((Object)(object)mat3.shader == (Object)null) && !((Object)(object)mat3 == (Object)(object)Plugin._transparentMat) && !((Object)(object)mat3 == (Object)(object)Plugin._fallbackMat) && (Plugin.NeedsReplacement(mat3) || Plugin.IsHardMatRule(mat3)) && Plugin.GetAction(mat3) != ShaderAction.Original)
					{
						needsInstanceFix = true;
						break;
					}
				}
				if (needsInstanceFix)
				{
					Material[] instMats = r.materials;
					bool changed = false;
					for (int m = 0; m < instMats.Length; m++)
					{
						if (!((Object)(object)instMats[m] == (Object)null) && !((Object)(object)instMats[m].shader == (Object)null) && Plugin.NeedsReplacement(instMats[m]) && Plugin.TryReplaceMaterial(instMats[m]) > 0)
						{
							changed = true;
							replaced++;
						}
					}
					if (changed)
					{
						r.materials = instMats;
						Plugin.Log.LogDebug((object)$"[InstanceFix] '{((Object)((Component)r).gameObject).name}' — {instMats.Length} instance mat(s) updated.");
					}
				}
				Material[] sharedMaterials5 = r.sharedMaterials;
				foreach (Material mat4 in sharedMaterials5)
				{
					if (!((Object)(object)mat4 == (Object)null))
					{
						replaced += Plugin.TryReplaceMaterial(mat4);
						matsProcessed++;
					}
				}
				if (ri % 100 == 0)
				{
					if (Plugin.SweepProgressTrace)
					{
						Plugin.Log.LogInfo((object)$"[SweepProgress] #{sweepIndex} batch={batchIndex} site=loop-end ri={ri} batchMs={batchStopwatch.ElapsedMilliseconds} cumMs={sweepStopwatch.ElapsedMilliseconds} mats={matsProcessed} replaced={replaced}");
					}
					batchIndex++;
					batchStopwatch.Restart();
					yield return null;
				}
			}
			sweepStopwatch.Stop();
			int totalReplaced = _currentSweepReplacedMatIds?.Count ?? 0;
			int reReplaced = 0;
			if (_currentSweepReplacedMatIds != null)
			{
				foreach (int id in _currentSweepReplacedMatIds)
				{
					if (_previousSweepReplacedMatIds.Contains(id))
					{
						reReplaced++;
					}
				}
			}
			int newReplaced = totalReplaced - reReplaced;
			if (totalReplaced > 0)
			{
				Plugin.Log.LogInfo((object)$"[SweepEnd]   trigger='{trigger}' #{sweepIndex} replaced={totalReplaced} (new={newReplaced} re-replaced={reReplaced}) duration={sweepStopwatch.ElapsedMilliseconds}ms");
			}
			else
			{
				Plugin.Log.LogDebug((object)$"[SweepEnd]   trigger='{trigger}' #{sweepIndex} replaced=0 duration={sweepStopwatch.ElapsedMilliseconds}ms");
			}
			_previousSweepReplacedMatIds = _currentSweepReplacedMatIds ?? new HashSet<int>();
			_currentSweepReplacedMatIds = null;
			_previousSweepTrigger = trigger;
			_previousSweepEndTime = DateTime.UtcNow;
			_epochAtLastSweepEnd = ReplacementCore._admissionEpoch;
			_lastSweepSnapshotValid = true;
			if (replaced > 0)
			{
				Plugin.Log.LogInfo((object)$"Replaced {replaced} material(s).");
			}
			self._sweepRunning = false;
		}
	}
}
namespace ShaderHelperForMac.Shaders
{
	internal static class MaterialClassifier
	{
		private static Shader? _emissiveFallbackShader;

		private static readonly string[] _particleLikeShaderKeywords = new string[9] { "Particle", "Glow", "Trail", "Distort", "ForceField", "Flame", "Smoke", "Fog", "Flare" };

		internal static bool IsParticleCapableShaderName(string name)
		{
			return name == "Particles/Standard Unlit" || name == "Legacy Shaders/Particles/Alpha Blended" || name == "Particles/Standard Surface2";
		}

		internal static bool NeedsReplacement(Shader shader)
		{
			string name = ((Object)shader).name;
			if (IsJVLMockShader(name))
			{
				return false;
			}
			if (Plugin.RepairInternalErrorShader && name.StartsWith("Hidden/InternalErrorShader", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (name.StartsWith("TextMeshPro/", StringComparison.OrdinalIgnoreCase) && name.EndsWith(" (Surface)", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (Plugin.IsForceFallback(name))
			{
				return true;
			}
			if (Plugin.IsForceTransparent(name))
			{
				return true;
			}
			bool flag = IsAggressivelySwappable(name);
			if (shader.isSupported && !flag)
			{
				return false;
			}
			if (Plugin.CanonicalShaderIds.Contains(((Object)shader).GetInstanceID()) && !flag)
			{
				return false;
			}
			if (ShaderScanner.IsLikelySafeShader(name) && !flag)
			{
				return false;
			}
			return true;
		}

		internal static bool IsErrorPink(Material mat)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (mat.HasProperty("_Color"))
			{
				Color color = mat.color;
				result = ((color.r > 0.9f && color.g < 0.1f && color.b > 0.7f) ? 1 : 0);
			}
			else
			{
				result = 0;
			}
			return (byte)result != 0;
		}

		internal static bool IsMagenta(Color c)
		{
			//IL_0000: 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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return c.r > 0.9f && c.g < 0.1f && c.b > 0.7f;
		}

		internal static string? ExtractMatSuffix(string name)
		{
			int num = name.LastIndexOf('_');
			if (num < 0 || num == name.Length - 1)
			{
				return null;
			}
			return name.Substring(num + 1);
		}

		internal static bool IsHdrEmission(Material mat)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			int result;
			if (mat.HasProperty("_EmissionColor"))
			{
				Color color = mat.GetColor("_EmissionColor");
				result = ((color.r > 1f || color.g > 1f || color.b > 1f) ? 1 : 0);
			}
			else
			{
				result = 0;
			}
			return (byte)result != 0;
		}

		internal static bool HasEmissiveIntent(Material mat)
		{
			//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)
			if ((Object)(object)mat == (Object)null)
			{
				return false;
			}
			string text = MaterialBridge.FirstProperty(mat, new string[2] { "_EmissionMap", "_EmissiveMap" });
			if (text != null && (Object)(object)mat.GetTexture(text) != (Object)null)
			{
				return true;
			}
			if (mat.IsKeywordEnabled("_EMISSION") && mat.HasProperty("_EmissionColor"))
			{
				Color color = mat.GetColor("_EmissionColor");
				if (((Color)(ref color)).maxColorComponent > 0.01f)
				{
					return true;
				}
			}
			if (IsHdrEmission(mat))
			{
				return true;
			}
			return false;
		}

		internal static Shader? GetEmissiveFallbackShader()
		{
			if ((Object)(object)_emissiveFallbackShader != (Object)null)
			{
				return _emissiveFallbackShader;
			}
			_emissiveFallbackShader = Plugin.FindShaderByNameInternal("Custom/Piece");
			return _emissiveFallbackShader;
		}

		internal static bool IsParticleLikeShaderName(string shaderName)
		{
			string[] particleLikeShaderKeywords = _particleLikeShaderKeywords;
			foreach (string value in particleLikeShaderKeywords)
			{
				if (shaderName.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsParticleLike(Material mat)
		{
			return IsErrorPink(mat) || IsHdrEmission(mat) || IsParticleLikeShaderName(((Object)mat.shader).name);
		}

		internal static bool NeedsReplacement(Material mat)
		{
			return NeedsReplacement(mat.shader) || IsErrorPink(mat);
		}

		internal static bool IsAggressivelySwappable(string shaderName)
		{
			if (Plugin.ValheimShaderNameSet.Contains(shaderName))
			{
				return false;
			}
			if (IsJVLMockShader(shaderName))
			{
				return false;
			}
			return shaderName.StartsWith("Standard", StringComparison.OrdinalIgnoreCase) || shaderName.StartsWith("Particles/", StringComparison.OrdinalIgnoreCase) || shaderName.StartsWith("Legacy Shaders/", StringComparison.OrdinalIgnoreCase);
		}

		internal static bool IsJVLMockShader(string shaderName)
		{
			return shaderName.StartsWith("JVLmock_", StringComparison.OrdinalIgnoreCase);
		}
	}
	internal static class ShaderCatalog
	{
		public static readonly string[] ValheimShaderNames = new string[52]
		{
			"Custom/Piece", "Custom/Creature", "Custom/Vegetation", "Custom/StaticRock", "Custom/Lit", "Custom/LitParticles", "Custom/FlowOpaque", "Custom/Billboard", "Custom/DistantLod", "Custom/WaterLily",
			"Custom/Trilinear", "Custom/Decal", "Custom/Cliff", "Custom/Skybox", "Custom/Distortion", "Custom/Player", "Custom/Blob", "Custom/Bonemass", "Custom/Grass", "Custom/Heightmap",
			"Custom/Rug", "Custom/ShadowBlob", "Custom/Tar", "Custom/Trilinearmap", "Custom/Yggdrasil", "Custom/Yggdrasil_root", "Custom/Water", "Custom/WaterBottom", "Custom/WaterMask", "Custom/Clouds",
			"Custom/Flow", "Custom/SkyboxProcedural", "Custom/SkyObject", "Custom/icon", "Custom/LitGui", "Custom/mapshader", "Custom/UI/AntiAliasedCircle", "Custom/UI_BGBlur", "Custom/AlphaParticle", "Custom/Gradient Mapped Particle (Unlit)",
			"Custom/Mesh Flipbook Particle", "Custom/Particle (Unlit)", "Custom/ParticleDecal", "FX/Glass/Stained BumpDistort", "FX/Glass/Stained", "Unlit/Lighting", "ToonDeferredShading", "ToonDeferredShading2017", "Earthquake/Tree", "Earthquake/Leaf",
			"Hovl/Particles/Additive", "Hovl/Particles/AlphaBlend"
		};

		public static readonly string[] UnityBuiltInShaderNames = new string[25]
		{
			"Standard", "Standard (Specular setup)", "Standard (Roughness setup)", "Sprites/Default", "Sprites/Mask", "UI/Default", "UI/DefaultFont", "UI/Unlit/Text", "UI/Unlit/Transparent", "Unlit/Color",
			"Unlit/Texture", "Unlit/Transparent", "Unlit/Transparent Cutout", "Diffuse", "Mobile/Diffuse", "Transparent/Diffuse", "VertexLit", "Mobile/VertexLit", "Legacy Shaders/Particles/Alpha Blended", "Legacy Shaders/Particles/Additive",
			"Legacy Shaders/Particles/Additive (Soft)", "Legacy Shaders/Particles/Multiply", "Legacy Shaders/Particles/VertexLit Blended", "Particles/Standard Unlit", "Particles/Standard Surface"
		};

		public static readonly HashSet<string> ValheimShaderNameSet = new HashSet<string>(ValheimShaderNames, StringComparer.OrdinalIgnoreCase);

		public static readonly HashSet<string> UnityBuiltInShaderNameSet = new HashSet<string>(UnityBuiltInShaderNames, StringComparer.OrdinalIgnoreCase);

		public static readonly string[] FallbackChain = new string[2] { "Custom/Creature", "Custom/Piece" };

		public static readonly string[] TransparentChain = new string[5] { "Particles/Standard Unlit", "Legacy Shaders/Particles/Alpha Blended", "Particles/Standard Surface2", "Sprites/Default", "UI/Default" };

		public static bool IsParticleCapableShaderName(string name)
		{
			return name == "Particles/Standard Unlit" || name == "Legacy Shaders/Particles/Alpha Blended" || name == "Particles/Standard Surface2";
		}

		public static bool IsAggressivelySwappable(string shaderName)
		{
			return shaderName.StartsWith("Standard", StringComparison.OrdinalIgnoreCase) || shaderName.StartsWith("Particles/", StringComparison.OrdinalIgnoreCase) || shaderName.StartsWith("Legacy Shaders/", StringComparison.OrdinalIgnoreCase);
		}
	}
}
namespace ShaderHelperForMac.Replacement
{
	internal static class ActionResolver
	{
		public static ShaderAction Resolve(Material mat, ResolveTrace? trace = null)
		{
			if ((Object)(object)mat == (Object)null || (Object)(object)mat.shader == (Object)null)
			{
				trace?.Add("mat/shader is null", ShaderAction.Original);
				return ShaderAction.Original;
			}
			string text = Plugin.StripInstancePublic(((Object)mat).name);
			if (Plugin._forceTransparentMatNames.Contains(text))
			{
				trace?.Add("forcetransparent mat:'" + text + "' matched", ShaderAction.Transparent);
				return ShaderAction.Transparent;
			}
			if (Plugin._forceFallbackMatNames.Contains(text))
			{
				trace?.Add("forcefallback mat:'" + text + "' matched", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			foreach (string forceTransparentMatSuffix in Plugin._forceTransparentMatSuffixes)
			{
				if (text.EndsWith(forceTransparentMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					trace?.Add("forcetransparent suffix:'" + forceTransparentMatSuffix + "' matched mat '" + text + "'", ShaderAction.Transparent);
					return ShaderAction.Transparent;
				}
			}
			foreach (string forceFallbackMatSuffix in Plugin._forceFallbackMatSuffixes)
			{
				if (text.EndsWith(forceFallbackMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					trace?.Add("forcefallback suffix:'" + forceFallbackMatSuffix + "' matched mat '" + text + "'", ShaderAction.Fallback);
					return ShaderAction.Fallback;
				}
			}
			if (Plugin.CanonicalShaderIds.Contains(((Object)mat.shader).GetInstanceID()))
			{
				trace?.Add($"CanonicalShaderIds contains shader '{((Object)mat.shader).name}' (id={((Object)mat.shader).GetInstanceID()})", ShaderAction.Original);
				return ShaderAction.Original;
			}
			if (Plugin._originalMatNames.Contains(text))
			{
				trace?.Add("[original] mat:'" + text + "' matched", ShaderAction.Original);
				return ShaderAction.Original;
			}
			if (Plugin._transparentMatNames.Contains(text))
			{
				trace?.Add("[transparent] mat:'" + text + "' matched", ShaderAction.Transparent);
				return ShaderAction.Transparent;
			}
			if (Plugin._fallbackMatNames.Contains(text))
			{
				trace?.Add("[fallback] mat:'" + text + "' matched", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			bool flag = false;
			bool flag2 = false;
			string text2 = null;
			string text3 = null;
			foreach (string fallbackMatSuffix in Plugin._fallbackMatSuffixes)
			{
				if (text.EndsWith(fallbackMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					flag = true;
					text2 = fallbackMatSuffix;
					break;
				}
			}
			foreach (string transparentMatSuffix in Plugin._transparentMatSuffixes)
			{
				if (text.EndsWith(transparentMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					flag2 = true;
					text3 = transparentMatSuffix;
					break;
				}
			}
			if (flag && flag2)
			{
				bool flag3 = Plugin.IsParticleLikePublic(mat);
				ShaderAction shaderAction = ((!flag3) ? ShaderAction.Fallback : ShaderAction.Transparent);
				trace?.Add($"soft suffix tie: [fallback]suffix:'{text2}' AND [transparent]suffix:'{text3}' — IsParticleLike={flag3} → {shaderAction}", shaderAction);
				return shaderAction;
			}
			if (flag)
			{
				trace?.Add("[fallback] suffix:'" + text2 + "' matched mat '" + text + "'", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			if (flag2)
			{
				trace?.Add("[transparent] suffix:'" + text3 + "' matched mat '" + text + "'", ShaderAction.Transparent);
				return ShaderAction.Transparent;
			}
			if (Plugin.IsErrorPinkPublic(mat))
			{
				trace?.Add("IsErrorPink (color ~magenta) matched", ShaderAction.Transparent);
				return ShaderAction.Transparent;
			}
			return ResolveByShaderName(((Object)mat.shader).name, trace);
		}

		public static ShaderAction ResolveByShaderName(string shaderName, ResolveTrace? trace = null)
		{
			if (Plugin.RepairInternalErrorShader && shaderName.StartsWith("Hidden/InternalErrorShader", StringComparison.OrdinalIgnoreCase))
			{
				trace?.Add("shader '" + shaderName + "' is Hidden/InternalErrorShader", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			if (shaderName.StartsWith("TextMeshPro/", StringComparison.OrdinalIgnoreCase) && shaderName.EndsWith(" (Surface)", StringComparison.OrdinalIgnoreCase))
			{
				trace?.Add("shader '" + shaderName + "' is TextMeshPro Surface variant", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			if (IsForceTransparentByName(shaderName, out string matchedPrefix))
			{
				trace?.Add("force-transparent prefix '" + matchedPrefix + "' matched shader '" + shaderName + "'", ShaderAction.Transparent);
				return ShaderAction.Transparent;
			}
			if (IsForceFallbackByName(shaderName, out string matchedPrefix2))
			{
				trace?.Add("force-fallback prefix '" + matchedPrefix2 + "' matched shader '" + shaderName + "'", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			if (ShaderCatalog.ValheimShaderNameSet.Contains(shaderName))
			{
				trace?.Add("Valheim shader name '" + shaderName + "' matched", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			Plugin.ModShaderDlls.TryGetValue(shaderName, out string value);
			if (value != null && Plugin._useOriginalDlls.Contains(value))
			{
				trace?.Add("[original] dll '" + value + "' matched for shader '" + shaderName + "'", ShaderAction.Original);
				return ShaderAction.Original;
			}
			if (value != null && Plugin._useTransparentDlls.Contains(value))
			{
				trace?.Add("[default]transparent for dll '" + value + "' matched shader '" + shaderName + "'", ShaderAction.Transparent);
				return ShaderAction.Transparent;
			}
			if (value != null && Plugin._useFallbackDlls.Contains(value))
			{
				trace?.Add("[default]fallback for dll '" + value + "' matched shader '" + shaderName + "'", ShaderAction.Fallback);
				return ShaderAction.Fallback;
			}
			trace?.Add("no rule matched shader '" + shaderName + "' (dll='" + (value ?? "unknown") + "') — Original", ShaderAction.Original);
			return ShaderAction.Original;
		}

		public static bool IsForceTransparentByName(string shaderName, out string? matchedPrefix)
		{
			foreach (string item in Plugin._forceTransparentPrefixSet)
			{
				if (shaderName.StartsWith(item, StringComparison.OrdinalIgnoreCase))
				{
					matchedPrefix = item;
					return true;
				}
			}
			matchedPrefix = null;
			return false;
		}

		public static bool IsForceFallbackByName(string shaderName, out string? matchedPrefix)
		{
			foreach (string item in Plugin._forceFallbackPrefixSet)
			{
				if (shaderName.StartsWith(item, StringComparison.OrdinalIgnoreCase))
				{
					matchedPrefix = item;
					return true;
				}
			}
			matchedPrefix = null;
			return false;
		}
	}
	internal sealed class ResolveTrace
	{
		private readonly List<(string reason, ShaderAction action)> _steps = new List<(string, ShaderAction)>();

		public IReadOnlyList<(string reason, ShaderAction action)> Steps => _steps;

		public void Add(string reason, ShaderAction action)
		{
			_steps.Add((reason, action));
		}

		public string Format(string indent = "  ")
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < _steps.Count; i++)
			{
				var (value, shaderAction) = _steps[i];
				stringBuilder.Append(indent).Append('[').Append(i + 1)
					.Append("] → ")
					.Append(shaderAction.ToString().PadRight(11))
					.Append("  ")
					.AppendLine(value);
			}
			return stringBuilder.ToString();
		}
	}
	internal static class MaterialBridge
	{
		private enum BridgeType
		{
			Texture,
			Color,
			Float
		}

		private static readonly (string group, BridgeType t, string[] names)[] BridgeGroups = new(string, BridgeType, string[])[10]
		{
			("albedoMap", BridgeType.Texture, new string[1] { "_MainTex" }),
			("tint", BridgeType.Color, new string[1] { "_Color" }),
			("metallicMap", BridgeType.Texture, new string[2] { "_MetallicGlossMap", "_MetallicMap" }),
			("metallic", BridgeType.Float, new string[1] { "_Metallic" }),
			("smoothness", BridgeType.Float, new string[3] { "_Glossiness", "_MetalGloss", "_Smoothness" }),
			("normalMap", BridgeType.Texture, new string[2] { "_BumpMap", "_NormalMap" }),
			("normalScale", BridgeType.Float, new string[2] { "_BumpScale", "_NormalScale" }),
			("emissionMap", BridgeType.Texture, new string[2] { "_EmissionMap", "_EmissiveMap" }),
			("emissionCol", BridgeType.Color, new string[1] { "_EmissionColor" }),
			("occlusion", BridgeType.Texture, new string[1] { "_OcclusionMap" })
		};

		private static readonly HashSet<int> _draugrTraceFiredMatIds = new HashSet<int>();

		private static readonly HashSet<int> _preSwapProbeFiredMatIds = new HashSet<int>();

		private static readonly HashSet<int> _postSwapProbeFiredMatIds = new HashSet<int>();

		private static readonly string[] _preSwapProbePrefixes = new string[6] { "M_Burst", "M_Fire", "M_Ember", "M_radial", "M_Slash", "M_Wind" };

		private static bool PreSwapProbeNameMatches(string baseName)
		{
			string[] preSwapProbePrefixes = _preSwapProbePrefixes;
			foreach (string value in preSwapProbePrefixes)
			{
				if (baseName.StartsWith(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static string? FirstProperty(Material mat, string[] names)
		{
			foreach (string text in names)
			{
				if (mat.HasProperty(text))
				{
					return text;
				}
			}
			return null;
		}

		internal static void BridgeMaterialProperties(Material mat, Shader target)
		{
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a87: Unknown result type (might be due to invalid IL or missing references)
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Invalid comparison between Unknown and I4
			//IL_0ed0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be9: Invalid comparison between Unknown and I4
			//IL_0f1b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f51: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null)
			{
				return;
			}
			HashSet<string> bridgeTraceMatNames = Plugin.BridgeTraceMatNames;
			string text = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
			if (bridgeTraceMatNames.Contains(text))
			{
				int instanceID = ((Object)mat).GetInstanceID();
				bool flag = ReplacementCore._processedMaterialIds.Contains(instanceID);
				int value;
				bool flag2 = ReplacementCore._cachedShaderIdByMat.TryGetValue(instanceID, out value);
				(string, ShaderAction) value2;
				bool flag3 = ReplacementCore._replacedMats.TryGetValue(instanceID, out value2);
				int value3;
				bool flag4 = ReplacementCore._cacheEpochByMat.TryGetValue(instanceID, out value3);
				Plugin.Log.LogDebug((object)($"[BridgeEntry-State] mat='{text}'  matId={instanceID}" + $"  inProcessed={flag}" + string.Format("  inCachedShaderId={0}  cachedShaderId={1}", flag2, flag2 ? value.ToString() : "n/a") + string.Format("  inReplacedMats={0}  prevReplacement='{1}'", flag3, flag3 ? $"{value2.Item1} → {value2.Item2}" : "<absent>") + string.Format("  currentEpoch={0}  cachedEpoch={1}", ReplacementCore._admissionEpoch, flag4 ? value3.ToString() : "n/a") + $"  bridgeTraceMatNamesCount={bridgeTraceMatNames.Count}  bridgeTraceMatNamesContainsBase=true"));
			}
			HashSet<string> bridgeTraceMatNames2 = Plugin.BridgeTraceMatNames;
			if (bridgeTraceMatNames2.Count > 0)
			{
				string text2 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
				if (bridgeTraceMatNames2.Contains(text2))
				{
					int instanceID2 = ((Object)mat).GetInstanceID();
					int num = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).GetInstanceID() : 0);
					string arg = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).name : "<null>");
					string text3 = "<absent>";
					if (mat.HasProperty("_EmissionColor"))
					{
						Color color = mat.GetColor("_EmissionColor");
						text3 = $"RGBA({color.r:F3},{color.g:F3},{color.b:F3},{color.a:F3})";
					}
					bool flag5 = Plugin.IsHdrEmission(mat);
					bool flag6 = mat.IsKeywordEnabled("_EMISSION");
					bool flag7 = Plugin.HasEmissiveIntent(mat);
					int num2 = (((Object)(object)target != (Object)null) ? ((Object)target).GetInstanceID() : 0);
					Plugin.Log.LogDebug((object)($"[BridgeTrace] mat='{text2}'  matId={instanceID2}" + $"  shader='{arg}'  shaderId={num}" + string.Format("  target='{0}'  targetId={1}", ((Object)(object)target != (Object)null) ? ((Object)target).name : "<null>", num2) + "  _EmissionColor=" + text3 + $"  Plugin.IsHdrEmission={flag5}  _EMISSION={flag6}" + $"  Plugin.HasEmissiveIntent={flag7}"));
				}
			}
			Dictionary<string, Texture> dictionary = new Dictionary<string, Texture>();
			Dictionary<string, Color> dictionary2 = new Dictionary<string, Color>();
			Dictionary<string, float> dictionary3 = new Dictionary<string, float>();
			bool flag8 = Plugin.HasEmissiveIntent(mat);
			(string, BridgeType, string[])[] bridgeGroups = BridgeGroups;
			for (int i = 0; i < bridgeGroups.Length; i++)
			{
				(string, BridgeType, string[]) tuple = bridgeGroups[i];
				string text4 = FirstProperty(mat, tuple.Item3);
				if (text4 != null)
				{
					switch (tuple.Item2)
					{
					case BridgeType.Texture:
						dictionary[tuple.Item1] = mat.GetTexture(text4);
						break;
					case BridgeType.Color:
						dictionary2[tuple.Item1] = mat.GetColor(text4);
						break;
					case BridgeType.Float:
						dictionary3[tuple.Item1] = mat.GetFloat(text4);
						break;
					}
				}
			}
			Texture value4;
			bool flag9 = dictionary.TryGetValue("metallicMap", out value4) && (Object)(object)value4 != (Object)null;
			bool flag10 = mat.IsKeywordEnabled("_EMISSION");
			int instanceID3 = ((Object)mat).GetInstanceID();
			if (Plugin._originalEmissionByMat.TryGetValue(instanceID3, out (bool, Color, Texture, bool) value5))
			{
				flag8 = value5.Item1;
				flag10 = value5.Item4;
				dictionary2["emissionCol"] = value5.Item2;
				dictionary["emissionMap"] = value5.Item3;
			}
			else
			{
				Color value6;
				Color item = (dictionary2.TryGetValue("emissionCol", out value6) ? value6 : Color.black);
				Texture value7;
				Texture item2 = (dictionary.TryGetValue("emissionMap", out value7) ? value7 : null);
				Plugin._originalEmissionByMat[instanceID3] = (flag8, item, item2, flag10);
			}
			string text5 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
			if ((text5.Equals("DraugrFangGlow", StringComparison.OrdinalIgnoreCase) || text5.Equals("DraugrFangBow", StringComparison.OrdinalIgnoreCase)) && _draugrTraceFiredMatIds.Add(((Object)mat).GetInstanceID()))
			{
				string arg2 = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).name : "<null>");
				int num3 = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).GetInstanceID() : 0);
				string arg3 = (mat.HasProperty("_Color") ? ((object)mat.color/*cast due to .constrained prefix*/).ToString() : "n/a");
				string arg4 = (((Object)(object)target != (Object)null) ? ((Object)target).name : "<null>");
				int num4 = (((Object)(object)target != (Object)null) ? ((Object)target).GetInstanceID() : 0);
				Plugin.Log.LogInfo((object)($"[DraugrTrace] BridgeMaterialProperties WRITE  mat='{text5}'  matId={((Object)mat).GetInstanceID()}" + $"  preShader='{arg2}'(id={num3})  preColor={arg3}" + $"  → target='{arg4}'(id={num4})  (the plugin IS about to mat.shader= this material here)"));
			}
			string text6 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
			if (PreSwapProbeNameMatches(text6) && _preSwapProbeFiredMatIds.Add(((Object)mat).GetInstanceID()))
			{
				string arg5 = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).name : "<null>");
				int num5 = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).GetInstanceID() : 0);
				string text7 = Fmt("_SrcBlend");
				string text8 = Fmt("_DstBlend");
				string text9 = Fmt("_Mode");
				string text10 = FmtColorAlpha("_Color");
				string text11 = FmtColorAlpha("_TintColor");
				string[] shaderKeywords = mat.shaderKeywords;
				string text12 = ((shaderKeywords == null || shaderKeywords.Length == 0) ? "<none>" : string.Join("|", shaderKeywords));
				StringBuilder stringBuilder = new StringBuilder();
				if ((Object)(object)mat.shader != (Object)null)
				{
					int propertyCount = mat.shader.GetPropertyCount();
					for (int j = 0; j < propertyCount; j++)
					{
						if ((int)mat.shader.GetPropertyType(j) == 4)
						{
							string propertyName = mat.shader.GetPropertyName(j);
							Texture texture = mat.GetTexture(propertyName);
							if (stringBuilder.Length > 0)
							{
								stringBuilder.Append(", ");
							}
							stringBuilder.Append(propertyName).Append('=').Append(((Object)(object)texture == (Object)null) ? "<null>" : ("'" + ((Object)texture).name + "'"));
						}
					}
				}
				string text13 = ((stringBuilder.Length > 0) ? stringBuilder.ToString() : "<no-texture-slots>");
				Plugin.Log.LogInfo((object)($"[PreSwapProbe] mat='{text6}'  matId={((Object)mat).GetInstanceID()}" + $"  srcShader='{arg5}'(id={num5})" + "  → target='" + (((Object)(object)target != (Object)null) ? ((Object)target).name : "<null>") + "'"));
				Plugin.Log.LogInfo((object)("[PreSwapProbe]   blend: _SrcBlend=" + text7 + " _DstBlend=" + text8 + " _Mode=" + text9 + "  _Color.a=" + text10 + " _TintColor.a=" + text11));
				Plugin.Log.LogInfo((object)("[PreSwapProbe]   keywords=" + text12));
				Plugin.Log.LogInfo((object)("[PreSwapProbe]   textures: " + text13));
			}
			mat.shader = target;
			(string, BridgeType, string[])[] bridgeGroups2 = BridgeGroups;
			for (int k = 0; k < bridgeGroups2.Length; k++)
			{
				(string, BridgeType, string[]) tuple2 = bridgeGroups2[k];
				string text14 = FirstProperty(mat, tuple2.Item3);
				if (text14 == null)
				{
					continue;
				}
				switch (tuple2.Item2)
				{
				case BridgeType.Texture:
				{
					if (dictionary.TryGetValue(tuple2.Item1, out var value9))
					{
						mat.SetTexture(text14, value9);
					}
					break;
				}
				case BridgeType.Color:
				{
					if (dictionary2.TryGetValue(tuple2.Item1, out var value10))
					{
						mat.SetColor(text14, value10);
					}
					break;
				}
				case BridgeType.Float:
				{
					if (dictionary3.TryGetValue(tuple2.Item1, out var value8))
					{
						mat.SetFloat(text14, value8);
					}
					break;
				}
				}
			}
			if (flag9 && mat.HasProperty("_UseGlossmap"))
			{
				mat.SetFloat("_UseGlossmap", 1f);
			}
			string text15 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
			if (PreSwapProbeNameMatches(text15) && _postSwapProbeFiredMatIds.Add(((Object)mat).GetInstanceID()))
			{
				string arg6 = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).name : "<null>");
				int num6 = (((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).GetInstanceID() : 0);
				StringBuilder stringBuilder2 = new StringBuilder();
				if ((Object)(object)mat.shader != (Object)null)
				{
					int propertyCount2 = mat.shader.GetPropertyCount();
					for (int l = 0; l < propertyCount2; l++)
					{
						if ((int)mat.shader.GetPropertyType(l) == 4)
						{
							string propertyName2 = mat.shader.GetPropertyName(l);
							Texture texture2 = mat.GetTexture(propertyName2);
							if (stringBuilder2.Length > 0)
							{
								stringBuilder2.Append(", ");
							}
							stringBuilder2.Append(propertyName2).Append('=').Append(((Object)(object)texture2 == (Object)null) ? "<null>" : ("'" + ((Object)texture2).name + "'"));
						}
					}
				}
				string text16 = ((stringBuilder2.Length > 0) ? stringBuilder2.ToString() : "<no-texture-slots>");
				Plugin.Log.LogInfo((object)($"[PostSwapProbe] mat='{text15}'  matId={((Object)mat).GetInstanceID()}" + $"  targetShader='{arg6}'(id={num6})  (after restore loop)"));
				Plugin.Log.LogInfo((object)("[PostSwapProbe]   textures: " + text16));
			}
			float value11;
			bool flag11 = dictionary3.TryGetValue("metallic", out value11) && value11 >= 0.5f;
			if (flag11 && flag9)
			{
				string text17 = FirstProperty(mat, new string[3] { "_MetalGloss", "_Glossiness", "_Smoothness" });
				bool flag12 = mat.HasProperty("_MetalGloss");
				bool flag13 = mat.HasProperty("_Glossiness");
				float num7 = (flag12 ? mat.GetFloat("_MetalGloss") : (-1f));
				float num8 = (flag13 ? mat.GetFloat("_Glossiness") : (-1f));
				Plugin.Log.LogDebug((object)("[MetalPolishProbe-A] mat='" + ((Object)mat).name + "'  frame=A-in-bridge" + string.Format("  shader='{0}'  shaderId={1}", ((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).name : "<null>", ((Object)(object)mat.shader != (Object)null) ? ((Object)mat.shader).GetInstanceID() : 0) + string.Format("  metallic={0:F2}  firstSmoothnessProp='{1}'", value11, text17 ?? "<none>") + $"  HasProperty(_MetalGloss)={flag12} (_MetalGloss={num7:F3})" + $"  HasProperty(_Glossiness)={flag13} (_Glossiness={num8:F3})"));
			}
			if (!flag10 && !flag8 && mat.HasProperty("_EmissionColor"))
			{
				mat.SetColor("_EmissionColor", Color.black);
			}
			else if (flag8)
			{
				mat.EnableKeyword("_EMISSION");
			}
			if (mat.HasProperty("_EmissionColor"))
			{
				Color color2 = mat.GetColor("_EmissionColor");
				if (MaterialClassifier.IsMagenta(color2) && ((Color)(ref color2)).maxColorComponent <= 1f)
				{
					mat.SetColor("_EmissionColor", Color.black);
					mat.DisableKeyword("_EMISSION");
				}
			}
			string Fmt(string prop)
			{
				return mat.HasProperty(prop) ? mat.GetFloat(prop).ToString("0.###") : "<absent>";
			}
			string FmtColorAlpha(string prop)
			{
				//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)
				return mat.HasProperty(prop) ? mat.GetColor(prop).a.ToString("0.###") : "<absent>";
			}
		}
	}
	internal static class ReplacementCore
	{
		internal static readonly HashSet<int> _vanillaRebindMatIds = new HashSet<int>();

		internal static readonly HashSet<int> _processedMaterialIds = new HashSet<int>();

		internal static readonly Dictionary<int, int> _cachedShaderIdByMat = new Dictionary<int, int>();

		internal static readonly Dictionary<int, int> _cacheEpochByMat = new Dictionary<int, int>();

		internal static readonly Dictionary<int, (string originalShader, ShaderAction action)> _replacedMats = new Dictionary<int, (string, ShaderAction)>();

		internal static int _admissionEpoch;

		private static readonly HashSet<int> _useShaderTracedMatIds = new HashSet<int>();

		private static readonly HashSet<string> _useShaderUnresolvedWarnedNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<int> _draugrTraceFiredMatIds = new HashSet<int>();

		private static readonly HashSet<int> _redirectProbeFiredMatIds = new HashSet<int>();

		private static readonly HashSet<string> _additiveOrAlphaBlendedParticleNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Legacy Shaders/Particles/Additive", "Legacy Shaders/Particles/Additive (Soft)", "Legacy Shaders/Particles/Alpha Blended", "Particles/Standard Unlit", "Particles/Standard Surface" };

		internal static void CollectCanonicalShaderIds()
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			string[] valheimShaderNames = Plugin.ValheimShaderNames;
			foreach (string text in valheimShaderNames)
			{
				Shader val = Shader.Find(text);
				if (!((Object)(object)val == (Object)null))
				{
					if (!val.isSupported)
					{
						num3++;
					}
					else if (Plugin.CanonicalShaderIds.Add(((Object)val).GetInstanceID()))
					{
						num++;
					}
				}
			}
			string[] unityBuiltInShaderNames = Plugin.UnityBuiltInShaderNames;
			foreach (string text2 in unityBuiltInShaderNames)
			{
				Shader val2 = Shader.Find(text2);
				if (!((Object)(object)val2 == (Object)null))
				{
					if (!val2.isSupported)
					{
						num3++;
					}
					else if (Plugin.CanonicalShaderIds.Add(((Object)val2).GetInstanceID()))
					{
						num2++;
					}
				}
			}
			Plugin.Log.LogDebug((object)$"Registered {Plugin.CanonicalShaderIds.Count} canonical shader ID(s) ({num} Valheim, {num2} Unity built-in; rejected {num3} unsupported).");
		}

		internal static void BuildTransparentMaterial()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Plugin._transparentMat != (Object)null)
			{
				return;
			}
			Shader val = null;
			string text = "";
			string[] transparentChain = Plugin.TransparentChain;
			foreach (string text2 in transparentChain)
			{
				if (Plugin.IsParticleCapableShaderName(text2))
				{
					Shader val2 = Shader.Find(text2);
					if (!((Object)(object)val2 == (Object)null) && val2.isSupported)
					{
						val = val2;
						text = text2;
						break;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				Plugin._transparentMat = new Material(val)
				{
					name = "ShaderFix_Transparent"
				};
				Plugin._transparentMat.color = new Color(0f, 0f, 0f, 0f);
				Plugin._transparentShaderIsParticleCapable = true;
				Plugin.Log.LogDebug((object)("Transparent material ready (shader='" + text + "', particleCapable=True, color=(0,0,0,0) for true invisibility on swap)."));
				return;
			}
			Shader val3 = Shader.Find("Standard");
			if ((Object)(object)val3 != (Object)null)
			{
				Plugin._transparentMat = new Material(val3)
				{
					name = "ShaderFix_Transparent"
				};
				Plugin._transparentMat.SetFloat("_Mode", 3f);
				Plugin._transparentMat.SetInt("_SrcBlend", 5);
				Plugin._transparentMat.SetInt("_DstBlend", 10);
				Plugin._transparentMat.SetInt("_ZWrite", 0);
				Plugin._transparentMat.EnableKeyword("_ALPHABLEND_ON");
				Plugin._transparentMat.renderQueue = 3000;
				Plugin._transparentMat.color = new Color(0f, 0f, 0f, 0f);
				Plugin._transparentShaderIsParticleCapable = false;
				Plugin.Log.LogWarning((object)$"Transparent material ready (Standard-Transparent placeholder, alpha=0 true-invisibility — Standard.isSupported={val3.isSupported}; will upgrade to a real particle shader if one becomes available after ZNetScene.Awake).");
				return;
			}
			string[] transparentChain2 = Plugin.TransparentChain;
			foreach (string text3 in transparentChain2)
			{
				if (!Plugin.IsParticleCapableShaderName(text3))
				{
					Shader val4 = Shader.Find(text3);
					if (!((Object)(object)val4 == (Object)null) && val4.isSupported)
					{
						Plugin._transparentMat = new Material(val4)
						{
							name = "ShaderFix_Transparent"
						};
						Plugin._transparentMat.color = new Color(0f, 0f, 0f, 0f);
						Plugin._transparentShaderIsParticleCapable = false;
						Plugin.Log.LogWarning((object)("Transparent material ready (last-resort shader='" + text3 + "' — Standard unavailable; replacements may look desaturated until Valheim bundles load and TryUpgradeTransparentShader runs)."));
						return;
					}
				}
			}
			Plugin.Log.LogWarning((object)"No transparent shader found — shader replacement will not work.");
		}

		internal static void TryUpgradeTransparentShader()
		{
			if ((Object)(object)Plugin._transparentMat == (Object)null)
			{
				return;
			}
			Shader[] source = Resources.FindObjectsOfTypeAll<Shader>();
			string[] transparentChain = Plugin.TransparentChain;
			foreach (string name in transparentChain)
			{
				Shader val = ((IEnumerable<Shader>)source).FirstOrDefault((Func<Shader, bool>)((Shader sh) => ((Object)sh).name == name && sh.isSupported));
				if ((Object)(object)val == (Object)null)
				{
					val = Shader.Find(name);
				}
				if ((Object)(object)val == (Object)null || !val.isSupported)
				{
					continue;
				}
				int instanceID = ((Object)Plugin._transparentMat.shader).GetInstanceID();
				if (((Object)val).GetInstanceID() != instanceID)
				{
					Plugin.Log.LogDebug((object)$"[ZNetScene.Awake] Upgraded transparent shader: '{((Object)Plugin._transparentMat.shader).name}' (id={instanceID}) → '{((Object)val).name}' (id={((Object)val).GetInstanceID()})");
					Plugin._transparentMat.shader = val;
					bool transparentShaderIsParticleCapable = Plugin.IsParticleCapableShaderName(name);
					Plugin._transparentShaderIsParticleCapable = transparentShaderIsParticleCapable;
					if (Plugin.CanonicalShaderIds.Remove(instanceID))
					{
						Plugin.Log.LogDebug((object)$"[ZNetScene.Awake] Purged stale canonical shader ID: id={instanceID} (was transparent placeholder; replaced by id={((Object)val).GetInstanceID()})");
					}
					Plugin.CanonicalShaderIds.Add(((Object)val).GetInstanceID());
					BumpAdmissionEpoch("TryUpgradeTransparentShader");
				}
				break;
			}
		}

		internal static void BuildReplacementMaterials()
		{
			//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_0032: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			BuildTransparentMaterial();
			if ((Object)(object)Plugin.FallbackShader != (Object)null)
			{
				Plugin._fallbackMat = new Material(Plugin.FallbackShader)
				{
					name = "ShaderFix_Fallback"
				};
				Plugin._fallbackMat.color = Color.white;
				Plugin.Log.LogDebug((object)("Fallback material ready (shader='" + ((Object)Plugin.FallbackShader).name + "')."));
			}
		}

		internal static void TryUpgradeFallbackShader()
		{
			if ((Object)(object)Plugin.FallbackShader == (Object)null)
			{
				return;
			}
			Shader[] source = Resources.FindObjectsOfTypeAll<Shader>();
			string[] fallbackChain = Plugin.FallbackChain;
			foreach (string name in fallbackChain)
			{
				Shader val = ((IEnumerable<Shader>)source).FirstOrDefault((Func<Shader, bool>)((Shader sh) => ((Object)sh).name == name && sh.isSupported));
				if ((Object)(object)val == (Object)null)
				{
					val = Shader.Find(name);
				}
				if ((Object)(object)val == (Object)null || !val.isSupported)
				{
					continue;
				}
				int instanceID = ((Object)Plugin.FallbackShader).GetInstanceID();
				if (((Object)val).GetInstanceID() != instanceID)
				{
					Plugin.Log.LogDebug((object)$"[ZNetScene.Awake] Upgraded fallback shader: '{((Object)Plugin.FallbackShader).name}' (id={instanceID}) → '{((Object)val).name}' (id={((Object)val).GetInstanceID()})");
					Plugin.FallbackShader = val;
					if ((Object)(object)Plugin._fallbackMat != (Object)null)
					{
						Plugin._fallbackMat.shader = val;
					}
					if (Plugin.CanonicalShaderIds.Remove(instanceID))
					{
						Plugin.Log.LogDebug((object)$"[ZNetScene.Awake] Purged stale canonical shader ID: id={instanceID} (was unsupported '{name}'; replaced by id={((Object)val).GetInstanceID()})");
					}
					Plugin.CanonicalShaderIds.Add(((Object)val).GetInstanceID());
					BumpAdmissionEpoch("TryUpgradeFallbackShader");
				}
				break;
			}
		}

		internal static int TryReplaceMaterial(Material? mat)
		{
			//IL_0ff8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ffd: Unknown result type (might be due to invalid IL or missing references)
			//IL_1270: Unknown result type (might be due to invalid IL or missing references)
			//IL_1218: Unknown result type (might be due to invalid IL or missing references)
			//IL_121d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1220: Unknown result type (might be due to invalid IL or missing references)
			//IL_1227: Unknown result type (might be due to invalid IL or missing references)
			//IL_122e: Unknown result type (might be due to invalid IL or missing references)
			//IL_123a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null || (Object)(object)mat.shader == (Object)null)
			{
				return 0;
			}
			if ((Object)(object)mat == (Object)(object)Plugin._transparentMat || (Object)(object)mat == (Object)(object)Plugin._fallbackMat)
			{
				return 0;
			}
			if (Plugin._sweepDisabled)
			{
				return 0;
			}
			if (Plugin.IsJVLMockShader(((Object)mat.shader).name))
			{
				return 0;
			}
			string text = Plugin.StripInstance(((Object)mat).name);
			bool flag = Plugin._baselineMatNames.Contains(text);
			bool flag2 = Plugin._vanillaShaderNames.Contains(((Object)mat.shader).name) || Plugin.ValheimShaderNameSet.Contains(((Object)mat.shader).name) || Plugin.UnityBuiltInShaderNameSet.Contains(((Object)mat.shader).name);
			bool flag3 = Plugin.CanonicalShaderIds.Contains(((Object)mat.shader).GetInstanceID());
			int instanceID = ((Object)mat).GetInstanceID();
			if (Plugin.VanillaRebindEnabled && flag2 && !flag3 && Plugin._particleRendererMatIdHints.Contains(instanceID) && !_vanillaRebindMatIds.Contains(instanceID))
			{
				Shader val = Plugin.FindShaderByNameInternal(((Object)mat.shader).name);
				if ((Object)(object)val != (Object)null && ((Object)val).GetInstanceID() != ((Object)mat.shader).GetInstanceID())
				{
					Plugin.Log.LogDebug((object)($"[VanillaRebind] '{((Object)mat.shader).name}' (id={((Object)mat.shader).GetInstanceID()})" + $" → canonical id={((Object)val).GetInstanceID()} on mat '{((Object)mat).name}'"));
					string text2 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
					if ((text2.Equals("DraugrFangGlow", StringComparison.OrdinalIgnoreCase) || text2.Equals("DraugrFangBow", StringComparison.OrdinalIgnoreCase)) && _draugrTraceFiredMatIds.Add(((Object)mat).GetInstanceID()))
					{
						Plugin.Log.LogInfo((object)($"[DraugrTrace] VanillaRebind WRITE  mat='{text2}'  matId={((Object)mat).GetInstanceID()}" + $"  preShader='{((Object)mat.shader).name}'(id={((Object)mat.shader).GetInstanceID()})" + $"  → canonical(id={((Object)val).GetInstanceID()})  (the plugin IS about to mat.shader= this material here)"));
					}
					mat.shader = val;
					_vanillaRebindMatIds.Add(instanceID);
					flag3 = true;
				}
			}
			bool flag4 = flag2 || flag3;
			bool flag5 = Plugin._prefabScopedModMatIds.Contains(((Object)mat).GetInstanceID());
			if (flag && flag4 && !flag5)
			{
				return 0;
			}
			bool flag6 = Plugin.IsHardMatRule(mat);
			bool flag7 = flag6 || PatchBatch.IsSoftMatRule(mat);
			bool flag8 = Plugin.IsForceTransparent(((Object)mat.shader).name) || Plugin.IsForceFallback(((Object)mat.shader).name);
			int instanceID2 = ((Object)mat).GetInstanceID();
			if (!flag6 && _processedMaterialIds.Contains(instanceID2) && _cachedShaderIdByMat.TryGetValue(instanceID2, out var value) && value == ((Object)mat.shader).GetInstanceID() && _cacheEpochByMat.TryGetValue(instanceID2, out var value2) && value2 == _admissionEpoch)
			{
				HashSet<string> bridgeTraceMatNames = Plugin.BridgeTraceMatNames;
				if (bridgeTraceMatNames.Count > 0)
				{
					string text3 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
					if (bridgeTraceMatNames.Contains(text3))
					{
						(string, ShaderAction) value3;
						bool flag9 = _replacedMats.TryGetValue(instanceID2, out value3);
						Plugin.Log.LogDebug((object)($"[BridgeSkipCacheHit] mat='{text3}'  matId={instanceID2}" + $"  cachedShaderId={value}  currentShaderId={((Object)mat.shader).GetInstanceID()}" + "  shaderName='" + ((Object)mat.shader).name + "'" + $"  cachedEpoch={value2}  currentEpoch={_admissionEpoch}" + $"  inReplacedMats={flag9}" + "  prevReplacement='" + (flag9 ? $"{value3.Item1} → {value3.Item2}" : "<absent>") + "'"));
					}
				}
				return 0;
			}
			if (!flag6 && _processedMaterialIds.Contains(instanceID2) && _cachedShaderIdByMat.TryGetValue(instanceID2, out var value4) && value4 != ((Object)mat.shader).GetInstanceID() && _replacedMats.TryGetValue(instanceID2, out (string, ShaderAction) value5))
			{
				string text4 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
				if (Plugin.BridgeTraceMatNames.Contains(text4))
				{
					Plugin.Log.LogDebug((object)($"[BridgeSkip-Candidate] mat='{text4}'  matId={instanceID2}" + $"  cachedShaderId={value4}" + $"  currentShaderId={((Object)mat.shader).GetInstanceID()}" + "  shaderName='" + ((Object)mat.shader).name + "'" + $"  prevReplacement='{value5.Item1} → {value5.Item2}'"));
				}
			}
			if (Plugin._forceReplacedMaterialIds.Contains(instanceID2) && !flag7)
			{
				return 0;
			}
			if (Plugin.CanonicalShaderIds.Contains(((Object)mat.shader).GetInstanceID()) && !flag6 && !Plugin.IsAggressivelySwappable(((Object)mat.shader).name) && !flag8)
			{
				_processedMaterialIds.Add(instanceID2);
				_cachedShaderIdByMat[instanceID2] = ((Object)mat.shader).GetInstanceID();
				_cacheEpochByMat[instanceID2] = _admissionEpoch;
				return 0;
			}
			if (Plugin.HunFXAutoDefault && !flag6 && ((Object)mat.shader).name.StartsWith("HunFX/", StringComparison.OrdinalIgnoreCase))
			{
				Shader val2 = Plugin.FindShaderByNameInternal("Legacy Shaders/Particles/Additive");
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Log.LogDebug((object)("[HunFXAutoDefault] target shader 'Legacy Shaders/Particles/Additive' not yet available for mat '" + ((Object)mat).name + "' (shader '" + ((Object)mat.shader).name + "') — keeping original; will retry next sweep."));
					return 0;
				}
				if (((Object)val2).GetInstanceID() != ((Object)mat.shader).GetInstanceID())
				{
					Plugin.Log.LogDebug((object)("[HunFXAutoDefault] '" + ((Object)mat.shader).name + "' → 'Legacy Shaders/Particles/Additive' on mat '" + ((Object)mat).name + "'"));
					_replacedMats[((Object)mat).GetInstanceID()] = (((Object)mat.shader).name, ShaderAction.UseShader);
					MaterialBridge.BridgeMaterialProperties(mat, val2);
				}
				_processedMaterialIds.Add(instanceID2);
				_cachedShaderIdByMat[instanceID2] = ((Object)mat.shader).GetInstanceID();
				_cacheEpochByMat[instanceID2] = _admissionEpoch;
				SweepCoordinator._currentSweepReplacedMatIds?.Add(instanceID2);
				return 1;
			}
			if (Plugin._matShaderOverrides.TryGetValue(text, out string value6))
			{
				int instanceID3 = ((Object)mat).GetInstanceID();
				bool flag10 = !_useShaderTracedMatIds.Contains(instanceID3);
				List<(string, string)> value7;
				int num = (Plugin._matShaderPropertyOverrides.TryGetValue(text, out value7) ? (value7?.Count ?? 0) : 0);
				if (flag10)
				{
					Plugin.Log.LogDebug((object)$"[UseShader] mat:{((Object)mat).name} → {value6}  propertyOverrideCount={num}  (gate signals: shaderVanillaByName={flag2}, shaderCanonicalById={flag3}, prefabScopeOverride={flag5})");
				}
				Shader val3 = Plugin.FindShaderByNameInternal(value6);
				if ((Object)(object)val3 == (Object)null)
				{
					Plugin.Log.LogDebug((object)("[UseShader] shader '" + value6 + "' not yet available for mat '" + ((Object)mat).name + "' — keeping original shader '" + ((Object)mat.shader).name + "'; will retry next sweep."));
					if (Plugin._zNetSceneAwakeFired && _useShaderUnresolvedWarnedNames.Add(value6))
					{
						Plugin.Log.LogWarning((object)("[UseShader] target shader '" + value6 + "' does not exist on this install (Shader.Find + Resources lookup both returned no supported instance, even after ZNetScene.Awake loaded Valheim's bundle shaders). The rule '[useshader] mat:" + text + " " + value6 + "' is INERT — the material keeps its original shader '" + ((Object)mat.shader).name + "'. Common cause: a near-miss shader name — e.g. 'Particles/Standard' does not exist; did you mean 'Particles/Standard Unlit'? Check the exact name with `shaderhelper resolveshader <name>`. This warning fires once per unresolved target per session."));
					}
					return 0;
				}
				_useShaderTracedMatIds.Add(instanceID3);
				if (((Object)val3).GetInstanceID() != ((Object)mat.shader).GetInstanceID())
				{
					Plugin.Log.LogDebug((object)("[UseShader] '" + ((Object)mat.shader).name + "' → '" + value6 + "' on mat '" + ((Object)mat).name + "'"));
					MatDump.DumpMatPropertiesIfTargeted(mat, "pre-swap");
					_replacedMats[((Object)mat).GetInstanceID()] = (((Object)mat.shader).name, ShaderAction.UseShader);
					MaterialBridge.BridgeMaterialProperties(mat, val3);
					ApplyUseShaderPropertyOverrides(mat, text, flag10);
					ApplyUseShaderKeywordOverrides(mat, text, flag10);
					MatDump.DumpMatPropertiesIfTargeted(mat, "post-swap");
					_processedMaterialIds.Add(instanceID2);
					_cachedShaderIdByMat[instanceID2] = ((Object)mat.shader).GetInstanceID();
					_cacheEpochByMat[instanceID2] = _admissionEpoch;
					SweepCoordinator._currentSweepReplacedMatIds?.Add(instanceID2);
					return 1;
				}
				ApplyUseShaderPropertyOverrides(mat, text, flag10);
				ApplyUseShaderKeywordOverrides(mat, text, flag10);
				if (flag10)
				{
					Plugin.Log.LogDebug((object)$"[UseShader] mat:{((Object)mat).name} already at target shader '{value6}'  propertyOverrideCount={num}  (already-at-target branch — property overrides applied via ApplyUseShaderPropertyOverrides; v3.0.44 hoist)");
				}
				_processedMaterialIds.Add(instanceID2);
				_cachedShaderIdByMat[instanceID2] = ((Object)mat.shader).GetInstanceID();
				_cacheEpochByMat[instanceID2] = _admissionEpoch;
				return 0;
			}
			if (Plugin.PreserveAdditiveParticles && !flag6 && IsAdditiveOrAlphaBlendedParticleName(((Object)mat.shader).name))
			{
				Plugin.Log.LogDebug((object)("[PreserveAdditive] keeping mat '" + ((Object)mat).name + "' on its own particle shader " + $"'{((Object)mat.shader).name}' (id={((Object)mat.shader).GetInstanceID()}) — declined aggressive-family " + "Fallback to Custom/Creature so _TintColor/_InvFade survive."));
				_replacedMats[((Object)mat).GetInstanceID()] = (((Object)mat.shader).name, ShaderAction.Original);
				_processedMaterialIds.Add(instanceID2);
				_cachedShaderIdByMat[instanceID2] = ((Object)mat.shader).GetInstanceID();
				_cacheEpochByMat[instanceID2] = _admissionEpoch;
				return 0;
			}
			ShaderAction shaderAction = ((Plugin.IsAggressivelySwappable(((Object)mat.shader).name) && !flag6) ? ShaderAction.Fallback : Plugin.GetAction(mat));
			if (shaderAction == ShaderAction.Original)
			{
				bool flag11 = Plugin._particleRendererMatIdHints.Contains(((Object)mat).GetInstanceID());
				shaderAction = ((!Plugin.IsErrorPink(mat) && !Plugin.IsParticleLikeShaderName(((Object)mat.shader).name) && !(Plugin.IsHdrEmission(mat) && flag11)) ? ShaderAction.Fallback : ShaderAction.Transparent);
			}
			if (((Object)mat.shader).name.StartsWith("TextMeshPro/", StringComparison.OrdinalIgnoreCase) && ((Object)mat.shader).name.EndsWith(" (Surface)", StringComparison.OrdinalIgnoreCase))
			{
				string text5 = ((Object)mat.shader).name.Substring(0, ((Object)mat.shader).name.Length - " (Surface)".Length);
				Shader val4 = Shader.Find(text5);
				if ((Object)(object)val4 != (Object)null && ((Object)val4).GetInstanceID() != ((Object)mat.shader).GetInstanceID())
				{
					Plugin.Log.LogDebug((object)("[TMP] '" + ((Object)mat.shader).name + "' → '" + text5 + "' on mat '" + ((Object)mat).name + "'"));
					_replacedMats[((Object)mat).GetInstanceID()] = (((Object)mat.shader).name, shaderAction);
					mat.shader = val4;
					return 1;
				}
			}
			bool flag12 = Plugin._particleRendererMatIdHints.Contains(((Object)mat).GetInstanceID());
			Material val5 = ((shaderAction == ShaderAction.Fallback) ? Plugin._fallbackMat : Plugin._transparentMat);
			if ((Object)(object)val5 == (Object)null)
			{
				return 0;
			}
			bool flag13 = shaderAction == ShaderAction.Transparent && flag6 && (Object)(object)Plugin._fallbackMat != (Object)null;
			if (flag13)
			{
				string text6 = Plugin.StripInstance(((Object)mat).name ?? string.Empty);
				if (text6.Equals("TrailThickRed", StringComparison.OrdinalIgnoreCase) && _redirectProbeFiredMatIds.Add(((Object)mat).GetInstanceID()))
				{
					bool flag14 = Plugin._matShaderOverrides.ContainsKey(text6);
					Plugin.Log.LogInfo((object)($"[RedirectProbe] mat='{text6}'  matId={((Object)mat).GetInstanceID()}" + $"  shader='{((Object)mat.shader).name}'(id={((Object)mat.shader).GetInstanceID()})" + $"  action={shaderAction}  hasHardRule={flag6}" + $"  _matShaderOverrides.ContainsKey('{text6}')={flag14}" + $"  overrideMapCount={Plugin._matShaderOverrides.Count}" + $"  admissionEpoch={_admissionEpoch}" + "  (about to redirect Transparent→MeshPath to _fallbackMat=Custom/Creature)"));
				}
				val5 = Plugin._fallbackMat;
			}
			Shader val6 = null;
			bool flag15 = false;
			if ((shaderAction == ShaderAction.Fallback || flag13) && Plugin.HasEmissiveIntent(mat))
			{
				val6 = Plugin.GetEmissiveFallbackShaderInternal();
				if ((Object)(object)val6 != (Object)null && ((Object)(object)Plugin.FallbackShader == (Object)null || ((Object)val6).GetInstanceID() != ((Object)Plugin.FallbackShader).GetInstanceID()))
				{
					flag15 = true;
				}
			}
			Shader val7 = (flag15 ? val6 : val5.shader);
			if (((Object)mat.shader).GetInstanceID() == ((Object)val7).GetInstanceID() && !flag13)
			{
				_processedMaterialIds.Add(instanceID2);
				_cachedShaderIdByMat[instanceID2] = ((Object)mat.shader).GetInstanceID();
				_cacheEpochByMat[instanceID2] = _admissionEpoch;
				return 0;
			}
			string text7 = (mat.HasProperty("_Color") ? ((object)mat.color/*cast due to .constrained prefix*/).ToString() : "n/a");
			string text8 = (flag15 ? "Fallback/Emissive" : (flag13 ? "Transparent→MeshPath" : shaderAction.ToString()));
			Plugin.Log.LogDebug((object)("[" + text8 + "] '" + ((Object)mat.shader).name + "' → '" + ((Object)val7).name + "' on mat '" + ((Object)mat).name + "'  color=" + text7 + "."));
			_replacedMats[((Object)mat).GetInstanceID()] = (((Object)mat.shader).name, shaderAction);
			if (shaderAction == ShaderAction.Fallback || flag13)
			{
				MaterialBridge.BridgeMaterialProperties(mat, val7);
				if (Plugin.AutoPolishMetallic && (shaderAction == ShaderAction.Fallback || flag13) && mat.HasProperty("_Metallic") && mat.GetFloat("_Metallic") >= 0.5f && (mat.HasProperty("_MetallicGlossMap") || mat.HasProperty("_MetallicMap")))
				{
					mat.SetFloat("_UseGlossmap", 1f);
					mat.SetFloat("_MetalGloss", 0.7f);
					mat.SetFloat("_Glossiness", 0.9f);
					mat.SetFloat("_Smoothness", 0.9f);
					Plugin.Log.LogDebug((object)("[AutoPolishMetallic] polished mat='" + ((Object)mat).name + "'  frame=B-post-bridge" + $"  shader='{((Object)mat.shader).name}'  shaderId={((Object)mat.shader).GetInstanceID()}" + string.Format("  metallic={0:F2}", mat.GetFloat("_Metallic")) + "  → _UseGlossmap=1 _MetalGloss=0.7 _Glossiness=0.9 _Smoothness=0.9"));
				}
				if (flag13 && mat.HasProperty("_Color"))
				{
					Color color = mat.color;
					mat.color = new Color(color.r, color.g, color.b, 0f);
				}
			}
			else
			{
				mat.shader = val5.shader;
				if (val5.HasProperty("_Color"))
				{
					mat.color = val5.color;
				}
				if (mat.HasProperty("_Mode"))
				{
					mat.SetFloat("_Mode", 3f);
				}
				if (mat.HasProperty("_SrcBlend"))
				{
					mat.SetInt("_SrcBlend", 5);
				}
				if (mat.HasProperty("_DstBlend"))
				{
					mat.SetInt("_DstBlend", 10);
				}
				if (mat.HasProperty("_ZWrite"))
				{
					mat.SetInt("_ZWrite", 0);
				}
				mat.EnableKeyword("_ALPHABLEND_ON");
				mat.DisableKeyword("_ALPHATEST_ON");
				mat.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				mat.renderQueue = 3000;
			}
			if (shaderAction == ShaderAction.Transparent)
			{
				Plugin._forceReplacedMaterialIds.Add(((Object)mat).GetInstanceID());
			}
			_processedMaterialIds.Add(instanceID2);
			_cachedShaderIdByMat[instanceID2] = ((Object)mat.shader).GetInstanceID();
			_cacheEpochByMat[instanceID2] = _admissionEpoch;
			SweepCoordinator._currentSweepReplacedMatIds?.Add(instanceID2);
			return 1;
		}

		internal static void BumpAdmissionEpoch(string source)
		{
			_admissionEpoch++;
			if (Plugin.BridgeTraceMatNames.Count > 0)
			{
				Plugin.Log.LogDebug((object)$"[BumpAdmissionEpoch] from='{source}'  newEpoch={_admissionEpoch}");
			}
		}

		private static void ApplyUseShaderPropertyOverrides(Material mat, string baseCheck, bool useShaderTraceFirstHit)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin._matShaderPropertyOverrides.TryGetValue(baseCheck, out List<(string, string)> value) || value == null)
			{
				return;
			}
			foreach (var (text, text2) in value)
			{
				if (TryParseColor(text2, out var c))
				{
					mat.SetColor(text, c);
					if (useShaderTraceFirstHit)
					{
						Plugin.Log.LogDebug((object)$"[UseShader] mat '{((Object)mat).name}': set color property '{text}' = {c}");
					}
					continue;
				}
				if (TryParseFloat(text2, out var f))
				{
					mat.SetFloat(text, f);
					if (useShaderTraceFirstHit)
					{
						Plugin.Log.LogDebug((object)$"[UseShader] mat '{((Object)mat).name}': set float property '{text}' = {f}");
					}
					continue;
				}
				Plugin.Log.LogWarning((object)("[UseShader] Property override '" + text + "=" + text2 + "' on mat '" + ((Object)mat).name + "' did not parse as Color (#RRGGBB or #RRGGBBAA) or Float — skipped."));
			}
		}

		private static void ApplyUseShaderKeywordOverrides(Material mat, string baseCheck, bool useShaderTraceFirstHit)
		{
			if (useShaderTraceFirstHit)
			{
				bool flag = Plugin._matShaderKeywordOverrides.ContainsKey(baseCheck);
				List<(string, bool)> value;
				int num = ((flag && Plugin._matShaderKeywordOverrides.TryGetValue(baseCheck, out value) && value != null) ? value.Count : 0);
				Plugin.Log.LogDebug((object)$"[UseShader] ApplyKeywords mat='{baseCheck}' mapHas={flag} listCount={num} mapTotalCount={Plugin._matShaderKeywordOverrides.Count}");
			}
			if (!Plugin._matShaderKeywordOverrides.TryGetValue(baseCheck, out List<(string, bool)> value2) || value2 == null)
			{
				return;
			}
			foreach (var item in value2)
			{
				var (text, _) = item;
				if (item.Item2)
				{
					mat.EnableKeyword(text);
					if (useShaderTraceFirstHit)
					{
						Plugin.Log.LogDebug((object)("[UseShader] mat '" + ((Object)mat).name + "': enabled keyword '" + text + "'"));
					}
				}
				else
				{
					mat.DisableKeyword(text);
					if (useShaderTraceFirstHit)
					{
						Plugin.Log.LogDebug((object)("[UseShader] mat '" + ((Object)mat).name + "': disabled keyword '" + text + "'"));
					}
				}
			}
		}

		private static bool TryParseColor(string s, out Color c)
		{
			//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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			c = Color.black;
			if (string.IsNullOrEmpty(s) || s[0] != '#')
			{
				return false;
			}
			if (s.Length != 7 && s.Length != 9)
			{
				return false;
			}
			try
			{
				int num = Convert.ToInt32(s.Substring(1, 2), 16);
				int num2 = Convert.ToInt32(s.Substring(3, 2), 16);
				int num3 = Convert.ToInt32(s.Substring(5, 2), 16);
				int num4 = ((s.Length == 9) ? Convert.ToInt32(s.Substring(7, 2), 16) : 255);
				c = new Color((float)num / 255f, (float)num2 / 255f, (float)num3 / 255f, (float)num4 / 255f);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryParseFloat(string s, out float f)
		{
			return float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out f);
		}

		private static bool IsAdditiveOrAlphaBlendedParticleName(string shaderName)
		{
			return _additiveOrAlphaBlendedParticleNames.Contains(shaderName);
		}
	}
}
namespace ShaderHelperForMac.Provenance
{
	internal static class BundleAttribution
	{
		private static readonly HashSet<string> _materialLoadProbeFiredKeys = new HashSet<string>(StringComparer.Ordinal);

		private static readonly HashSet<string> _gameObjectMaterialProbeFiredKeys = new HashSet<string>(StringComparer.Ordinal);

		private static HashSet<string>? _pluginDllBasenamesCache;

		private static HashSet<string>? _bepInExFolderBasenamesCache;

		internal static string? IdentifyCallingPluginDll()
		{
			try
			{
				StackTrace stackTrace = new StackTrace(2, fNeedFileInfo: false);
				string value = Paths.PluginPath.Replace('\\', '/').TrimEnd(new char[1] { '/' });
				for (int i = 0; i < stackTrace.FrameCount; i++)
				{
					Assembly assembly = (stackTrace.GetFrame(i)?.GetMethod())?.DeclaringType?.Assembly;
					if (assembly == null)
					{
						continue;
					}
					string text;
					try
					{
						text = assembly.Location ?? string.Empty;
					}
					catch
					{
						continue;
					}
					if (string.IsNullOrEmpty(text))
					{
						continue;
					}
					string text2 = text.Replace('\\', '/');
					if (text2.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text2);
						if (!string.Equals(fileNameWithoutExtension, "ShaderHelperForMac", StringComparison.OrdinalIgnoreCase))
						{
							return fileNameWithoutExtension;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[Provenance] IdentifyCallingPluginDll failed: " + ex.Message));
			}
			return null;
		}

		internal static void RecordBundleOwner(AssetBundle bundle, string? dll)
		{
			if (!((Object)(object)bundle == (Object)null) && dll != null && (!Plugin._bundleToDll.TryGetValue(((Object)bundle).name, out string value) || !string.Equals(value, dll, StringComparison.OrdinalIgnoreCase)))
			{
				Plugin._bundleToDll[((Object)bundle).name] = dll;
				Plugin.Log.LogDebug((object)("[Provenance] Bundle '" + ((Object)bundle).name + "' attributed to DLL '" + dll + "'"));
			}
		}

		internal static HashSet<string> GetPluginDllBasenames()
		{
			if (_pluginDllBasenamesCache != null)
			{
				return _pluginDllBasenamesCache;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			try
			{
				foreach (string item in Directory.EnumerateFiles(Paths.PluginPath, "*.dll", SearchOption.AllDirectories))
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
					if (!string.IsNullOrEmpty(fileNameWithoutExtension) && !string.Equals(fileNameWithoutExtension, "ShaderHelperForMac", StringComparison.OrdinalIgnoreCase))
					{
						hashSet.Add(fileNameWithoutExtension);
						hashSet.Add(fileNameWithoutExtension.Replace(' ', '_'));
						hashSet.Add(fileNameWithoutExtension.Replace('_', ' '));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[Provenance] Plugin DLL enumeration failed: " + ex.Message));
			}
			_pluginDllBasenamesCache = hashSet;
			return hashSet;
		}

		internal static HashSet<string> GetBepInExFolderBasenames()
		{
			if (_bepInExFolderBasenamesCache != null)
			{
				return _bepInExFolderBasenamesCache;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			try
			{
				foreach (string item in Directory.EnumerateDirectories(Paths.PluginPath))
				{
					string fileName = Path.GetFileName(item);
					if (!string.IsNullOrEmpty(fileName))
					{
						hashSet.Add(fileName);
						hashSet.Add(fileName.Replace(' ', '_'));
						hashSet.Add(fileName.Replace('_', ' '));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[Provenance] BepInEx folder enumeration failed: " + ex.Message));
			}
			_bepInExFolderBasenamesCache = hashSet;
			return hashSet;
		}

		internal static string? IdentifyBundleOwnerByToc(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return null;
			}
			HashSet<string> pluginDllBasenames = GetPluginDllBasenames();
			HashSet<string> bepInExFolderBasenames = GetBepInExFolderBasenames();
			if (pluginDllBasenames.Count == 0 && bepInExFolderBasenames.Count == 0)
			{
				return null;
			}
			if (!string.IsNullOrEmpty(((Object)bundle).name))
			{
				if (pluginDllBasenames.Contains(((Object)bundle).name))
				{
					foreach (string item in pluginDllBasenames)
					{
						if (item.Equals(((Object)bundle).name, StringComparison.OrdinalIgnoreCase))
						{
							return item;
						}
					}
				}
				if (bepInExFolderBasenames.Contains(((Object)bundle).name))
				{
					foreach (string item2 in bepInExFolderBasenames)
					{
						if (item2.Equals(((Object)bundle).name, StringComparison.OrdinalIgnoreCase))
						{
							return item2;
						}
					}
				}
			}
			try
			{
				string[] allAssetNames = bundle.GetAllAssetNames();
				int num = Math.Min(allAssetNames.Length, 64);
				string text = null;
				for (int i = 0; i < num; i++)
				{
					string text2 = allAssetNames[i];
					if (string.IsNullOrEmpty(text2))
					{
						continue;
					}
					string[] array = text2.Replace('\\', '/').Split(new char[1] { '/' });
					string[] array2 = array;
					foreach (string text3 in array2)
					{
						if (string.IsNullOrEmpty(text3) || text3.Equals("assets", StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text3);
						if (pluginDllBasenames.Contains(fileNameWithoutExtension))
						{
							foreach (string item3 in pluginDllBasenames)
							{
								if (item3.Equals(fileNameWithoutExtension, StringComparison.OrdinalIgnoreCase))
								{
									return item3;
								}
							}
						}
						if (text != null || !bepInExFolderBasenames.Contains(fileNameWithoutExtension))
						{
							continue;
						}
						foreach (string item4 in bepInExFolderBasenames)
						{
							if (item4.Equals(fileNameWithoutExtension, StringComparison.OrdinalIgnoreCase))
							{
								text = item4;
								break;
							}
						}
					}
				}
				if (text != null)
				{
					return text;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[Provenance] TOC walk for '" + ((Object)bundle).name + "' failed: " + ex.Message));
			}
			return null;
		}

		internal static void OnBundleLoadedFromFile(AssetBundle? bundle, string? path)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return;
			}
			RecordBundleOwner(bundle, IdentifyCallingPluginDll());
			if (path != null)
			{
				string text = path.Replace('\\', '/');
				bool flag = Plugin._valheimDataPath != null && text.StartsWith(Plugin._valheimDataPath, StringComparison.OrdinalIgnoreCase);
				bool flag2 = text.IndexOf("/valheim_Data/", StringComparison.OrdinalIgnoreCase) >= 0;
				if (flag || flag2)
				{
					Plugin._vanillaBundleNames.Add(((Object)bundle).name);
					AddBundleMatNamesToBaseline(bundle);
					Plugin.Log.LogDebug((object)("[Provenance] Classify bundle '" + ((Object)bundle).name + "' → VANILLA  (source=LoadFromFile, path under Valheim data dir)"));
					return;
				}
			}
			if (Plugin._vanillaBundleNames.Contains(((Object)bundle).name))
			{
				AddBundleMatNamesToBaseline(bundle);
				Plugin.Log.LogDebug((object)("[Provenance] Classify bundle '" + ((Object)bundle).name + "' → VANILLA  (source=LoadFromFile, name in Awake snapshot)"));
				return;
			}
			Plugin.Log.LogDebug((object)("[Provenance] Classify bundle '" + ((Object)bundle).name + "' → MOD-OWNED  (source=LoadFromFile, path='" + (path ?? "<null>") + "')"));
			TagBundleAssets(bundle);
		}

		internal static void OnBundleLoadedFromMemoryOrStream(AssetBundle? bundle)
		{
			if (!((Object)(object)bundle == (Object)null))
			{
				if (Plugin._vanillaBundleNames.Contains(((Object)bundle).name))
				{
					Plugin.Log.LogDebug((object)("[Provenance] Classify bundle '" + ((Object)bundle).name + "' → VANILLA  (source=LoadFromMemory/Stream, name in Awake snapshot)"));
				}
				else if (Plugin._awakeVanillaSnapshotEmpty)
				{
					Plugin._deferredMemoryStreamBundles.Add(bundle);
					Plugin.Log.LogDebug((object)("[Provenance] Classify bundle '" + ((Object)bundle).name + "' → DEFERRED  (source=LoadFromMemory/Stream, Awake vanilla-snapshot was empty — will reclassify at ZNetScene.Awake)"));
				}
				else
				{
					Plugin.Log.LogDebug((object)("[Provenance] Classify bundle '" + ((Object)bundle).name + "' → MOD-OWNED  (source=LoadFromMemory/Stream, Awake vanilla-snapshot populated)"));
					TagBundleAssets(bundle);
				}
			}
		}

		internal static void OnLoadAssetResult(AssetBundle? bundle, Object? result)
		{
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			if (result == (Object)null || ((Object)(object)bundle != (Object)null && Plugin._vanillaBundleNames.Contains(((Object)bundle).name)))
			{
				return;
			}
			if ((Object)(object)bundle != (Object)null && !string.IsNullOrEmpty(((Object)bundle).name) && !Plugin._bundleToDll.ContainsKey(((Object)bundle).name))
			{
				string text = IdentifyCallingPluginDll();
				if (!string.IsNullOrEmpty(text))
				{
					Plugin._bundleToDll[((Object)bundle).name] = text;
					Plugin._tocAttributedBundles.Add(((Object)bundle).name);
					Plugin.Log.LogDebug((object)("[Provenance] Bundle '" + ((Object)bundle).name + "' attributed to DLL '" + text + "' via OnLoadAssetResult stack-walk fallback (no TOC-walk match — see CHANGELOG v3.0.41)"));
				}
			}
			if (Plugin.DiagnosticProbes)
			{
				Shader val = (Shader)(object)((result is Shader) ? result : null);
				if (val != null)
				{
					try
					{
						string text2 = ((Object)val).name ?? string.Empty;
						if (!string.IsNullOrEmpty(text2) && IsVanillaShaderName(text2))
						{
							Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
							int num = 0;
							List<int> list = new List<int>();
							int instanceID = ((Object)val).GetInstanceID();
							Shader[] array2 = array;
							foreach (Shader val2 in array2)
							{
								if (!((Object)(object)val2 == (Object)null) && !(((Object)val2).name != text2) && ((Object)val2).GetInstanceID() != instanceID)
								{
									num++;
									if (list.Count < 8)
									{
										list.Add(((Object)val2).GetInstanceID());
									}
								}
							}
							if (num >= 1)
							{
								string text3 = string.Join(",", list);
								string text4 = ((num > list.Count) ? ("+" + (num - list.Count) + "more") : "");
								Plugin.Log.LogInfo((object)("[BindProbe-OnLoadAsset] bundle='" + (((bundle != null) ? ((Object)bundle).name : null) ?? "<null>") + "' shader='" + text2 + "'" + $" newId={instanceID} peerCount={num} peerIds=[{text3}{text4}]" + $" newShaderRQ={val.renderQueue} newShaderIsSupported={val.isSupported} vanillaName=true"));
							}
						}
					}
					catch (Exception ex)
					{
						Plugin.Log.LogDebug((object)("[BindProbe-OnLoadAsset] swallowed exception for shader load from bundle '" + (((bundle != null) ? ((Object)bundle).name : null) ?? "<null>") + "': " + ex.GetType().Name + ": " + ex.Message));
					}
				}
			}
			if (Plugin.DiagnosticProbes)
			{
				Material val3 = (Material)(object)((result is Material) ? result : null);
				if (val3 != null)
				{
					try
					{
						if ((Object)(object)val3.shader != (Object)null)
						{
							string text5 = ((Object)val3.shader).name ?? string.Empty;
							if (!string.IsNullOrEmpty(text5) && IsVanillaShaderName(text5))
							{
								string text6 = ((bundle != null) ? ((Object)bundle).name : null) ?? "<null>";
								string item = text6 + "::" + text5;
								if (_materialLoadProbeFiredKeys.Add(item))
								{
									Shader[] array3 = Resources.FindObjectsOfTypeAll<Shader>();
									int num2 = 0;
									List<int> list2 = new List<int>();
									int instanceID2 = ((Object)val3.shader).GetInstanceID();
									Shader[] array4 = array3;
									foreach (Shader val4 in array4)
									{
										if (!((Object)(object)val4 == (Object)null) && !(((Object)val4).name != text5) && ((Object)val4).GetInstanceID() != instanceID2)
										{
											num2++;
											if (list2.Count < 8)
											{
												list2.Add(((Object)val4).GetInstanceID());
											}
										}
									}
									if (num2 >= 1)
									{
										string arg = string.Join(",", list2);
										string arg2 = ((num2 > list2.Count) ? ("+" + (num2 - list2.Count) + "more") : string.Empty);
										string text7 = "n/a";
										try
										{
											int num3 = val3.shader.FindPropertyIndex("_Color");
											text7 = ((num3 < 0) ? "no-_Color" : ((object)val3.shader.GetPropertyType(num3)/*cast due to .constrained prefix*/).ToString());
										}
										catch (Exception)
										{
										}
										Plugin.Log.LogInfo((object)("[BindProbe-MaterialLoad] bundle='" + text6 + "' material='" + (((Object)val3).name ?? "<null>") + "'" + $" matId={((Object)val3).GetInstanceID()} shader='{text5}' shaderId={instanceID2}" + $" peerCount={num2} peerIds=[{arg}{arg2}]" + $" shaderRQ={val3.shader.renderQueue} shaderIsSupported={val3.shader.isSupported}" + " schema=" + text7 + " vanillaName=true"));
									}
								}
							}
						}
					}
					catch (Exception ex3)
					{
						Plugin.Log.LogDebug((object)("[BindProbe-MaterialLoad] swallowed exception for material load from bundle '" + (((bundle != null) ? ((Object)bundle).name : null) ?? "<null>") + "': " + ex3.GetType().Name + ": " + ex3.Message));
					}
				}
			}
			TagModAsset(result);
			if ((Object)(object)bundle != (Object)null)
			{
				GameObject val5 = (GameObject)(object)((result is GameObject) ? result : null);
				if (val5 != null)
				{
					CapturePrefabRootFromBundle(bundle, val5);
					ProbeGameObjectMaterialsForBindProbe(bundle, val5);
				}
			}
		}

		private static void ProbeGameObjectMaterialsForBindProbe(AssetBundle bundle, GameObject go)
		{
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.DiagnosticProbes || (Object)(object)bundle == (Object)null || (Object)(object)go == (Object)null)
			{
				return;
			}
			try
			{
				string text = ((Object)bundle).name ?? "<null>";
				Shader[] array = null;
				Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val in componentsInChildren)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Material[] sharedMaterials = val.sharedMaterials;
					if (sharedMaterials == null)
					{
						continue;
					}
					Material[] array2 = sharedMaterials;
					foreach (Material val2 in array2)
					{
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						Shader shader = val2.shader;
						if ((Object)(object)shader == (Object)null)
						{
							continue;
						}
						string text2 = ((Object)shader).name ?? string.Empty;
						if (string.IsNullOrEmpty(text2) || !IsVanillaShaderName(text2))
						{
							continue;
						}
						string item = text + "::" + text2;
						if (!_gameObjectMaterialProbeFiredKeys.Add(item))
						{
							continue;
						}
						if (array == null)
						{
							array = Resources.FindObjectsOfTypeAll<Shader>();
						}
						int num = 0;
						List<int> list = new List<int>();
						int instanceID = ((Object)shader).GetInstanceID();
						Shader[] array3 = array;
						foreach (Shader val3 in array3)
						{
							if (!((Object)(object)val3 == (Object)null) && !(((Object)val3).name != text2) && ((Object)val3).GetInstanceID() != instanceID)
							{
								num++;
								if (list.Count < 8)
								{
									list.Add(((Object)val3).GetInstanceID());
								}
							}
						}
						if (num >= 1)
						{
							string arg = string.Join(",", list);
							string arg2 = ((num > list.Count) ? ("+" + (num - list.Count) + "more") : string.Empty);
							string text3 = "n/a";
							try
							{
								int num2 = shader.FindPropertyIndex("_Color");
								text3 = ((num2 < 0) ? "no-_Color" : ((object)shader.GetPropertyType(num2)/*cast due to .constrained prefix*/).ToString());
							}
							catch (Exception)
							{
							}
							Plugin.Log.LogInfo((object)("[BindProbe-GameObjectMaterial] bundle='" + text + "' gameObject='" + (((Object)go).name ?? "<null>") + "'" + string.Format(" goId={0} renderer='{1}' material='{2}'", ((Object)go).GetInstanceID(), ((Object)val).name ?? "<null>", ((Object)val2).name ?? "<null>") + $" matId={((Object)val2).GetInstanceID()} shader='{text2}' shaderId={instanceID}" + $" peerCount={num} peerIds=[{arg}{arg2}]" + $" shaderRQ={shader.renderQueue} shaderIsSupported={shader.isSupported}" + " schema=" + text3 + " vanillaName=true"));
						}
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogDebug((object)("[BindProbe-GameObjectMaterial] swallowed exception walking GameObject '" + (((go != null) ? ((Object)go).name : null) ?? "<null>") + "' from bundle '" + (((bundle != null) ? ((Object)bundle).name : null) ?? "<null>") + "': " + ex2.GetType().Name + ": " + ex2.Message));
			}
		}

		private static void CapturePrefabRootFromBundle(AssetBundle bundle, GameObject go)
		{
			if (!((Object)(object)bundle == (Object)null) && !((Object)(object)go == (Object)null) && !Plugin._vanillaBundleNames.Contains(((Object)bundle).name) && Plugin._bundleToDll.TryGetValue(((Object)bundle).name, out string value) && !string.IsNullOrEmpty(value))
			{
				string text = Plugin.StripCloneSuffix(((Object)go).name);
				if (!string.IsNullOrEmpty(text) && !Plugin._prefabRootToDll.ContainsKey(text))
				{
					Plugin._prefabRootToDll[text] = value;
				}
			}
		}

		internal static void RefreshCanonicalShaderIdsFromLoadedAssets()
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			if ((Object)(object)Plugin._fallbackMat != (Object)null && (Object)(object)Plugin._fallbackMat.shader != (Object)null)
			{
				if (!Plugin._fallbackMat.shader.isSupported)
				{
					num7++;
				}
				else if (Plugin.CanonicalShaderIds.Add(((Object)Plugin._fallbackMat.shader).GetInstanceID()))
				{
					num++;
				}
			}
			if ((Object)(object)Plugin._transparentMat != (Object)null && (Object)(object)Plugin._transparentMat.shader != (Object)null)
			{
				if (!Plugin._transparentMat.shader.isSupported)
				{
					num7++;
				}
				else if (Plugin.CanonicalShaderIds.Add(((Object)Plugin._transparentMat.shader).GetInstanceID()))
				{
					num2++;
				}
			}
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance != (Object)null && instance.m_prefabs != null)
			{
				foreach (GameObject prefab in instance.m_prefabs)
				{
					if ((Object)(object)prefab == (Object)null)
					{
						continue;
					}
					num4++;
					Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val in componentsInChildren)
					{
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						num5++;
						Material[] sharedMaterials = val.sharedMaterials;
						foreach (Material val2 in sharedMaterials)
						{
							if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null))
							{
								int instanceID = ((Object)val2).GetInstanceID();
								if (Plugin._prefabScopedModMatIds.Contains(instanceID))
								{
									num6++;
								}
								else if (!val2.shader.isSupported)
								{
									num7++;
								}
								else if (Plugin.CanonicalShaderIds.Add(((Object)val2.shader).GetInstanceID()))
								{
									num3++;
								}
							}
						}
					}
				}
			}
			int num8 = num + num2 + num3;
			if (num8 > 0 || num6 > 0 || num7 > 0)
			{
				Plugin.Log.LogDebug((object)("[ZNetScene.Awake] Canonical shader IDs refreshed (instance-reachability): " + $"+{num8} total (fallbackMat={num}, transparentMat={num2}, " + $"vanilla-prefab mats={num3} across {num4} prefab(s) / {num5} renderer(s); " + $"rejected {num6} mod-lane-admitted material(s), " + $"rejected {num7} unsupported shader instance(s)); CanonicalShaderIds total={Plugin.CanonicalShaderIds.Count}"));
			}
			if (num8 > 0)
			{
				ReplacementCore.BumpAdmissionEpoch("RefreshCanonicalShaderIds");
			}
		}

		private static bool IsVanillaShader(Shader? sh)
		{
			if ((Object)(object)sh == (Object)null)
			{
				return false;
			}
			if (Plugin.CanonicalShaderIds.Contains(((Object)sh).GetInstanceID()))
			{
				return true;
			}
			if (Plugin.ValheimShaderNameSet.Contains(((Object)sh).name))
			{
				return true;
			}
			if (Plugin.UnityBuiltInShaderNameSet.Contains(((Object)sh).name))
			{
				return true;
			}
			if (Plugin._vanillaShaderNames.Contains(((Object)sh).name))
			{
				return true;
			}
			return false;
		}

		internal static bool IsVanillaShaderName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (Plugin._vanillaShaderNames.Contains(name))
			{
				return true;
			}
			if (Plugin.ValheimShaderNameSet.Contains(name))
			{
				return true;
			}
			if (Plugin.UnityBuiltInShaderNameSet.Contains(name))
			{
				return true;
			}
			return false;
		}

		internal static void EmitBaselineSnapshot(string label)
		{
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.DiagnosticProbes)
			{
				return;
			}
			try
			{
				Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
				Dictionary<string, List<Shader>> dictionary = new Dictionary<string, List<Shader>>(StringComparer.Ordinal);
				Shader[] array2 = array;
				foreach (Shader val in array2)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					string text = ((Object)val).name ?? string.Empty;
					if (!string.IsNullOrEmpty(text) && IsVanillaShaderName(text))
					{
						if (!dictionary.TryGetValue(text, out var value))
						{
							value = (dictionary[text] = new List<Shader>());
						}
						value.Add(val);
					}
				}
				int num = 0;
				foreach (KeyValuePair<string, List<Shader>> item in dictionary)
				{
					if (item.Value.Count < 2)
					{
						continue;
					}
					num++;
					StringBuilder stringBuilder = new StringBuilder();
					for (int j = 0; j < item.Value.Count; j++)
					{
						Shader val2 = item.Value[j];
						if (j > 0)
						{
							stringBuilder.Append(",");
						}
						stringBuilder.Append("id=");
						stringBuilder.Append(((Object)val2).GetInstanceID());
						stringBuilder.Append("(RQ=");
						stringBuilder.Append(val2.renderQueue);
						stringBuilder.Append(" sup=");
						stringBuilder.Append(val2.isSupported ? "T" : "F");
						try
						{
							int num2 = val2.FindPropertyIndex("_Color");
							if (num2 >= 0)
							{
								stringBuilder.Append(" sch=");
								stringBuilder.Append(((object)val2.GetPropertyType(num2)/*cast due to .constrained prefix*/).ToString());
							}
						}
						catch
						{
						}
						stringBuilder.Append(")");
					}
					Plugin.Log.LogInfo((object)($"[BindProbe-Baseline] label='{label}' shader='{item.Key}' instanceCount={item.Value.Count}" + $" instances=[{stringBuilder}]"));
				}
				Plugin.Log.LogInfo((object)($"[BindProbe-Baseline] label='{label}' summary: {num} vanilla shader name(s) with >=2 instances at this moment" + $" (vanilla-name registry total {dictionary.Count} of {array.Length} loaded shaders)."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[BindProbe-Baseline] swallowed exception during baseline walk at label='" + label + "': " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		internal static void RetroactiveBundleSweep(string label)
		{
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.DiagnosticProbes)
			{
				try
				{
					Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
					Dictionary<string, List<Shader>> dictionary = new Dictionary<string, List<Shader>>(StringComparer.Ordinal);
					Shader[] array2 = array;
					foreach (Shader val in array2)
					{
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						string text = ((Object)val).name ?? string.Empty;
						if (!string.IsNullOrEmpty(text))
						{
							if (!dictionary.TryGetValue(text, out var value))
							{
								value = (dictionary[text] = new List<Shader>());
							}
							value.Add(val);
						}
					}
					int num = 0;
					int num2 = 0;
					foreach (KeyValuePair<string, List<Shader>> item in dictionary)
					{
						if (item.Value.Count < 2)
						{
							continue;
						}
						num++;
						num2 += item.Value.Count;
						StringBuilder stringBuilder = new StringBuilder();
						for (int j = 0; j < item.Value.Count; j++)
						{
							Shader val2 = item.Value[j];
							if (j > 0)
							{
								stringBuilder.Append(",");
							}
							stringBuilder.Append("id=");
							stringBuilder.Append(((Object)val2).GetInstanceID());
							stringBuilder.Append("(RQ=");
							stringBuilder.Append(val2.renderQueue);
							stringBuilder.Append(" sup=");
							stringBuilder.Append(val2.isSupported ? "T" : "F");
							try
							{
								int num3 = val2.FindPropertyIndex("_Color");
								if (num3 >= 0)
								{
									stringBuilder.Append(" sch=");
									stringBuilder.Append(((object)val2.GetPropertyType(num3)/*cast due to .constrained prefix*/).ToString());
								}
							}
							catch
							{
							}
							stringBuilder.Append(")");
						}
						Plugin.Log.LogInfo((object)($"[BindProbe-RetroactiveSweep] label='{label}' shader='{item.Key}' instanceCount={item.Value.Count}" + $" instances=[{stringBuilder}]"));
					}
					if (num > 0)
					{
						Plugin.Log.LogInfo((object)($"[BindProbe-RetroactiveSweep] label='{label}' summary: {num} shader name(s) with >=2 registered instances," + $" totaling {num2} colliding shader object(s) across {dictionary.Count} distinct shader name(s) in the registry."));
					}
					else
					{
						Plugin.Log.LogInfo((object)("[BindProbe-RetroactiveSweep] label='" + label + "' summary: 0 shader-name collisions detected at retroactive-sweep time" + $" ({dictionary.Count} distinct shader names registered, all with single instances)."));
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogDebug((object)("[BindProbe-RetroactiveSweep] swallowed exception during registry walk at label='" + label + "': " + ex.GetType().Name + ": " + ex.Message));
				}
			}
			int count = Plugin._baselineMatNames.Count;
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				if (!((Object)(object)allLoadedAssetBundle == (Object)null) && Plugin._vanillaBundleNames.Contains(((Object)allLoadedAssetBundle).name))
				{
					AddBundleMatNamesToBaseline(allLoadedAssetBundle);
				}
			}
			Material[] array3 = Resources.FindObjectsOfTypeAll<Material>();
			int num4 = Plugin._baselineMatNames.Count - count;
			int num5 = 0;
			if (Plugin._deferredMemoryStreamBundles.Count > 0)
			{
				foreach (AssetBundle deferredMemoryStreamBundle in Plugin._deferredMemoryStreamBundles)
				{
					if (!((Object)(object)deferredMemoryStreamBundle == (Object)null) && !Plugin._vanillaBundleNames.Contains(((Object)deferredMemoryStreamBundle).name))
					{
						Plugin.Log.LogDebug((object)("[Provenance] Classify deferred bundle '" + ((Object)deferredMemoryStreamBundle).name + "' → MOD-OWNED  (reclassified at " + label + ", baseline now populated)"));
						TagBundleAssets(deferredMemoryStreamBundle);
						num5++;
					}
				}
				Plugin._deferredMemoryStreamBundles.Clear();
			}
			int num6 = 0;
			foreach (AssetBundle allLoadedAssetBundle2 in AssetBundle.GetAllLoadedAssetBundles())
			{
				if (!((Object)(object)allLoadedAssetBundle2 == (Object)null) && !Plugin._vanillaBundleNames.Contains(((Object)allLoadedAssetBundle2).name))
				{
					TagBundleAssets(allLoadedAssetBundle2);
					num6++;
				}
			}
			Plugin.Log.LogDebug((object)$"[Provenance] {label}: {num6} mod bundle(s) tagged ({num5} from deferred mem/stream list). Baseline +{num4} from vanilla bundles (total {Plugin._baselineMatNames.Count}).");
		}

		private static void AddBundleMatNamesToBaseline(AssetBundle bundle)
		{
			try
			{
				string[] allAssetNames = bundle.GetAllAssetNames();
				foreach (string text in allAssetNames)
				{
					if (!string.IsNullOrEmpty(text) && text.EndsWith(".mat", StringComparison.OrdinalIgnoreCase))
					{
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
						if (!string.IsNullOrEmpty(fileNameWithoutExtension))
						{
							Plugin._baselineMatNames.Add(fileNameWithoutExtension);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogDebug((object)("[Baseline] TOC walk failed for '" + ((Object)bundle).name + "': " + ex.Message));
			}
		}

		private static bool IsVanillaByName(Material mat)
		{
			if ((Object)(object)mat == (Object)null || string.IsNullOrEmpty(((Object)mat).name))
			{
				return false;
			}
			string text = Plugin.StripInstance(((Object)mat).name);
			return !string.IsNullOrEmpty(text) && Plugin._baselineMatNames.Contains(text);
		}

		private static (int total, int matches) ComputeBaselineNameRatio(AssetBundle bundle)
		{
			int num = 0;
			int num2 = 0;
			try
			{
				string[] allAssetNames = bundle.GetAllAssetNames();
				foreach (string text in allAssetNames)
				{
					if (!string.IsNullOrEmpty(text) && text.EndsWith(".mat", StringComparison.OrdinalIgnoreCase))
					{
						num++;
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
						if (!string.IsNullOrEmpty(fileNameWithoutExtension) && Plugin._baselineMatNames.Contains(fileNameWithoutExtension))
						{
							num2++;
						}
					}
				}
			}
			catch
			{
			}
			return (total: num, matches: num2);
		}

		private static void TagBundleAssets(AssetBundle bundle)
		{
			if (Plugin._awakeVanillaSnapshotEmpty && !Plugin._vanillaBundleNames.Contains(((Object)bundle).name))
			{
				var (num, num2) = ComputeBaselineNameRatio(bundle);
				if (num >= 200 && num2 * 100 >= num * 95)
				{
					Plugin.Log.LogDebug((object)$"[Provenance] Reclassify bundle '{((Object)bundle).name}' → VANILLA  (TOC baseline-name ratio {num2}/{num} = {100.0 * (double)num2 / (double)num:F1}% ≥ 95%, samples ≥ 200 — evidence of vanilla content)");
					Plugin._vanillaBundleNames.Add(((Object)bundle).name);
					AddBundleMatNamesToBaseline(bundle);
					return;
				}
			}
			if (!Plugin._bundleToDll.TryGetValue(((Object)bundle).name, out string value))
			{
				value = IdentifyBundleOwnerByToc(bundle);
				if (value != null)
				{
					Plugin._bundleToDll[((Object)bundle).name] = value;
					Plugin._tocAttributedBundles.Add(((Object)bundle).name);
					Plugin.Log.LogDebug((object)("[Provenance] Bundle '" + ((Object)bundle).name + "' attributed to DLL '" + value + "' via TOC-path heuristic (no load-time call site — mod bundle loaded before Harmony patches installed)"));
				}
			}
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			try
			{
				Shader[] array = bundle.LoadAllAssets<Shader>();
				foreach (Shader val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					if (Plugin.DiagnosticProbes)
					{
						try
						{
							string text = ((Object)val).name ?? string.Empty;
							if (!string.IsNullOrEmpty(text) && IsVanillaShaderName(text))
							{
								Shader[] array2 = Resources.FindObjectsOfTypeAll<Shader>();
								int num8 = 0;
								List<int> list = new List<int>();
								int instanceID = ((Object)val).GetInstanceID();
								Shader[] array3 = array2;
								foreach (Shader val2 in array3)
								{
									if (!((Object)(object)val2 == (Object)null) && !(((Object)val2).name != text) && ((Object)val2).GetInstanceID() != instanceID)
									{
										num8++;
										if (list.Count < 8)
										{
											list.Add(((Object)val2).GetInstanceID());
										}
									}
								}
								if (num8 >= 1)
								{
									string text2 = string.Join(",", list);
									string text3 = ((num8 > list.Count) ? ("+" + (num8 - list.Count) + "more") : "");
									Plugin.Log.LogInfo((object)("[BindProbe-ShaderLoad] bundle='" + ((Object)bundle).name + "' shader='" + text + "'" + $" newId={instanceID} peerCount={num8} peerIds=[{text2}{text3}]" + $" newShaderRQ={val.renderQueue} newShaderIsSupported={val.isSupported} vanillaName=true"));
								}
							}
						}
						catch (Exception ex)
						{
							Plugin.Log.LogDebug((object)("[BindProbe-ShaderLoad] swallowed exception for shader in bundle '" + ((Object)bundle).name + "': " + ex.GetType().Name + ": " + ex.Message));
						}
					}
					if (IsVanillaShader(val))
					{
						num5++;
						continue;
					}
					string key = ((Object)val).name ?? string.Empty;
					if (value != null && !Plugin.ModShaderDlls.ContainsKey(key))
					{
						Plugin.ModShaderDlls[key] = value;
						num7++;
					}
				}
				Material[] array4 = bundle.LoadAllAssets<Material>();
				foreach (Material val3 in array4)
				{
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					if ((Object)(object)val3.shader != (Object)null && !IsVanillaShader(val3.shader) && value != null && !Plugin.ModShaderDlls.ContainsKey(((Object)val3.shader).name))
					{
						Plugin.ModShaderDlls[((Object)val3.shader).name] = value;
						num7++;
					}
					if (IsVanillaByName(val3))
					{
						num6++;
						continue;
					}
					TagModMaterialName(val3);
					if ((!((Object)(object)val3.shader != (Object)null) || IsVanillaShader(val3.shader)) && (Object)(object)val3.shader != (Object)null)
					{
						num5++;
					}
				}
				GameObject[] array5 = bundle.LoadAllAssets<GameObject>();
				foreach (GameObject val4 in array5)
				{
					if ((Object)(object)val4 == (Object)null)
					{
						continue;
					}
					if (value != null)
					{
						string text4 = Plugin.StripCloneSuffix(((Object)val4).name);
						if (!string.IsNullOrEmpty(text4) && !Plugin._prefabRootToDll.ContainsKey(text4))
						{
							Plugin._prefabRootToDll[text4] = value;
						}
					}
					Renderer[] componentsInChildren = val4.GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val5 in componentsInChildren)
					{
						Material[] sharedMaterials = val5.sharedMaterials;
						foreach (Material val6 in sharedMaterials)
						{
							if ((Object)(object)val6 == (Object)null)
							{
								continue;
							}
							if ((Object)(object)val6.shader != (Object)null && !IsVanillaShader(val6.shader) && value != null && !Plugin.ModShaderDlls.ContainsKey(((Object)val6.shader).name))
							{
								Plugin.ModShaderDlls[((Object)val6.shader).name] = value;
								num7++;
							}
							if (IsVanillaByName(val6))
							{
								num6++;
								continue;
							}
							TagModMaterialName(val6);
							if ((!((Object)(object)val6.shader != (Object)null) || IsVanillaShader(val6.shader)) && (Object)(object)val6.shader != (Object)null)
							{
								num5++;
							}
						}
					}
				}
				if (value != null && Plugin._tocAttributedBundles.Contains(((Object)bundle).name))
				{
					int num9 = 0;
					int num10 = 0;
					Material[] array6 = bundle.LoadAllAssets<Material>();
					foreach (Material val7 in array6)
					{
						if ((Object)(object)val7 == (Object)null)
						{
						}
					}
					GameObject[] array7 = bundle.LoadAllAssets<GameObject>();
					foreach (GameObject val8 in array7)
					{
						if ((Object)(object)val8 == (Object)null)
						{
							continue;
						}
						Renderer[] componentsInChildren2 = val8.GetComponentsInChildren<Renderer>(true);
						foreach (Renderer val9 in componentsInChildren2)
						{
							Material[] sharedMaterials2 = val9.sharedMaterials;
							foreach (Material val10 in sharedMaterials2)
							{
								if ((Object)(object)val10 == (Object)null)
								{
								}
							}
						}
					}
					if (num9 > 0 || num10 > 0)
					{
						Plugin.Log.LogDebug((object)$"[Provenance] Lane-6 bundle-owned mat-ID lane: +{num9} (material assets) + {num10} (GameObject renderers) id(s) from TOC-attributed bundle '{((Object)bundle).name}' (owner: '{value}')");
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("[Provenance] Failed to walk bundle '" + ((Object)bundle).name + "': " + ex2.Message));
				return;
			}
			Plugin.Log.LogDebug((object)string.Format("[Provenance] Tagged mod bundle '{0}': +{1} shaders, +{2} materials (skipped {3} vanilla shader refs, {4} vanilla-name mats, +{5} shader→DLL attributions to '{6}')", ((Object)bundle).name, num3, num4, num5, num6, num7, value ?? "unknown"));
			if (num3 > 0 || num4 > 0)
			{
				ReplacementCore.BumpAdmissionEpoch("TagBundleAssets");
			}
		}

		private static void TagModAsset(Object obj)
		{
			bool flag = false;
			Material val = (Material)(object)((obj is Material) ? obj : null);
			if (val == null)
			{
				Shader val2 = (Shader)(object)((obj is Shader) ? obj : null);
				if (val2 == null)
				{
					GameObject val3 = (GameObject)(object)((obj is GameObject) ? obj : null);
					if (val3 == null)
					{
						return;
					}
					Renderer[] componentsInChildren = val3.GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val4 in componentsInChildren)
					{
						Material[] sharedMaterials = val4.sharedMaterials;
						foreach (Material val5 in sharedMaterials)
						{
							if (!((Object)(object)val5 == (Object)null) && !IsVanillaByName(val5) && TagModMaterialName(val5))
							{
								flag = true;
							}
						}
					}
					if (flag)
					{
						ReplacementCore.BumpAdmissionEpoch("TagModAsset.GameObject");
					}
				}
				else if (flag)
				{
					ReplacementCore.BumpAdmissionEpoch("TagModAsset.Shader");
				}
			}
			else if (!IsVanillaByName(val))
			{
				if (TagModMaterialName(val))
				{
					flag = true;
				}
				if (flag)
				{
					ReplacementCore.BumpAdmissionEpoch("TagModAsset.Material");
				}
			}
		}

		private static bool TagModMaterialName(Material mat)
		{
			if (string.IsNullOrEmpty(((Object)mat).name))
			{
				return false;
			}
			string text = Plugin.StripInstance(((Object)mat).name);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (Plugin._baselineMatNames.Contains(text))
			{
				return false;
			}
			return false;
		}
	}
}
namespace ShaderHelperForMac.Diagnostics
{
	internal static class MatDump
	{
		private sealed class ParsedMatDump
		{
			public string MatName = "<unknown>";

			public string ShaderName = "<unknown>";

			public int RenderQueue = 0;

			public int PassCount = 0;

			public bool Supported = false;

			public bool Canonical = false;

			public HashSet<string> Keywords = new HashSet<string>(StringComparer.Ordinal);

			public Dictionary<string, string> Props = new Dictionary<string, string>(StringComparer.Ordinal);

			public string? ReplacedMats;

			public string? Cached;

			public string? Gate;

			public int BlocksSeen = 0;
		}

		private static readonly string[] _dumpTargets = new string[1] { "BastardFlametal" };

		internal static string SanitizeMatDumpLabel(string label)
		{
			if (string.IsNullOrEmpty(label))
			{
				return "unnamed";
			}
			StringBuilder stringBuilder = new StringBuilder(label.Length);
			foreach (char c in label)
			{
				if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_')
				{
					stringBuilder.Append(c);
				}
				else
				{
					stringBuilder.Append('_');
				}
			}
			string text = stringBuilder.ToString();
			if (text.Length == 0)
			{
				return "unnamed";
			}
			return text;
		}

		internal static void EmitMatDumpBlock(Material mat, string qBase, List<Action<string>> sinks)
		{
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected I4, but got Unknown
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null || (Object)(object)mat.shader == (Object)null || sinks == null || sinks.Count == 0)
			{
				return;
			}
			int instanceID = ((Object)mat).GetInstanceID();
			Shader shader = mat.shader;
			int instanceID2 = ((Object)shader).GetInstanceID();
			bool flag = Plugin.CanonicalShaderIds.Contains(instanceID2);
			bool isSupported = shader.isSupported;
			bool flag2 = Plugin._baselineMatNames.Contains(qBase);
			bool flag3 = Plugin._vanillaShaderNames.Contains(((Object)shader).name) || Plugin.ValheimShaderNameSet.Contains(((Object)shader).name) || Plugin.UnityBuiltInShaderNameSet.Contains(((Object)shader).name);
			bool flag4 = flag;
			bool flag5 = flag3 || flag4;
			bool flag6 = Plugin._prefabScopedModMatIds.Contains(instanceID);
			bool flag7 = !(flag2 && flag5) || flag6;
			WriteAll($"[MatDump] mat='{qBase}'  matId={instanceID}  shader='{((Object)shader).name}'  shaderId={instanceID2}" + $"  supported={isSupported}  canonical={flag}  renderQueue={mat.renderQueue}  passCount={shader.passCount}");
			string[] shaderKeywords = mat.shaderKeywords;
			string text = ((shaderKeywords == null || shaderKeywords.Length == 0) ? "<none>" : string.Join("|", shaderKeywords));
			WriteAll("[MatDump]   keywords=" + text);
			int propertyCount = shader.GetPropertyCount();
			for (int i = 0; i < propertyCount; i++)
			{
				string propertyName = shader.GetPropertyName(i);
				ShaderPropertyType propertyType = shader.GetPropertyType(i);
				string arg;
				try
				{
					ShaderPropertyType val = propertyType;
					ShaderPropertyType val2 = val;
					switch ((int)val2)
					{
					case 4:
					{
						Texture texture = mat.GetTexture(propertyName);
						Vector2 textureScale = mat.GetTextureScale(propertyName);
						Vector2 textureOffset = mat.GetTextureOffset(propertyName);
						arg = (((Object)(object)texture == (Object)null) ? $"<null>  scale=({textureScale.x:F3},{textureScale.y:F3})  offset=({textureOffset.x:F3},{textureOffset.y:F3})" : $"'{((Object)texture).name}'  scale=({textureScale.x:F3},{textureScale.y:F3})  offset=({textureOffset.x:F3},{textureOffset.y:F3})");
						break;
					}
					case 0:
						arg = ((object)mat.GetColor(propertyName)/*cast due to .constrained prefix*/).ToString();
						break;
					case 2:
					case 3:
						arg = mat.GetFloat(propertyName).ToString("0.###");
						break;
					case 1:
						arg = ((object)mat.GetVector(propertyName)/*cast due to .constrained prefix*/).ToString();
						break;
					case 5:
						arg = mat.GetInt(propertyName).ToString();
						break;
					default:
						arg = "<unknown-type>";
						break;
					}
				}
				catch (Exception ex)
				{
					arg = "<read-failed: " + ex.GetType().Name + ">";
				}
				WriteAll($"[MatDump]   prop.{propertyName}={propertyType}:{arg}");
			}
			if (ReplacementCore._replacedMats.TryGetValue(instanceID, out (string, ShaderAction) value))
			{
				WriteAll($"[MatDump]   Replacement.ReplacementCore._replacedMats=original='{value.Item1}' action={value.Item2}");
			}
			if (ReplacementCore._cachedShaderIdByMat.TryGetValue(instanceID, out var value2) && ReplacementCore._cacheEpochByMat.TryGetValue(instanceID, out var value3))
			{
				WriteAll($"[MatDump]   cached=(shaderId={value2}, epoch={value3})  currentEpoch={ReplacementCore._admissionEpoch}");
			}
			WriteAll("[MatDump]   gate=" + (flag7 ? "PASS" : "FAIL") + $" (nameInBaseline={flag2}, shaderVanillaByName={flag3}, shaderCanonicalById={flag4}, prefabScopeOverride={flag6})");
			void WriteAll(string line)
			{
				foreach (Action<string> sink in sinks)
				{
					sink(line);
				}
			}
		}

		private static ParsedMatDump? ParseMatDumpFile(string path, out string? errorMsg)
		{
			errorMsg = null;
			if (!File.Exists(path))
			{
				errorMsg = "file not found: " + path;
				return null;
			}
			string[] array;
			try
			{
				array = File.ReadAllLines(path);
			}
			catch (Exception ex)
			{
				errorMsg = "read failed (" + ex.GetType().Name + "): " + ex.Message;
				return null;
			}
			ParsedMatDump parsedMatDump = new ParsedMatDump();
			bool flag = false;
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (text == null)
				{
					continue;
				}
				string text2 = StripLogPrefix(text);
				if (text2.StartsWith("[MatDump] mat=", StringComparison.Ordinal))
				{
					parsedMatDump.BlocksSeen++;
					if (!flag)
					{
						flag = true;
						parsedMatDump.MatName = ExtractQuoted(text2, "mat=") ?? parsedMatDump.MatName;
						parsedMatDump.ShaderName = ExtractQuoted(text2, "shader=") ?? parsedMatDump.ShaderName;
						parsedMatDump.RenderQueue = (int)ExtractNumeric(text2, "renderQueue=");
						parsedMatDump.PassCount = (int)ExtractNumeric(text2, "passCount=");
						parsedMatDump.Supported = ExtractBool(text2, "supported=");
						parsedMatDump.Canonical = ExtractBool(text2, "canonical=");
					}
				}
				else
				{
					if (!flag)
					{
						continue;
					}
					if (text2.StartsWith("[MatDump]   keywords=", StringComparison.Ordinal))
					{
						string text3 = text2.Substring("[MatDump]   keywords=".Length);
						if (!(text3 != "<none>"))
						{
							continue;
						}
						string[] array3 = text3.Split(new char[1] { '|' });
						foreach (string text4 in array3)
						{
							string text5 = text4.Trim();
							if (text5.Length > 0)
							{
								parsedMatDump.Keywords.Add(text5);
							}
						}
					}
					else if (text2.StartsWith("[MatDump]   prop.", StringComparison.Ordinal))
					{
						string text6 = text2.Substring("[MatDump]   prop.".Length);
						int num = text6.IndexOf('=');
						if (num > 0)
						{
							string key = text6.Substring(0, num);
							string value = text6.Substring(num + 1);
							if (!parsedMatDump.Props.ContainsKey(key))
							{
								parsedMatDump.Props[key] = value;
							}
						}
					}
					else if (text2.StartsWith("[MatDump]   Replacement.ReplacementCore._replacedMats=", StringComparison.Ordinal))
					{
						parsedMatDump.ReplacedMats = text2.Substring("[MatDump]   Replacement.ReplacementCore._replacedMats=".Length);
					}
					else if (text2.StartsWith("[MatDump]   cached=", StringComparison.Ordinal))
					{
						parsedMatDump.Cached = text2.Substring("[MatDump]   cached=".Length);
					}
					else if (text2.StartsWith("[MatDump]   gate=", StringComparison.Ordinal))
					{
						parsedMatDump.Gate = text2.Substring("[MatDump]   gate=".Length);
					}
				}
			}
			if (!flag)
			{
				errorMsg = "no [MatDump] header found in " + path;
				return null;
			}
			return parsedMatDump;
			static string StripLogPrefix(string line)
			{
				int num2 = line.IndexOf('[');
				int num3 = line.IndexOf(']');
				if (num2 == 0 && num3 > 0 && num3 < line.Length - 2 && line.IndexOf(':', num2, num3 - num2) > 0)
				{
					int k;
					for (k = num3 + 1; k < line.Length && line[k] == ' '; k++)
					{
					}
					return line.Substring(k);
				}
				return line;
			}
		}

		private static string? ExtractQuoted(string line, string key)
		{
			int num = line.IndexOf(key, StringComparison.Ordinal);
			if (num < 0)
			{
				return null;
			}
			num += key.Length;
			if (num >= line.Length || line[num] != '\'')
			{
				return null;
			}
			int num2 = line.IndexOf('\'', num + 1);
			if (num2 < 0)
			{
				return null;
			}
			return line.Substring(num + 1, num2 - num - 1);
		}

		private static double ExtractNumeric(string line, string key)
		{
			int num = line.IndexOf(key, StringComparison.Ordinal);
			if (num < 0)
			{
				return 0.0;
			}
			num += key.Length;
			int i;
			for (i = num; i < line.Length && (char.IsDigit(line[i]) || line[i] == '-' || line[i] == '.'); i++)
			{
			}
			if (i == num)
			{
				return 0.0;
			}
			double.TryParse(line.Substring(num, i - num), NumberStyles.Float, CultureInfo.InvariantCulture, out var result);
			return result;
		}

		private static bool ExtractBool(string line, string key)
		{
			int num = line.IndexOf(key, StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			num += key.Length;
			int i;
			for (i = num; i < line.Length && char.IsLetter(line[i]); i++)
			{
			}
			return i > num && line.Substring(num, i - num).Equals("True", StringComparison.OrdinalIgnoreCase);
		}

		internal static string RunMatDumpDiff(string labelA, string labelB)
		{
			string text = SanitizeMatDumpLabel(labelA);
			string text2 = SanitizeMatDumpLabel(labelB);
			string path = Path.Combine(Plugin.ConfigDir, "matdump");
			string path2 = Path.Combine(path, text + ".txt");
			string path3 = Path.Combine(path, text2 + ".txt");
			string errorMsg;
			ParsedMatDump parsedMatDump = ParseMatDumpFile(path2, out errorMsg);
			if (parsedMatDump == null)
			{
				Plugin.Log.LogWarning((object)("[MatDump-diff] failed to load labelA='" + labelA + "' (" + errorMsg + ")"));
				return "ShaderHelperForMac: matdump --diff — failed to load '" + labelA + "': " + errorMsg;
			}
			string errorMsg2;
			ParsedMatDump parsedMatDump2 = ParseMatDumpFile(path3, out errorMsg2);
			if (parsedMatDump2 == null)
			{
				Plugin.Log.LogWarning((object)("[MatDump-diff] failed to load labelB='" + labelB + "' (" + errorMsg2 + ")"));
				return "ShaderHelperForMac: matdump --diff — failed to load '" + labelB + "': " + errorMsg2;
			}
			Plugin.Log.LogInfo((object)("[MatDump-diff] A='" + text + "' B='" + text2 + "'  matA='" + parsedMatDump.MatName + "' shaderA='" + parsedMatDump.ShaderName + "'  matB='" + parsedMatDump2.MatName + "' shaderB='" + parsedMatDump2.ShaderName + "'"));
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			foreach (string keyword in parsedMatDump.Keywords)
			{
				if (!parsedMatDump2.Keywords.Contains(keyword))
				{
					list.Add(keyword);
				}
			}
			foreach (string keyword2 in parsedMatDump2.Keywords)
			{
				if (!parsedMatDump.Keywords.Contains(keyword2))
				{
					list2.Add(keyword2);
				}
			}
			if (list.Count > 0 || list2.Count > 0)
			{
				list.Sort(StringComparer.Ordinal);
				list2.Sort(StringComparer.Ordinal);
				num = list.Count + list2.Count;
				Plugin.Log.LogInfo((object)("[MatDump-diff]   keywords: A_only=[" + string.Join(",", list) + "]  B_only=[" + string.Join(",", list2) + "]"));
			}
			SortedSet<string> sortedSet = new SortedSet<string>(StringComparer.Ordinal);
			foreach (string key in parsedMatDump.Props.Keys)
			{
				sortedSet.Add(key);
			}
			foreach (string key2 in parsedMatDump2.Props.Keys)
			{
				sortedSet.Add(key2);
			}
			foreach (string item in sortedSet)
			{
				string value;
				bool flag = parsedMatDump.Props.TryGetValue(item, out value);
				string value2;
				bool flag2 = parsedMatDump2.Props.TryGetValue(item, out value2);
				if (flag && flag2)
				{
					if (!string.Equals(value, value2, StringComparison.Ordinal))
					{
						Plugin.Log.LogInfo((object)("[MatDump-diff]   prop." + item + ": A='" + value + "' B='" + value2 + "'"));
						num2++;
					}
				}
				else if (flag)
				{
					Plugin.Log.LogInfo((object)("[MatDump-diff]   prop." + item + ": A='" + value + "' B=<absent>"));
					num2++;
				}
				else if (flag2)
				{
					Plugin.Log.LogInfo((object)("[MatDump-diff]   prop." + item + ": A=<absent> B='" + value2 + "'"));
					num2++;
				}
			}
			if (parsedMatDump.RenderQueue != parsedMatDump2.RenderQueue)
			{
				Plugin.Log.LogInfo((object)$"[MatDump-diff]   renderQueue: A={parsedMatDump.RenderQueue} B={parsedMatDump2.RenderQueue}");
				num3++;
			}
			if (parsedMatDump.PassCount != parsedMatDump2.PassCount)
			{
				Plugin.Log.LogInfo((object)$"[MatDump-diff]   passCount: A={parsedMatDump.PassCount} B={parsedMatDump2.PassCount}");
				num3++;
			}
			if (parsedMatDump.Supported != parsedMatDump2.Supported)
			{
				Plugin.Log.LogInfo((object)$"[MatDump-diff]   supported: A={parsedMatDump.Supported} B={parsedMatDump2.Supported}");
				num3++;
			}
			if (parsedMatDump.Canonical != parsedMatDump2.Canonical)
			{
				Plugin.Log.LogInfo((object)$"[MatDump-diff]   canonical: A={parsedMatDump.Canonical} B={parsedMatDump2.Canonical}");
				num3++;
			}
			if (!string.Equals(parsedMatDump.ReplacedMats, parsedMatDump2.ReplacedMats, StringComparison.Ordinal))
			{
				Plugin.Log.LogInfo((object)("[MatDump-diff]   Replacement.ReplacementCore._replacedMats: A='" + (parsedMatDump.ReplacedMats ?? "<absent>") + "' B='" + (parsedMatDump2.ReplacedMats ?? "<absent>") + "'"));
				num3++;
			}
			if (!string.Equals(parsedMatDump.Cached, parsedMatDump2.Cached, StringComparison.Ordinal))
			{
				Plugin.Log.LogInfo((object)("[MatDump-diff]   cached: A='" + (parsedMatDump.Cached ?? "<absent>") + "' B='" + (parsedMatDump2.Cached ?? "<absent>") + "'"));
				num3++;
			}
			if (!string.Equals(parsedMatDump.Gate, parsedMatDump2.Gate, StringComparison.Ordinal))
			{
				Plugin.Log.LogInfo((object)("[MatDump-diff]   gate: A='" + (parsedMatDump.Gate ?? "<absent>") + "' B='" + (parsedMatDump2.Gate ?? "<absent>") + "'"));
				num3++;
			}
			Plugin.Log.LogInfo((object)$"[MatDump-diff] summary: keywordDiff={num} propDiff={num2} metadataDiff={num3}");
			if (num == 0 && num2 == 0 && num3 == 0)
			{
				return "ShaderHelperForMac: matdump --diff '" + text + "' '" + text2 + "' — NO differences found. See BepInEx/LogOutput.log for [MatDump-diff] lines.";
			}
			return $"ShaderHelperForMac: matdump --diff '{text}' '{text2}' — {num} keyword diff(s), {num2} property diff(s), {num3} metadata diff(s). See BepInEx/LogOutput.log for [MatDump-diff] lines.";
		}

		internal static void DumpMatPropertiesIfTargeted(Material mat, string label)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected I4, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null || (Object)(object)mat.shader == (Object)null)
			{
				return;
			}
			string text = ((Object)mat).name ?? "";
			bool flag = false;
			string[] dumpTargets = _dumpTargets;
			foreach (string value in dumpTargets)
			{
				if (text.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return;
			}
			Shader shader = mat.shader;
			int propertyCount = shader.GetPropertyCount();
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append($"[MatDump {label}] mat='{((Object)mat).name}' shader='{((Object)shader).name}' props={propertyCount}");
			for (int j = 0; j < propertyCount; j++)
			{
				string propertyName = shader.GetPropertyName(j);
				ShaderPropertyType propertyType = shader.GetPropertyType(j);
				stringBuilder.Append("  ").Append(propertyName).Append('=')
					.Append(propertyType)
					.Append(':');
				ShaderPropertyType val = propertyType;
				ShaderPropertyType val2 = val;
				switch ((int)val2)
				{
				case 4:
				{
					Texture texture = mat.GetTexture(propertyName);
					stringBuilder.Append(((Object)(object)texture == (Object)null) ? "<null>" : ((Object)texture).name);
					break;
				}
				case 0:
					stringBuilder.Append(((object)mat.GetColor(propertyName)/*cast due to .constrained prefix*/).ToString());
					break;
				case 2:
				case 3:
					stringBuilder.Append(mat.GetFloat(propertyName).ToString("0.###"));
					break;
				case 1:
					stringBuilder.Append(((object)mat.GetVector(propertyName)/*cast due to .constrained prefix*/).ToString());
					break;
				default:
					stringBuilder.Append("?");
					break;
				}
			}
			Plugin.Log.LogInfo((object)stringBuilder.ToString());
		}
	}
}
namespace ShaderHelperForMac.Config
{
	internal static class ConfigLoader
	{
		internal sealed class ConfigSnapshot
		{
			public readonly HashSet<string> UseTransparentDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> UseFallbackDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> UseOriginalDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> TransparentMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> FallbackMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> OriginalMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly List<string> TransparentMatSuffixes = new List<string>();

			public readonly List<string> FallbackMatSuffixes = new List<string>();

			public readonly HashSet<string> ForceFallbackMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly List<string> ForceFallbackMatSuffixes = new List<string>();

			public readonly HashSet<string> ForceTransparentMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly List<string> ForceTransparentMatSuffixes = new List<string>();

			public readonly HashSet<string> ForceFallbackPrefixSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> ForceTransparentPrefixSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, string> MatShaderOverrides = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, List<(string prop, string value)>> MatShaderPropertyOverrides = new Dictionary<string, List<(string, string)>>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, List<(string keyword, bool enable)>> MatShaderKeywordOverrides = new Dictionary<string, List<(string, bool)>>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> ModPrefabRootNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> HardRuleNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> HideRendererMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly List<string> HideRendererMatSuffixes = new List<string>();

			public readonly Dictionary<string, HashSet<string>> MatNameToOwningTxts = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);
		}

		private static List<string> TokenizeUseShaderEntry(string entry)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(entry))
			{
				return list;
			}
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			bool flag2 = false;
			foreach (char c in entry)
			{
				if (c == '"')
				{
					flag = !flag;
					flag2 = true;
				}
				else if (!flag && (c == ' ' || c == '\t'))
				{
					if (flag2)
					{
						list.Add(stringBuilder.ToString());
						stringBuilder.Clear();
						flag2 = false;
					}
				}
				else
				{
					stringBuilder.Append(c);
					flag2 = true;
				}
			}
			if (flag2)
			{
				list.Add(stringBuilder.ToString());
			}
			if (flag)
			{
				Plugin.Log.LogWarning((object)("[useshader] entry '" + entry + "': unterminated double-quoted span — closing quote missing. The partial token was taken as-is; fix the trailing quote in the per-mod txt and re-reload."));
			}
			return list;
		}

		internal static void EnsureConfigFiles()
		{
			Directory.CreateDirectory(Plugin.ConfigDir);
			string path = Path.Combine(Plugin.ConfigDir, Plugin.UseTransparentShaderFile);
			if (!File.Exists(path))
			{
				File.WriteAllText(path, "# Materials made transparent (invisible) by ShaderHelperForMac.\n# Three line formats (all case-insensitive, one per line):\n#\n#   DllName              — all unsupported materials from this mod DLL\n#   mat:MaterialName     — one specific material by exact name\n#   suffix:TW            — all materials whose name ends with this suffix\n#\n# Examples:\n# mat:smoke_TW\n# suffix:_vfx\n# DarkWoodFurnitures\n#\n");
			}
			string path2 = Path.Combine(Plugin.ConfigDir, Plugin.UseFallbackShaderFile);
			if (!File.Exists(path2))
			{
				File.WriteAllText(path2, "# Materials given the fallback shader by ShaderHelperForMac.\n# Three line formats (all case-insensitive, one per line):\n#\n#   DllName              — all unsupported materials from this mod DLL\n#   mat:MaterialName     — one specific material by exact name\n#   suffix:TW            — all materials whose name ends with this suffix\n#\n# Examples:\n# suffix:TW\n# mat:rocksTW\n# Warfare\n#\n");
			}
			string path3 = Path.Combine(Plugin.ConfigDir, Plugin.UseOriginalShaderFile);
			if (!File.Exists(path3))
			{
				File.WriteAllText(path3, "# Mods listed here will be left completely untouched (shaders not changed).\n# Use when a per-mod config defaults the mod to fallback or transparent\n# but you want this specific install left as-is.\n#\n# One DLL name per line (without the .dll extension), case-insensitive.\n# Lines starting with # are comments.\n#\n");
			}
		}

		internal static int IndexOfInlineComment(string line)
		{
			for (int i = 1; i < line.Length; i++)
			{
				if (line[i] == '#')
				{
					char c = line[i - 1];
					if (c == ' ' || c == '\t')
					{
						return i - 1;
					}
				}
			}
			return -1;
		}

		internal static string StripSurroundingQuotes(string token)
		{
			if (token.Length >= 2 && token[0] == '"' && token[token.Length - 1] == '"')
			{
				return token.Substring(1, token.Length - 2);
			}
			return token;
		}

		internal static void ParseRuleLine(string line, HashSet<string> dlls, HashSet<string> matNames, List<string> matSuffixes)
		{
			int num = IndexOfInlineComment(line);
			if (num >= 0)
			{
				line = line.Substring(0, num).TrimEnd(Array.Empty<char>());
			}
			if (line.Length != 0)
			{
				if (line.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
				{
					matNames.Add(StripSurroundingQuotes(line.Substring(4).Trim()));
				}
				else if (line.StartsWith("suffix:", StringComparison.OrdinalIgnoreCase))
				{
					matSuffixes.Add(StripSurroundingQuotes(line.Substring(7).Trim()));
				}
				else
				{
					dlls.Add(line);
				}
			}
		}

		internal static void ParseForceRuleLine(string line, HashSet<string> prefixSet, HashSet<string> forceMatNames, List<string> forceMatSuffixes)
		{
			int num = IndexOfInlineComment(line);
			if (num >= 0)
			{
				line = line.Substring(0, num).TrimEnd(Array.Empty<char>());
			}
			if (line.Length != 0)
			{
				if (line.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
				{
					forceMatNames.Add(StripSurroundingQuotes(line.Substring(4).Trim()));
				}
				else if (line.StartsWith("suffix:", StringComparison.OrdinalIgnoreCase))
				{
					forceMatSuffixes.Add(StripSurroundingQuotes(line.Substring(7).Trim()));
				}
				else
				{
					prefixSet.Add(line);
				}
			}
		}

		internal static void LoadConfigFile(string filename, HashSet<string> dlls, HashSet<string> matNames, List<string> matSuffixes)
		{
			string path = Path.Combine(Plugin.ConfigDir, filename);
			if (!File.Exists(path))
			{
				return;
			}
			string[] array = File.ReadAllLines(path);
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.Length != 0 && !text2.StartsWith("#"))
				{
					ParseRuleLine(text2, dlls, matNames, matSuffixes);
				}
			}
		}

		internal static void LoadConfigFileInto(string filename, HashSet<string> dlls, HashSet<string> matNames, List<string> matSuffixes)
		{
			string path = Path.Combine(Plugin.ConfigDir, filename);
			if (!File.Exists(path))
			{
				return;
			}
			string[] array = File.ReadAllLines(path);
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.Length != 0 && !text2.StartsWith("#"))
				{
					ParseRuleLine(text2, dlls, matNames, matSuffixes);
				}
			}
		}

		internal static void LoadModFileInto(string filePath, ConfigSnapshot snap)
		{
			string dllName = Path.GetFileNameWithoutExtension(filePath);
			string text = string.Empty;
			string[] array = File.ReadAllLines(filePath);
			foreach (string text2 in array)
			{
				string text3 = text2.Trim();
				if (text3.Length == 0 || text3.StartsWith("#"))
				{
					continue;
				}
				if (text3.StartsWith("[") && text3.EndsWith("]"))
				{
					text = text3.Substring(1, text3.Length - 2).ToLowerInvariant();
					continue;
				}
				switch (text)
				{
				case "default":
					if (text3.Equals("fallback", StringComparison.OrdinalIgnoreCase))
					{
						snap.UseFallbackDlls.Add(dllName);
					}
					else if (text3.Equals("transparent", StringComparison.OrdinalIgnoreCase))
					{
						snap.UseTransparentDlls.Add(dllName);
					}
					else if (text3.Equals("original", StringComparison.OrdinalIgnoreCase))
					{
						snap.UseOriginalDlls.Add(dllName);
					}
					break;
				case "fallback":
					ParseRuleLine(text3, snap.UseFallbackDlls, snap.FallbackMatNames, snap.FallbackMatSuffixes);
					if (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						int num2 = IndexOfInlineComment(text3);
						string text5 = ((num2 >= 0) ? text3.Substring(0, num2).TrimEnd(Array.Empty<char>()) : text3);
						TrackOwningTxt(StripSurroundingQuotes(text5.Substring(4).Trim()));
					}
					break;
				case "transparent":
					ParseRuleLine(text3, snap.UseTransparentDlls, snap.TransparentMatNames, snap.TransparentMatSuffixes);
					if (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						int num7 = IndexOfInlineComment(text3);
						string text16 = ((num7 >= 0) ? text3.Substring(0, num7).TrimEnd(Array.Empty<char>()) : text3);
						TrackOwningTxt(StripSurroundingQuotes(text16.Substring(4).Trim()));
					}
					break;
				case "original":
					if (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						string text8 = StripSurroundingQuotes(text3.Substring(4).Trim());
						snap.OriginalMatNames.Add(text8);
						TrackOwningTxt(text8);
					}
					else if (!text3.StartsWith("suffix:", StringComparison.OrdinalIgnoreCase))
					{
						snap.UseOriginalDlls.Add(text3);
					}
					break;
				case "forcefallback":
					ParseForceRuleLine(text3, snap.ForceFallbackPrefixSet, snap.ForceFallbackMatNames, snap.ForceFallbackMatSuffixes);
					if (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						int num3 = IndexOfInlineComment(text3);
						string text6 = ((num3 >= 0) ? text3.Substring(0, num3).TrimEnd(Array.Empty<char>()) : text3);
						string text7 = StripSurroundingQuotes(text6.Substring(4).Trim());
						snap.HardRuleNames.Add(text7);
						TrackOwningTxt(text7);
					}
					break;
				case "forcetransparent":
					ParseForceRuleLine(text3, snap.ForceTransparentPrefixSet, snap.ForceTransparentMatNames, snap.ForceTransparentMatSuffixes);
					if (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						int num4 = IndexOfInlineComment(text3);
						string text9 = ((num4 >= 0) ? text3.Substring(0, num4).TrimEnd(Array.Empty<char>()) : text3);
						string text10 = StripSurroundingQuotes(text9.Substring(4).Trim());
						snap.HardRuleNames.Add(text10);
						TrackOwningTxt(text10);
					}
					break;
				case "useshader":
				{
					int num5 = IndexOfInlineComment(text3);
					if (num5 >= 0)
					{
						text3 = text3.Substring(0, num5).TrimEnd(Array.Empty<char>());
					}
					if (text3.Length == 0)
					{
						break;
					}
					string entry = (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase) ? text3.Substring(4).Trim() : text3);
					List<string> list = TokenizeUseShaderEntry(entry);
					if (list.Count < 2)
					{
						break;
					}
					string text11 = list[0].Trim();
					string text12 = list[1].Trim();
					if (text11.Length <= 0 || text12.Length <= 0)
					{
						break;
					}
					snap.MatShaderOverrides[text11] = text12;
					snap.HardRuleNames.Add(text11);
					TrackOwningTxt(text11);
					if (list.Count <= 2)
					{
						break;
					}
					List<(string, string)> list2 = new List<(string, string)>();
					List<(string, bool)> list3 = new List<(string, bool)>();
					for (int j = 2; j < list.Count; j++)
					{
						string text13 = list[j];
						int num6 = text13.IndexOf('=');
						if (num6 <= 0 || num6 == text13.Length - 1)
						{
							Plugin.Log.LogWarning((object)("[useshader] mat:" + text11 + " on shader '" + text12 + "': malformed token '" + text13 + "' (expected `_PropertyName=Value` or `_KEYWORD=on/off`) — skipped."));
							continue;
						}
						string text14 = text13.Substring(0, num6).Trim();
						string text15 = text13.Substring(num6 + 1).Trim();
						if (text14.Length == 0 || text15.Length == 0)
						{
							Plugin.Log.LogWarning((object)("[useshader] mat:" + text11 + " on shader '" + text12 + "': empty name or value in token '" + text13 + "' — skipped."));
						}
						else if (text15.Equals("on", StringComparison.OrdinalIgnoreCase))
						{
							list3.Add((text14, true));
						}
						else if (text15.Equals("off", StringComparison.OrdinalIgnoreCase))
						{
							list3.Add((text14, false));
						}
						else
						{
							list2.Add((text14, text15));
						}
					}
					if (list2.Count > 0)
					{
						snap.MatShaderPropertyOverrides[text11] = list2;
					}
					if (list3.Count > 0)
					{
						snap.MatShaderKeywordOverrides[text11] = list3;
					}
					break;
				}
				case "prefab":
				{
					int num8 = IndexOfInlineComment(text3);
					string text17 = ((num8 >= 0) ? text3.Substring(0, num8) : text3).Trim();
					if (text17.Length > 0)
					{
						snap.ModPrefabRootNames.Add(text17);
					}
					break;
				}
				case "hiderenderer":
				{
					int num = IndexOfInlineComment(text3);
					string text4 = ((num >= 0) ? text3.Substring(0, num) : text3).TrimEnd(Array.Empty<char>());
					if (text4.Length != 0)
					{
						if (text4.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
						{
							snap.HideRendererMatNames.Add(text4.Substring(4).Trim());
						}
						else if (text4.StartsWith("suffix:", StringComparison.OrdinalIgnoreCase))
						{
							snap.HideRendererMatSuffixes.Add(text4.Substring(7).Trim());
						}
					}
					break;
				}
				}
			}
			void TrackOwningTxt(string matName)
			{
				if (!string.IsNullOrEmpty(matName))
				{
					if (!snap.MatNameToOwningTxts.TryGetValue(matName, out HashSet<string> value))
					{
						value = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
						snap.MatNameToOwningTxts[matName] = value;
					}
					value.Add(dllName);
				}
			}
		}

		internal static void LoadModFile(string filePath)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
			string text = string.Empty;
			string[] array = File.ReadAllLines(filePath);
			foreach (string text2 in array)
			{
				string text3 = text2.Trim();
				if (text3.Length == 0 || text3.StartsWith("#"))
				{
					continue;
				}
				if (text3.StartsWith("[") && text3.EndsWith("]"))
				{
					text = text3.Substring(1, text3.Length - 2).ToLowerInvariant();
					continue;
				}
				switch (text)
				{
				case "default":
					if (text3.Equals("fallback", StringComparison.OrdinalIgnoreCase))
					{
						Plugin._useFallbackDlls.Add(fileNameWithoutExtension);
					}
					else if (text3.Equals("transparent", StringComparison.OrdinalIgnoreCase))
					{
						Plugin._useTransparentDlls.Add(fileNameWithoutExtension);
					}
					else if (text3.Equals("original", StringComparison.OrdinalIgnoreCase))
					{
						Plugin._useOriginalDlls.Add(fileNameWithoutExtension);
					}
					break;
				case "fallback":
					ParseRuleLine(text3, Plugin._useFallbackDlls, Plugin._fallbackMatNames, Plugin._fallbackMatSuffixes);
					break;
				case "transparent":
					ParseRuleLine(text3, Plugin._useTransparentDlls, Plugin._transparentMatNames, Plugin._transparentMatSuffixes);
					break;
				case "original":
					if (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						Plugin._originalMatNames.Add(text3.Substring(4).Trim());
					}
					else if (!text3.StartsWith("suffix:", StringComparison.OrdinalIgnoreCase))
					{
						Plugin._useOriginalDlls.Add(text3);
					}
					break;
				case "forcefallback":
					ParseForceRuleLine(text3, Plugin._forceFallbackPrefixSet, Plugin._forceFallbackMatNames, Plugin._forceFallbackMatSuffixes);
					break;
				case "forcetransparent":
					ParseForceRuleLine(text3, Plugin._forceTransparentPrefixSet, Plugin._forceTransparentMatNames, Plugin._forceTransparentMatSuffixes);
					break;
				case "useshader":
				{
					string text5 = (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase) ? text3.Substring(4).Trim() : text3);
					string[] array2 = text5.Split(new char[2] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
					if (array2.Length >= 2)
					{
						string text6 = array2[0].Trim();
						string text7 = array2[1].Trim();
						if (text6.Length > 0 && text7.Length > 0)
						{
							Plugin._matShaderOverrides[text6] = text7;
						}
					}
					break;
				}
				case "prefab":
				{
					int num = IndexOfInlineComment(text3);
					string text4 = ((num >= 0) ? text3.Substring(0, num) : text3).Trim();
					if (text4.Length > 0)
					{
						Plugin._modPrefabRootNames.Add(text4);
					}
					break;
				}
				}
			}
		}

		internal static void ReloadConfigFiles()
		{
			ConfigSnapshot configSnapshot = new ConfigSnapshot();
			configSnapshot.ForceTransparentPrefixSet.Add("Legacy Shaders/Particles/");
			LoadConfigFileInto(Plugin.UseTransparentShaderFile, configSnapshot.UseTransparentDlls, configSnapshot.TransparentMatNames, configSnapshot.TransparentMatSuffixes);
			LoadConfigFileInto(Plugin.UseFallbackShaderFile, configSnapshot.UseFallbackDlls, configSnapshot.FallbackMatNames, configSnapshot.FallbackMatSuffixes);
			HashSet<string> matNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			List<string> matSuffixes = new List<string>();
			LoadConfigFileInto(Plugin.UseOriginalShaderFile, configSnapshot.UseOriginalDlls, matNames, matSuffixes);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
			{
				Plugin.UseTransparentShaderFile,
				Plugin.UseFallbackShaderFile,
				Plugin.UseOriginalShaderFile
			};
			string[] files = Directory.GetFiles(Plugin.ConfigDir, "*.txt");
			foreach (string text in files)
			{
				if (!hashSet.Contains(Path.GetFileName(text)))
				{
					LoadModFileInto(text, configSnapshot);
				}
			}
			SortedSet<string> vetoedNames = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string fallbackMatName in configSnapshot.FallbackMatNames)
			{
				PromoteIfNonVanilla(fallbackMatName);
			}
			foreach (string transparentMatName in configSnapshot.TransparentMatNames)
			{
				PromoteIfNonVanilla(transparentMatName);
			}
			foreach (string originalMatName in configSnapshot.OriginalMatNames)
			{
				PromoteIfNonVanilla(originalMatName);
			}
			foreach (string forceFallbackMatName in configSnapshot.ForceFallbackMatNames)
			{
				PromoteIfNonVanilla(forceFallbackMatName);
			}
			foreach (string forceTransparentMatName in configSnapshot.ForceTransparentMatNames)
			{
				PromoteIfNonVanilla(forceTransparentMatName);
			}
			foreach (string key in configSnapshot.MatShaderOverrides.Keys)
			{
				PromoteIfNonVanilla(key);
			}
			Plugin._useTransparentDlls = configSnapshot.UseTransparentDlls;
			Plugin._useFallbackDlls = configSnapshot.UseFallbackDlls;
			Plugin._useOriginalDlls = configSnapshot.UseOriginalDlls;
			Plugin._transparentMatNames = configSnapshot.TransparentMatNames;
			Plugin._fallbackMatNames = configSnapshot.FallbackMatNames;
			Plugin._originalMatNames = configSnapshot.OriginalMatNames;
			Plugin._transparentMatSuffixes = configSnapshot.TransparentMatSuffixes;
			Plugin._fallbackMatSuffixes = configSnapshot.FallbackMatSuffixes;
			Plugin._forceFallbackMatNames = configSnapshot.ForceFallbackMatNames;
			Plugin._forceFallbackMatSuffixes = configSnapshot.ForceFallbackMatSuffixes;
			Plugin._forceTransparentMatNames = configSnapshot.ForceTransparentMatNames;
			Plugin._forceTransparentMatSuffixes = configSnapshot.ForceTransparentMatSuffixes;
			Plugin._forceFallbackPrefixSet = configSnapshot.ForceFallbackPrefixSet;
			Plugin._forceTransparentPrefixSet = configSnapshot.ForceTransparentPrefixSet;
			Plugin._matShaderOverrides = configSnapshot.MatShaderOverrides;
			Plugin._matShaderPropertyOverrides = configSnapshot.MatShaderPropertyOverrides;
			Plugin._matShaderKeywordOverrides = configSnapshot.MatShaderKeywordOverrides;
			Plugin._hideRendererMatNames = configSnapshot.HideRendererMatNames;
			Plugin._hideRendererMatSuffixes = configSnapshot.HideRendererMatSuffixes;
			lock (Plugin._modPrefabRootNames)
			{
				Plugin._modPrefabRootNames.Clear();
				foreach (string modPrefabRootName in configSnapshot.ModPrefabRootNames)
				{
					Plugin._modPrefabRootNames.Add(modPrefabRootName);
				}
			}
			Plugin._prefabScopedModMatIds.Clear();
			ReplacementCore._processedMaterialIds.Clear();
			ReplacementCore._cachedShaderIdByMat.Clear();
			ReplacementCore._cacheEpochByMat.Clear();
			int count = vetoedNames.Count;
			if (count > 0)
			{
				int num = 0;
				int num2 = 0;
				foreach (string item in vetoedNames)
				{
					if (configSnapshot.HardRuleNames.Contains(item))
					{
						num++;
					}
					else
					{
						num2++;
					}
				}
				Plugin.Log.LogInfo((object)$"Config: vetoed {count} vanilla-name rule(s) ({num} hard-rule veto(s) still firing via IsHardMatRule; {num2} soft-rule veto(s) inert).");
				if (num2 > 0)
				{
					Plugin.Log.LogInfo((object)"Config: soft-rule remediation: add `[prefab] <RootName>` to the rule's .txt file so it fires only inside that prefab's renderer hierarchy.");
					Plugin.Log.LogInfo((object)"Config:   To DISCOVER candidate <RootName> values for a mod:");
					Plugin.Log.LogInfo((object)"Config:     • `shaderhelper dumpprefabmap`           — every mod with prefab roots attributed");
					Plugin.Log.LogInfo((object)"Config:     • `shaderhelper modprefabs <ModName>`    — every prefab root attributed to one mod (DLL or BepInEx folder name)");
					Plugin.Log.LogInfo((object)"Config:   Or delete the rule entirely if it targeted a vanilla material by mistake.");
				}
				foreach (string item2 in vetoedNames)
				{
					string text2 = "";
					if (configSnapshot.MatNameToOwningTxts.TryGetValue(item2, out HashSet<string> value) && value.Count > 0)
					{
						List<string> list = new List<string>(value);
						list.Sort(StringComparer.OrdinalIgnoreCase);
						StringBuilder stringBuilder = new StringBuilder();
						for (int j = 0; j < list.Count; j++)
						{
							if (j > 0)
							{
								stringBuilder.Append(", ");
							}
							stringBuilder.Append(list[j]).Append(".txt");
						}
						text2 = $"  (declared in: {stringBuilder})";
					}
					if (configSnapshot.HardRuleNames.Contains(item2))
					{
						Plugin.Log.LogInfo((object)("  [Vetoed-hard]  mat:" + item2 + text2 + "  (vanilla-name collision on HARD rule — still fires at sweep time via IsHardMatRule, this log line is FYI only; rule is live)"));
					}
					else
					{
						Plugin.Log.LogInfo((object)("  [Vetoed-soft]  mat:" + item2 + text2 + "  (vanilla-name collision on SOFT rule — rule is INERT; add `[prefab] <Root>` to scope via Lane 5 or delete the rule; see remediation lines above)"));
					}
				}
			}
			Plugin.Log.LogDebug((object)($"Config loaded: {Plugin._useTransparentDlls.Count} transparent, {Plugin._useFallbackDlls.Count} fallback, {Plugin._useOriginalDlls.Count} original DLL(s); " + $"{Plugin._transparentMatNames.Count + Plugin._transparentMatSuffixes.Count} transparent mat rule(s), " + $"{Plugin._fallbackMatNames.Count + Plugin._fallbackMatSuffixes.Count} fallback mat rule(s); " + $"{Plugin._forceTransparentMatNames.Count + Plugin._forceTransparentMatSuffixes.Count} force-transparent mat rule(s), " + $"{Plugin._forceFallbackMatNames.Count + Plugin._forceFallbackMatSuffixes.Count} force-fallback mat rule(s); " + $"{Plugin._forceFallbackPrefixSet.Count} force-fallback prefix(es), {Plugin._forceTransparentPrefixSet.Count} force-transparent prefix(es); " + $"{Plugin._matShaderOverrides.Count} useshader override(s), " + $"{Plugin._matShaderPropertyOverrides.Count} property-override mat(s), " + $"{Plugin._matShaderKeywordOverrides.Count} keyword-override mat(s)."));
			foreach (KeyValuePair<string, string> matShaderOverride in Plugin._matShaderOverrides)
			{
				Plugin.Log.LogDebug((object)("  [useshader]  mat:" + matShaderOverride.Key + "  →  " + matShaderOverride.Value));
			}
			int num3 = Plugin._hideRendererMatNames.Count + Plugin._hideRendererMatSuffixes.Count;
			if (num3 > 0 && Plugin._modPrefabRootNames.Count == 0)
			{
				Plugin.Log.LogWarning((object)$"Config: {num3} [hiderenderer] rule(s) loaded but no [prefab] declared — rules are INERT. Add at least one `[prefab] <ModRootName>` line to scope them via Lane 5; without that, the Lane-5 ancestor check can never match and no renderer will be disabled.");
			}
			ReplacementCore.BumpAdmissionEpoch("ReloadConfigFiles");
			Plugin._forceNextPeriodicSweep = true;
			Plugin._consecutiveSweepSkips = 0;
			void PromoteIfNonVanilla(string n)
			{
				if (Plugin._baselineMatNames.Contains(n))
				{
					vetoedNames.Add(n);
				}
			}
		}
	}
	internal static class PatchBatch
	{
		internal const string PatchMarkerStart = "# ─── shaderhelper patch ";

		internal const string PatchMarkerEnd = "# ─── end ";

		internal static bool IsSoftMatRule(Material mat)
		{
			string text = Plugin.StripInstance(((Object)mat).name);
			if (Plugin._transparentMatNames.Contains(text) || Plugin._fallbackMatNames.Contains(text) || Plugin._originalMatNames.Contains(text))
			{
				return true;
			}
			foreach (string transparentMatSuffix in Plugin._transparentMatSuffixes)
			{
				if (text.EndsWith(transparentMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			foreach (string fallbackMatSuffix in Plugin._fallbackMatSuffixes)
			{
				if (text.EndsWith(fallbackMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsHardMatRule(Material mat)
		{
			string text = Plugin.StripInstance(((Object)mat).name);
			if (Plugin._forceFallbackMatNames.Contains(text) || Plugin._forceTransparentMatNames.Contains(text))
			{
				return true;
			}
			if (Plugin._matShaderOverrides.ContainsKey(text))
			{
				return true;
			}
			foreach (string forceFallbackMatSuffix in Plugin._forceFallbackMatSuffixes)
			{
				if (text.EndsWith(forceFallbackMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			foreach (string forceTransparentMatSuffix in Plugin._forceTransparentMatSuffixes)
			{
				if (text.EndsWith(forceTransparentMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsExplicitMatRule(Material mat)
		{
			return IsSoftMatRule(mat) || IsHardMatRule(mat);
		}

		internal static bool CheckMatNameRules(string matName, out ShaderAction action, out string reason)
		{
			if (Plugin._forceTransparentMatNames.Contains(matName))
			{
				action = ShaderAction.Transparent;
				reason = "[forcetransparent] mat:" + matName;
				return true;
			}
			if (Plugin._forceFallbackMatNames.Contains(matName))
			{
				action = ShaderAction.Fallback;
				reason = "[forcefallback] mat:" + matName;
				return true;
			}
			foreach (string forceTransparentMatSuffix in Plugin._forceTransparentMatSuffixes)
			{
				if (matName.EndsWith(forceTransparentMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					action = ShaderAction.Transparent;
					reason = "[forcetransparent] suffix:" + forceTransparentMatSuffix;
					return true;
				}
			}
			foreach (string forceFallbackMatSuffix in Plugin._forceFallbackMatSuffixes)
			{
				if (matName.EndsWith(forceFallbackMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					action = ShaderAction.Fallback;
					reason = "[forcefallback] suffix:" + forceFallbackMatSuffix;
					return true;
				}
			}
			if (Plugin._matShaderOverrides.TryGetValue(matName, out string value))
			{
				action = ShaderAction.UseShader;
				reason = "[useshader] " + matName + " → " + value;
				return true;
			}
			if (Plugin._originalMatNames.Contains(matName))
			{
				action = ShaderAction.Original;
				reason = "[original] mat:" + matName;
				return true;
			}
			if (Plugin._transparentMatNames.Contains(matName))
			{
				action = ShaderAction.Transparent;
				reason = "[transparent] mat:" + matName;
				return true;
			}
			if (Plugin._fallbackMatNames.Contains(matName))
			{
				action = ShaderAction.Fallback;
				reason = "[fallback] mat:" + matName;
				return true;
			}
			string text = null;
			string text2 = null;
			foreach (string transparentMatSuffix in Plugin._transparentMatSuffixes)
			{
				if (matName.EndsWith(transparentMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					text = transparentMatSuffix;
					break;
				}
			}
			foreach (string fallbackMatSuffix in Plugin._fallbackMatSuffixes)
			{
				if (matName.EndsWith(fallbackMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					text2 = fallbackMatSuffix;
					break;
				}
			}
			if (text != null && text2 != null)
			{
				action = ShaderAction.Transparent;
				reason = "[transparent] suffix:" + text + " AND [fallback] suffix:" + text2 + " — tie; Plugin.IsParticleLike tiebreak runs at sweep time, defaulting to Transparent for dry-run";
				return true;
			}
			if (text != null)
			{
				action = ShaderAction.Transparent;
				reason = "[transparent] suffix:" + text;
				return true;
			}
			if (text2 != null)
			{
				action = ShaderAction.Fallback;
				reason = "[fallback] suffix:" + text2;
				return true;
			}
			action = ShaderAction.Original;
			reason = string.Empty;
			return false;
		}

		internal static string GeneratePatchBatchId()
		{
			return "B" + DateTime.Now.ToString("yyyyMMddTHHmmss");
		}

		internal static string AppendPatchBatch(string dllFile, Dictionary<string, List<string>> rulesBySection, string batchId)
		{
			string text = Path.Combine(Plugin.ConfigDir, dllFile + ".txt");
			Directory.CreateDirectory(Plugin.ConfigDir);
			string text2 = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
			StringBuilder stringBuilder = new StringBuilder();
			if (File.Exists(text) && new FileInfo(text).Length > 0)
			{
				stringBuilder.AppendLine();
			}
			stringBuilder.AppendLine("# ─── shaderhelper patch " + batchId + " (" + text2 + ") ───");
			stringBuilder.AppendLine("# Added interactively via `shaderhelper patch`. Remove this whole block to revert,");
			stringBuilder.AppendLine("# or comment individual lines. See `shaderhelper patches` / `shaderhelper undo`.");
			string[] array = new string[5] { "forcefallback", "forcetransparent", "fallback", "transparent", "original" };
			string[] array2 = array;
			foreach (string text3 in array2)
			{
				if (!rulesBySection.TryGetValue(text3, out List<string> value) || value.Count == 0)
				{
					continue;
				}
				stringBuilder.AppendLine("[" + text3 + "]");
				foreach (string item in value)
				{
					stringBuilder.AppendLine(item);
				}
			}
			stringBuilder.AppendLine("# ─── end " + batchId + " ───");
			File.AppendAllText(text, stringBuilder.ToString());
			return text;
		}

		internal static List<(string filePath, string dllName, string batchId, string timestamp, List<string> bodyLines)> EnumeratePatchBatches()
		{
			List<(string, string, string, string, List<string>)> list = new List<(string, string, string, string, List<string>)>();
			if (!Directory.Exists(Plugin.ConfigDir))
			{
				return list;
			}
			string[] files = Directory.GetFiles(Plugin.ConfigDir, "*.txt");
			foreach (string text in files)
			{
				string[] array;
				try
				{
					array = File.ReadAllLines(text);
				}
				catch
				{
					continue;
				}
				for (int j = 0; j < array.Length; j++)
				{
					string text2 = array[j];
					if (!text2.StartsWith("# ─── shaderhelper patch ", StringComparison.Ordinal))
					{
						continue;
					}
					string text3 = text2.Substring("# ─── shaderhelper patch ".Length);
					int num = text3.IndexOf('(');
					int num2 = text3.IndexOf(')');
					if (num >= 0 && num2 >= num)
					{
						string text4 = text3.Substring(0, num).Trim();
						string item = text3.Substring(num + 1, num2 - num - 1).Trim();
						List<string> list2 = new List<string>();
						int k = j + 1;
						for (string value = "# ─── end " + text4; k < array.Length && !array[k].StartsWith(value, StringComparison.Ordinal); k++)
						{
							list2.Add(array[k]);
						}
						list.Add((text, Path.GetFileNameWithoutExtension(text), text4, item, list2));
						j = k;
					}
				}
			}
			return list;
		}

		internal static bool RemovePatchBatch(string filePath, string batchId)
		{
			string[] array;
			try
			{
				array = File.ReadAllLines(filePath);
			}
			catch
			{
				return false;
			}
			List<string> list = new List<string>(array.Length);
			string value = "# ─── shaderhelper patch " + batchId + " ";
			string value2 = "# ─── end " + batchId;
			bool flag = false;
			bool flag2 = false;
			foreach (string text in array)
			{
				if (!flag && text.StartsWith(value, StringComparison.Ordinal))
				{
					flag = true;
					flag2 = true;
					if (list.Count > 0 && list[list.Count - 1].Length == 0)
					{
						list.RemoveAt(list.Count - 1);
					}
				}
				else if (flag)
				{
					if (text.StartsWith(value2, StringComparison.Ordinal))
					{
						flag = false;
					}
				}
				else
				{
					list.Add(text);
				}
			}
			if (flag2)
			{
				File.WriteAllLines(filePath, list);
			}
			return flag2;
		}

		internal static (string section, string matName, string line, string? dllFile)? ProposeMatRule(Material mat, float distance, string parentName)
		{
			if ((Object)(object)mat == (Object)null || (Object)(object)mat.shader == (Object)null)
			{
				return null;
			}
			if (Plugin.GetAction(mat) != ShaderAction.Original)
			{
				return null;
			}
			if (Plugin.CanonicalShaderIds.Contains(((Object)mat.shader).GetInstanceID()) && !Plugin.IsAggressivelySwappable(((Object)mat.shader).name))
			{
				return null;
			}
			if (Plugin.ValheimShaderNameSet.Contains(((Object)mat.shader).name))
			{
				return null;
			}
			if (ShaderScanner.IsLikelySafeShader(((Object)mat.shader).name) && !Plugin.IsAggressivelySwappable(((Object)mat.shader).name))
			{
				return null;
			}
			string text = Plugin.StripInstance(((Object)mat).name);
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			if (Plugin._baselineMatNames.Contains(text))
			{
				return null;
			}
			string item = (Plugin.IsParticleLike(mat) ? "forcetransparent" : "forcefallback");
			string arg = (string.IsNullOrEmpty(parentName) ? "" : (" parent='" + parentName + "'"));
			string item2 = $"mat:{text,-44}# dist={distance:F1}m{arg}";
			Plugin.ModShaderDlls.TryGetValue(((Object)mat.shader).name, out string value);
			return (item, text, item2, value);
		}

		internal static bool FileAlreadyHasMatRule(string filePath, string matName)
		{
			if (!File.Exists(filePath))
			{
				return false;
			}
			string[] array;
			try
			{
				array = File.ReadAllLines(filePath);
			}
			catch
			{
				return false;
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				string text2 = text.TrimStart(Array.Empty<char>());
				if (text2.StartsWith("#", StringComparison.Ordinal))
				{
					text2 = text2.TrimStart(new char[1] { '#' }).TrimStart(Array.Empty<char>());
				}
				if (text2.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
				{
					string text3 = text2.Substring(4).TrimStart(Array.Empty<char>());
					int j;
					for (j = 0; j < text3.Length && !char.IsWhiteSpace(text3[j]) && text3[j] != '#'; j++)
					{
					}
					string text4 = text3.Substring(0, j);
					if (text4.Equals(matName, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
				}
			}
			return false;
		}
	}
}
namespace ShaderHelperForMac.Commands
{
	internal static class BasicCommands
	{
		internal static void HandleReload(Plugin instance, ConsoleEventArgs args)
		{
			Plugin.ReloadConfigFiles();
			args.Context.AddString("ShaderHelperForMac: config reloaded.");
		}

		internal static void HandleSweep(Plugin instance, ConsoleEventArgs args)
		{
			if (!instance._initialized)
			{
				args.Context.AddString("ShaderHelperForMac: not yet initialized — enter a world first.");
				return;
			}
			Plugin.ReloadConfigFiles();
			args.Context.AddString("ShaderHelperForMac: running sweep...");
			instance.SweepMaterialsWithNotify();
		}

		internal static void HandleDumpMod(Plugin instance, ConsoleEventArgs args)
		{
			string dumpTarget = ((args.Length > 2) ? args[2] : string.Empty);
			if (string.IsNullOrEmpty(dumpTarget))
			{
				args.Context.AddString("Usage: shaderhelper dumpmod <DllName>");
				return;
			}
			List<string> list = (from kv in Plugin.ModShaderDlls
				where kv.Value.Equals(dumpTarget, StringComparison.OrdinalIgnoreCase)
				select kv.Key into n
				orderby n
				select n).ToList();
			args.Context.AddString($"ShaderHelperForMac: {list.Count} shader(s) recorded for '{dumpTarget}':");
			foreach (string item in list)
			{
				Plugin.Log.LogInfo((object)("[DumpMod] '" + item + "'"));
			}
			args.Context.AddString("See BepInEx/LogOutput.log for the full list.");
		}

		internal static void HandleShaders(Plugin instance, ConsoleEventArgs args)
		{
			int num = 0;
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			foreach (Shader val in array)
			{
				if (!((Object)(object)val == (Object)null) && (!((Object)val).name.StartsWith("Hidden/") || ((Object)val).name.Contains("InternalError")) && !((Object)val).name.StartsWith("GUI/") && !((Object)val).name.StartsWith("UI/"))
				{
					Plugin.ModShaderDlls.TryGetValue(((Object)val).name, out string value);
					bool flag = Plugin.ValheimShaderNameSet.Contains(((Object)val).name);
					Plugin.Log.LogInfo((object)string.Format("[Shader] name='{0}'  supported={1}  dll='{2}'  valheim={3}", ((Object)val).name, val.isSupported, value ?? "unknown", flag));
					num++;
				}
			}
			args.Context.AddString($"ShaderHelperForMac: dumped {num} shader(s). Check BepInEx/LogOutput.log.");
		}

		internal static void HandleRenderers(Plugin instance, ConsoleEventArgs args)
		{
			int num = 0;
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null) && !(((Object)val2.shader).name == "Standard") && !(((Object)val2.shader).name == "Sprites/Default"))
					{
						Plugin.ModShaderDlls.TryGetValue(((Object)val2.shader).name, out string value);
						ShaderAction action = Plugin.GetAction(val2);
						Plugin.Log.LogInfo((object)string.Format("[Rend] go='{0}'  mat='{1}'  shader='{2}'  supported={3}  action={4}  dll='{5}'", ((Object)((Component)val).gameObject).name, ((Object)val2).name, ((Object)val2.shader).name, val2.shader.isSupported, action, value ?? "unknown"));
						num++;
					}
				}
			}
			args.Context.AddString($"ShaderHelperForMac: found {num} renderer material(s). Check BepInEx/LogOutput.log.");
		}

		internal static void HandleAll(Plugin instance, ConsoleEventArgs args)
		{
			int num = 0;
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && !((Object)(object)val == (Object)(object)Plugin._transparentMat) && !((Object)(object)val == (Object)(object)Plugin._fallbackMat) && !(((Object)val.shader).name == "Standard") && !(((Object)val.shader).name == "Sprites/Default") && !ShaderScanner.IsLikelySafeShader(((Object)val.shader).name))
				{
					Plugin.ModShaderDlls.TryGetValue(((Object)val.shader).name, out string value);
					ShaderAction action = Plugin.GetAction(val);
					Plugin.Log.LogInfo((object)string.Format("[All] mat='{0}'  shader='{1}'  supported={2}  action={3}  dll='{4}'", ((Object)val).name, ((Object)val.shader).name, val.shader.isSupported, action, value ?? "unknown"));
					num++;
				}
			}
			args.Context.AddString($"ShaderHelperForMac: dumped {num} material(s). Check BepInEx/LogOutput.log for details.");
		}
	}
	internal static class BindProbeCommand
	{
		internal static void Handle(Plugin instance, ConsoleEventArgs args)
		{
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			if (args.Args == null || args.Args.Length < 3)
			{
				Emit("Usage: shaderhelper bindprobe <MaterialName>");
				Emit("  Example: shaderhelper bindprobe DraugrFangGlow");
				Emit("  Captures shader-binding state + name-collision peers for the named material.");
				return;
			}
			string targetName = string.Join(" ", args.Args.Skip(2)).Trim();
			if (string.IsNullOrEmpty(targetName))
			{
				Emit("Usage: shaderhelper bindprobe <MaterialName>");
				return;
			}
			Emit("ShaderHelperForMac v3.2.0 — bindprobe '" + targetName + "'");
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			Material[] array2 = Resources.FindObjectsOfTypeAll<Material>();
			Emit($"  snapshot: {array.Length} loaded shader object(s), {array2.Length} loaded material(s).");
			Emit("");
			Material[] array3 = array2.Where((Material m) => (Object)(object)m != (Object)null && (Object)(object)m.shader != (Object)null && string.Equals(Plugin.StripInstance(((Object)m).name ?? string.Empty), targetName, StringComparison.Ordinal)).ToArray();
			Emit("  ─── Materials whose stripped name == '" + targetName + "' ───");
			Emit($"  count: {array3.Length}");
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int num = 0; num < array3.Length; num++)
			{
				Material val = array3[num];
				int instanceID = ((Object)val).GetInstanceID();
				int instanceID2 = ((Object)val.shader).GetInstanceID();
				string text = ((Object)val.shader).name ?? string.Empty;
				int renderQueue = val.renderQueue;
				hashSet.Add(text);
				string text2 = "n/a";
				try
				{
					int num2 = val.shader.FindPropertyIndex("_Color");
					text2 = ((num2 < 0) ? "no-_Color" : ((object)val.shader.GetPropertyType(num2)/*cast due to .constrained prefix*/).ToString());
				}
				catch (Exception ex)
				{
					text2 = "exn:" + ex.GetType().Name;
				}
				int num3 = 0;
				List<int> list = new List<int>();
				Shader[] array4 = array;
				foreach (Shader val2 in array4)
				{
					if (!((Object)(object)val2 == (Object)null) && !(((Object)val2).name != text) && ((Object)val2).GetInstanceID() != instanceID2)
					{
						num3++;
						if (list.Count < 8)
						{
							list.Add(((Object)val2).GetInstanceID());
						}
					}
				}
				string arg = string.Join(",", list);
				string arg2 = ((num3 > list.Count) ? ("+" + (num3 - list.Count) + "more") : "");
				if (num < 50)
				{
					Emit($"    [{num}] mat='{targetName}' matId={instanceID}" + $"  shaderName='{text}' shaderId={instanceID2}" + $"  renderQueue={renderQueue} schema={text2}" + $"  peerCount={num3} peerIds=[{arg}{arg2}]");
				}
				else if (num == 50)
				{
					Emit($"    … (truncated at 50; {array3.Length} total matched mats — Section 2 below shows the registry state per shader name)");
				}
			}
			Emit("");
			if (hashSet.Count == 0)
			{
				Emit("  ─── No materials matched; nothing further to report ───");
				return;
			}
			Emit("  ─── Shader-registry state for each observed shader name ───");
			foreach (string shName in hashSet.OrderBy<string, string>((string n) => n, StringComparer.Ordinal))
			{
				Shader[] array5 = array.Where((Shader s) => (Object)(object)s != (Object)null && ((Object)s).name == shName).ToArray();
				Emit($"    shader='{shName}' instances={array5.Length}:");
				Shader[] array6 = array5;
				foreach (Shader val3 in array6)
				{
					int instanceID3 = ((Object)val3).GetInstanceID();
					int renderQueue2 = val3.renderQueue;
					bool isSupported = val3.isSupported;
					bool flag = Plugin.CanonicalShaderIds.Contains(instanceID3);
					string text3 = "n/a";
					try
					{
						int num6 = val3.FindPropertyIndex("_Color");
						text3 = ((num6 < 0) ? "no-_Color" : ((object)val3.GetPropertyType(num6)/*cast due to .constrained prefix*/).ToString());
					}
					catch (Exception ex2)
					{
						text3 = "exn:" + ex2.GetType().Name;
					}
					Emit($"      id={instanceID3} renderQueue={renderQueue2} isSupported={isSupported} schema={text3} inCanonical={flag}");
				}
			}
			void Emit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[BindProbe] " + line));
			}
		}
	}
	internal static class CaptureCommand
	{
		private sealed class MatSample
		{
			public string BaseName = "";

			public string ShaderName = "";

			public bool ShaderSupported;

			public bool ParticleCapable;

			public ShaderAction LastAction;

			public string? Dll;

			public float MinDist = float.MaxValue;

			public float MaxDist = float.MinValue;

			public int FirstFrame;

			public int LastFrame;

			public int FramesSeen;

			public string LastColor = "n/a";

			public Dictionary<string, int> RendererTypeCounts = new Dictionary<string, int>();

			public string LastParent = "(root)";

			public string LastGo = "";
		}

		[StructLayout(LayoutKind.Auto)]
		[CompilerGenerated]
		private struct <>c__DisplayClass10_0
		{
			public HashSet<int> seenRendererIds;

			public Vector3 playerPos;

			public int frameNum;
		}

		private const float MaxCaptureDurationSeconds = 60f;

		private static bool _captureActive;

		private static Coroutine? _captureCoroutine;

		private static Dictionary<int, MatSample> _activeSamples = new Dictionary<int, MatSample>();

		private static float _captureRadius;

		private static int _captureStartFrame;

		private static float _captureStartRealtime;

		internal static void HandleStart(Plugin instance, ConsoleEventArgs args)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				args.Context.AddString("ShaderHelperForMac: no local player found.");
				return;
			}
			if (_captureActive)
			{
				args.Context.AddString("ShaderHelperForMac: capture already running. Stop it first with `shaderhelper capture stop`, or accept it auto-stopping.");
				Plugin.Log.LogWarning((object)"[Capture] start requested while capture already active — ignoring.");
				return;
			}
			float num = 30f;
			if (args.Length > 3 && float.TryParse(args[3], out var result))
			{
				num = result;
			}
			_captureRadius = num;
			_captureStartFrame = Time.frameCount;
			_captureStartRealtime = Time.realtimeSinceStartup;
			_activeSamples = new Dictionary<int, MatSample>();
			_captureActive = true;
			_captureCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(CaptureCoroutine());
			Plugin.Log.LogInfo((object)$"[Capture] BEGIN  radius={num:F0}  startFrame={_captureStartFrame}  maxDuration={60f:F0}s — trigger your event(s) now, then run `shaderhelper capture stop`.");
			args.Context.AddString($"ShaderHelperForMac: capture started (radius={num:F0}, max {60f:F0}s). Trigger your weapon swing / FX now, then run `shaderhelper capture stop`.");
		}

		internal static void HandleStop(Plugin instance, ConsoleEventArgs args)
		{
			if (!_captureActive)
			{
				args.Context.AddString("ShaderHelperForMac: no capture is currently running.");
				return;
			}
			if (_captureCoroutine != null)
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(_captureCoroutine);
				_captureCoroutine = null;
			}
			_captureActive = false;
			EmitSummary("user-stop");
			_activeSamples = new Dictionary<int, MatSample>();
			args.Context.AddString("ShaderHelperForMac: capture stopped — see [Capture] block in BepInEx/LogOutput.log.");
		}

		private static IEnumerator CaptureCoroutine()
		{
			<>c__DisplayClass10_0 CS$<>8__locals7 = default(<>c__DisplayClass10_0);
			while (_captureActive)
			{
				Player player = Player.m_localPlayer;
				if ((Object)(object)player == (Object)null)
				{
					_captureActive = false;
					EmitSummary("player-lost");
					_activeSamples = new Dictionary<int, MatSample>();
					_captureCoroutine = null;
					break;
				}
				if (Time.realtimeSinceStartup - _captureStartRealtime > 60f)
				{
					_captureActive = false;
					EmitSummary("auto-stop (max duration)");
					_activeSamples = new Dictionary<int, MatSample>();
					_captureCoroutine = null;
					break;
				}
				CS$<>8__locals7.frameNum = Time.frameCount;
				CS$<>8__locals7.playerPos = ((Component)player).transform.position;
				CS$<>8__locals7.seenRendererIds = new HashSet<int>();
				Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
				foreach (Renderer r in array)
				{
					Sample(r);
				}
				TrailRenderer[] array2 = Resources.FindObjectsOfTypeAll<TrailRenderer>();
				foreach (TrailRenderer tr in array2)
				{
					Sample((Renderer)(object)tr);
				}
				LineRenderer[] array3 = Resources.FindObjectsOfTypeAll<LineRenderer>();
				foreach (LineRenderer lr in array3)
				{
					Sample((Renderer)(object)lr);
				}
				yield return null;
				CS$<>8__locals7 = default(<>c__DisplayClass10_0);
				void Sample(Renderer val)
				{
					//IL_003a: 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_0212: Unknown result type (might be due to invalid IL or missing references)
					//IL_0217: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)val == (Object)null))
					{
						int instanceID = ((Object)val).GetInstanceID();
						if (CS$<>8__locals7.seenRendererIds.Add(instanceID))
						{
							float num = Vector3.Distance(((Component)val).transform.position, CS$<>8__locals7.playerPos);
							if (!(num > _captureRadius))
							{
								string name = ((object)val).GetType().Name;
								Transform parent = ((Component)val).transform.parent;
								string lastParent = ((parent != null) ? ((Object)parent).name : null) ?? "(root)";
								string name2 = ((Object)((Component)val).gameObject).name;
								Material[] sharedMaterials = val.sharedMaterials;
								foreach (Material val2 in sharedMaterials)
								{
									if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.shader == (Object)null) && !((Object)(object)val2 == (Object)(object)Plugin._transparentMat) && !((Object)(object)val2 == (Object)(object)Plugin._fallbackMat))
									{
										int instanceID2 = ((Object)val2).GetInstanceID();
										if (!_activeSamples.TryGetValue(instanceID2, out MatSample value))
										{
											value = new MatSample
											{
												BaseName = Plugin.StripInstance(((Object)val2).name),
												ShaderName = (((Object)val2.shader).name ?? "<null>"),
												ShaderSupported = val2.shader.isSupported,
												ParticleCapable = Plugin.IsParticleCapableShaderName(((Object)val2.shader).name ?? string.Empty),
												FirstFrame = CS$<>8__locals7.frameNum
											};
											Plugin.ModShaderDlls.TryGetValue(((Object)val2.shader).name ?? string.Empty, out string value2);
											value.Dll = value2;
											_activeSamples[instanceID2] = value;
										}
										value.LastFrame = CS$<>8__locals7.frameNum;
										value.FramesSeen++;
										value.LastAction = Plugin.GetAction(val2);
										value.LastColor = (val2.HasProperty("_Color") ? ((object)val2.color/*cast due to .constrained prefix*/).ToString() : "n/a");
										value.LastParent = lastParent;
										value.LastGo = name2;
										if (num < value.MinDist)
										{
											value.MinDist = num;
										}
										if (num > value.MaxDist)
										{
											value.MaxDist = num;
										}
										if (value.RendererTypeCounts.TryGetValue(name, out var value3))
										{
											value.RendererTypeCounts[name] = value3 + 1;
										}
										else
										{
											value.RendererTypeCounts[name] = 1;
										}
									}
								}
							}
						}
					}
				}
			}
		}

		private static void EmitSummary(string stopReason)
		{
			int frameCount = Time.frameCount;
			int num = frameCount - _captureStartFrame;
			float num2 = Time.realtimeSinceStartup - _captureStartRealtime;
			Plugin.Log.LogInfo((object)$"[Capture] END    reason='{stopReason}'  frames={num}  wallSec={num2:F1}  distinctMats={_activeSamples.Count}  radius={_captureRadius:F0}");
			if (_activeSamples.Count == 0)
			{
				Plugin.Log.LogInfo((object)"[Capture]   (no materials sampled — player may have been out of range, or the capture window was a single frame)");
				return;
			}
			List<KeyValuePair<int, MatSample>> list = new List<KeyValuePair<int, MatSample>>(_activeSamples);
			list.Sort(delegate(KeyValuePair<int, MatSample> a, KeyValuePair<int, MatSample> b)
			{
				int num5 = a.Value.FramesSeen.CompareTo(b.Value.FramesSeen);
				return (num5 != 0) ? num5 : string.Compare(a.Value.BaseName, b.Value.BaseName, StringComparison.OrdinalIgnoreCase);
			});
			foreach (KeyValuePair<int, MatSample> item in list)
			{
				MatSample value = item.Value;
				string text;
				if (value.RendererTypeCounts.Count == 0)
				{
					text = "(none)";
				}
				else
				{
					List<string> list2 = new List<string>(value.RendererTypeCounts.Count);
					foreach (KeyValuePair<string, int> rendererTypeCount in value.RendererTypeCounts)
					{
						list2.Add($"{rendererTypeCount.Key}:{rendererTypeCount.Value}");
					}
					text = string.Join(" ", list2);
				}
				int num3 = value.FirstFrame - _captureStartFrame;
				int num4 = value.LastFrame - _captureStartFrame;
				Plugin.Log.LogInfo((object)($"[Capture]   frames={value.FramesSeen,4} ({num3}..{num4})  " + $"mat='{value.BaseName}'  shader='{value.ShaderName}' supp={value.ShaderSupported} pCap={value.ParticleCapable}  " + $"action={value.LastAction}  dist={value.MinDist:F1}..{value.MaxDist:F1}  " + "renderers=[" + text + "]  parent='" + value.LastParent + "' go='" + value.LastGo + "'  color=" + value.LastColor + "  dll='" + (value.Dll ?? "unknown") + "'"));
			}
		}
	}
	internal static class CaptureVanillaCommand
	{
		internal static void Handle(Plugin self, ConsoleEventArgs args)
		{
			string pluginPath = Paths.PluginPath;
			List<string> list = new List<string>();
			try
			{
				foreach (string item in Directory.EnumerateFiles(pluginPath, "*.dll", SearchOption.AllDirectories))
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
					if (!string.Equals(fileNameWithoutExtension, "ShaderHelperForMac", StringComparison.OrdinalIgnoreCase) && !string.Equals(fileNameWithoutExtension, "AssetsTools.NET", StringComparison.OrdinalIgnoreCase))
					{
						list.Add(item);
					}
				}
			}
			catch (Exception ex)
			{
				CvEmit("REFUSED: failed to enumerate '" + pluginPath + "': " + ex.GetType().Name + ": " + ex.Message);
				return;
			}
			if (list.Count > 0)
			{
				CvEmit($"REFUSED: {list.Count} non-self DLL(s) found in BepInEx/plugins/. Move them out, then re-run.");
				CvEmit("This refusal is structural: any mod that materializes its AssetBundle materials into the Unity heap during its own Awake would pollute the captured baseline. Only ShaderHelperForMac.dll and its sibling AssetsTools.NET.dll may be loaded.");
				int num = Math.Min(list.Count, 20);
				for (int i = 0; i < num; i++)
				{
					CvEmit("  offender: " + list[i]);
				}
				if (list.Count > num)
				{
					CvEmit($"  …and {list.Count - num} more.");
				}
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			int num2 = 0;
			int num3 = 0;
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				if ((Object)(object)allLoadedAssetBundle == (Object)null)
				{
					continue;
				}
				num3++;
				if (!Plugin._vanillaBundleNames.Contains(((Object)allLoadedAssetBundle).name))
				{
					continue;
				}
				num2++;
				hashSet3.Add(((Object)allLoadedAssetBundle).name);
				try
				{
					string[] allAssetNames = allLoadedAssetBundle.GetAllAssetNames();
					foreach (string text in allAssetNames)
					{
						if (string.IsNullOrEmpty(text))
						{
							continue;
						}
						if (text.EndsWith(".mat", StringComparison.OrdinalIgnoreCase))
						{
							string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(text);
							if (!string.IsNullOrEmpty(fileNameWithoutExtension2))
							{
								hashSet.Add(fileNameWithoutExtension2);
							}
						}
						else if (text.EndsWith(".shader", StringComparison.OrdinalIgnoreCase))
						{
							string fileNameWithoutExtension3 = Path.GetFileNameWithoutExtension(text);
							if (!string.IsNullOrEmpty(fileNameWithoutExtension3))
							{
								hashSet2.Add(fileNameWithoutExtension3);
							}
						}
					}
				}
				catch (Exception ex2)
				{
					CvEmit("  warning: TOC walk failed for bundle '" + ((Object)allLoadedAssetBundle).name + "': " + ex2.GetType().Name + ": " + ex2.Message);
				}
			}
			if (num2 == 0)
			{
				CvEmit($"REFUSED: zero vanilla bundles observed (total loaded bundles: {num3}). Load any world first, then re-run from F5 console.");
				return;
			}
			string valheimVersionViaReflection = VanillaBaselineCache.GetValheimVersionViaReflection();
			bool flag = VanillaBaselineCache.Write(Plugin.ConfigDir, Plugin.Log, hashSet3, hashSet, hashSet2, valheimVersionViaReflection);
			string cachePath = VanillaBaselineCache.GetCachePath(Plugin.ConfigDir);
			if (flag)
			{
				long num4 = 0L;
				try
				{
					num4 = new FileInfo(cachePath).Length;
				}
				catch
				{
				}
				CvEmit($"WROTE: mats={hashSet.Count} shaders={hashSet2.Count} bundles={hashSet3.Count} ({num4} bytes at {cachePath})");
				CvEmit("Quit Valheim, restore your mod DLLs, relaunch. The new baseline takes effect on next startup.");
			}
			else
			{
				CvEmit("FAILED: cache write to '" + cachePath + "' did not succeed. See the [VanillaCache] warning above for the underlying I/O error.");
			}
			void CvEmit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[CaptureVanilla] " + line));
			}
		}
	}
	internal static class ConfigAuthoringCommands
	{
		public static void HandlePatch(Plugin self, ConsoleEventArgs args)
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				args.Context.AddString("ShaderHelperForMac: no local player found.");
				return;
			}
			float num = 15f;
			string pDllOverride = null;
			for (int i = 2; i < args.Length; i++)
			{
				if (float.TryParse(args[i], out var result))
				{
					num = result;
				}
				else
				{
					pDllOverride = args[i];
				}
			}
			if (pDllOverride != null)
			{
				string text = Plugin.ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(pDllOverride, StringComparison.OrdinalIgnoreCase));
				if (text != null)
				{
					pDllOverride = text;
				}
			}
			Dictionary<string, Dictionary<string, List<string>>> dictionary = new Dictionary<string, Dictionary<string, List<string>>>(StringComparer.OrdinalIgnoreCase);
			Dictionary<string, HashSet<string>> dictionary2 = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			Renderer[] array2 = array;
			foreach (Renderer val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				float num6 = Vector3.Distance(((Component)val).transform.position, ((Component)localPlayer).transform.position);
				if (num6 > num)
				{
					continue;
				}
				Transform parent = ((Component)val).transform.parent;
				string text2 = ((parent != null) ? ((Object)parent).name : null) ?? ((Object)((Component)val).gameObject).name;
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if ((Object)(object)val2 == (Object)null || (Object)(object)val2.shader == (Object)null || (Object)(object)val2 == (Object)(object)Plugin._transparentMat || (Object)(object)val2 == (Object)(object)Plugin._fallbackMat)
					{
						continue;
					}
					(string, string, string, string)? tuple = Plugin.ProposeMatRule(val2, num6, text2);
					if (!tuple.HasValue)
					{
						num4++;
						continue;
					}
					(string, string, string, string) value = tuple.Value;
					string item = value.Item1;
					string item2 = value.Item2;
					string item3 = value.Item3;
					string item4 = value.Item4;
					string text3 = item4 ?? pDllOverride;
					if (text3 == null)
					{
						Plugin.Log.LogInfo((object)("[Patch] unattributed — paste into the owning mod's .txt under [" + item + "]:"));
						Plugin.Log.LogInfo((object)$"[Patch]   mat:{item2}    # shader='{((Object)val2.shader).name}'  parent='{text2}'  dist={num6:F1}m");
						Plugin.Log.LogInfo((object)$"[Patch]   (or re-run: shaderhelper patch {num} <DllName>  to auto-write to that file)");
						num2++;
						continue;
					}
					if (!dictionary2.TryGetValue(text3, out var value2))
					{
						value2 = (dictionary2[text3] = new HashSet<string>(StringComparer.OrdinalIgnoreCase));
					}
					if (!value2.Add(item2))
					{
						continue;
					}
					string filePath = Path.Combine(Plugin.ConfigDir, text3 + ".txt");
					if (Plugin.FileAlreadyHasMatRule(filePath, item2))
					{
						num3++;
						continue;
					}
					if (!dictionary.TryGetValue(text3, out var value3))
					{
						value3 = (dictionary[text3] = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase));
					}
					if (!value3.TryGetValue(item, out var value4))
					{
						value4 = (value3[item] = new List<string>());
					}
					value4.Add(item3);
				}
			}
			if (dictionary.Count == 0)
			{
				int num8 = 0;
				int num9 = 0;
				Renderer[] array3 = array;
				foreach (Renderer val3 in array3)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						num8++;
						if (Vector3.Distance(((Component)val3).transform.position, ((Component)localPlayer).transform.position) <= num)
						{
							num9++;
						}
					}
				}
				args.Context.AddString($"ShaderHelperForMac: no rules to add within {num}m.");
				args.Context.AddString($"  Renderers in scene: {num8}  within {num}m: {num9}");
				args.Context.AddString($"  Skipped: {num4} ineligible, {num2} unattributed, {num3} already-ruled");
				if (num9 == 0)
				{
					args.Context.AddString("  (no renderers in range — move closer to the mod objects you want to patch)");
				}
				else if (num4 > 0 && num2 == 0 && num3 == 0)
				{
					args.Context.AddString("  (every in-range material was vanilla/canonical/safe — nothing mod-owned here to patch)");
				}
				else if (num2 > 0)
				{
					args.Context.AddString($"  (re-run with a DllName arg to auto-write the {num2} unattributed; see BepInEx/LogOutput.log for copy-paste hints)");
				}
				return;
			}
			string text4 = Plugin.GeneratePatchBatchId();
			int num11 = 0;
			foreach (KeyValuePair<string, Dictionary<string, List<string>>> item5 in dictionary)
			{
				string arg = Plugin.AppendPatchBatch(item5.Key, item5.Value, text4);
				int num12 = 0;
				foreach (List<string> value5 in item5.Value.Values)
				{
					num12 += value5.Count;
				}
				num11 += num12;
				Plugin.Log.LogInfo((object)$"[Patch] {text4}: wrote {num12} rule(s) to {arg}");
				foreach (KeyValuePair<string, List<string>> item6 in item5.Value)
				{
					foreach (string item7 in item6.Value)
					{
						Plugin.Log.LogInfo((object)("[Patch]   [" + item6.Key + "] " + item7));
					}
				}
			}
			Plugin.ReloadConfigFiles();
			if (self._initialized)
			{
				self.SweepMaterialsWithNotify();
			}
			args.Context.AddString($"Patch {text4}: added {num11} rule(s) across {dictionary.Count} mod(s).");
			if (num2 > 0)
			{
				args.Context.AddString($"Skipped {num2} unattributed (see log for manual-add hints).");
			}
			if (num3 > 0)
			{
				args.Context.AddString($"Skipped {num3} already-ruled.");
			}
			args.Context.AddString("Run 'shaderhelper patches' to review or 'shaderhelper undo' to revert.");
		}

		public static void HandlePatches(Plugin self, ConsoleEventArgs args)
		{
			List<(string, string, string, string, List<string>)> list = Plugin.EnumeratePatchBatches();
			if (list.Count == 0)
			{
				args.Context.AddString("ShaderHelperForMac: no patch batches found.");
				return;
			}
			list.Sort(((string filePath, string dllName, string batchId, string timestamp, List<string> bodyLines) a, (string filePath, string dllName, string batchId, string timestamp, List<string> bodyLines) b) => string.Compare(b.timestamp, a.timestamp, StringComparison.Ordinal));
			args.Context.AddString($"ShaderHelperForMac: {list.Count} patch batch(es):");
			foreach (var item in list)
			{
				int num = 0;
				foreach (string item2 in item.Item5)
				{
					string text = item2.TrimStart(Array.Empty<char>());
					if (text.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						num++;
					}
				}
				string text2 = $"  {item.Item3}  {item.Item4}  {item.Item2}.txt  {num} rule(s)";
				args.Context.AddString(text2);
				Plugin.Log.LogInfo((object)$"[Patches] {item.Item3}  {item.Item4}  {item.Item1}  {num} rule(s)");
				foreach (string item3 in item.Item5)
				{
					string text3 = item3.TrimStart(Array.Empty<char>());
					if (text3.StartsWith("mat:", StringComparison.OrdinalIgnoreCase) || text3.StartsWith("[", StringComparison.Ordinal))
					{
						Plugin.Log.LogInfo((object)("  " + item3));
					}
				}
			}
		}

		public static void HandleUndo(Plugin self, ConsoleEventArgs args)
		{
			string text = ((args.Length > 2) ? args[2] : "last");
			List<(string, string, string, string, List<string>)> list = Plugin.EnumeratePatchBatches();
			if (list.Count == 0)
			{
				args.Context.AddString("ShaderHelperForMac: no patch batches to undo.");
				return;
			}
			List<(string, string)> list2 = new List<(string, string)>();
			if (text.Equals("all", StringComparison.OrdinalIgnoreCase))
			{
				foreach (var item2 in list)
				{
					list2.Add((item2.Item1, item2.Item3));
				}
			}
			else if (text.Equals("last", StringComparison.OrdinalIgnoreCase))
			{
				list.Sort(((string filePath, string dllName, string batchId, string timestamp, List<string> bodyLines) a, (string filePath, string dllName, string batchId, string timestamp, List<string> bodyLines) b) => string.Compare(b.timestamp, a.timestamp, StringComparison.Ordinal));
				string item = list[0].Item3;
				foreach (var item3 in list)
				{
					if (item3.Item3.Equals(item, StringComparison.Ordinal))
					{
						list2.Add((item3.Item1, item3.Item3));
					}
				}
			}
			else
			{
				foreach (var item4 in list)
				{
					if (item4.Item3.Equals(text, StringComparison.OrdinalIgnoreCase))
					{
						list2.Add((item4.Item1, item4.Item3));
					}
				}
				if (list2.Count == 0)
				{
					args.Context.AddString("ShaderHelperForMac: no batch with id '" + text + "'.");
					return;
				}
			}
			int num = 0;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (var (text2, text3) in list2)
			{
				if (Plugin.RemovePatchBatch(text2, text3))
				{
					num++;
					hashSet.Add(text3);
					Plugin.Log.LogInfo((object)("[Undo] removed " + text3 + " from " + text2));
				}
			}
			Plugin.ReloadConfigFiles();
			if (self._initialized)
			{
				self.SweepMaterialsWithNotify();
			}
			args.Context.AddString($"Undo: removed {hashSet.Count} batch(es) across {num} file(s).");
			args.Context.AddString("Config reloaded and sweep running.");
		}
	}
	internal static class DllFilteredCommands
	{
		internal static void HandleScan(Plugin instance, ConsoleEventArgs args)
		{
			string text = ((args.Length > 2) ? args[2] : string.Empty);
			if (string.IsNullOrEmpty(text))
			{
				args.Context.AddString("Usage: shaderhelper scan <DllName>");
				return;
			}
			int num = 0;
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && Plugin.ModShaderDlls.TryGetValue(((Object)val.shader).name, out string value) && value.Equals(text, StringComparison.OrdinalIgnoreCase))
				{
					Plugin.Log.LogInfo((object)$"[Scan] mat='{((Object)val).name}'  shader='{((Object)val.shader).name}'  supported={val.shader.isSupported}");
					num++;
				}
			}
			args.Context.AddString($"ShaderHelperForMac: found {num} material(s) from '{text}'. Check BepInEx/LogOutput.log for details.");
		}

		internal static void HandleTransparent(Plugin instance, ConsoleEventArgs args)
		{
			string trFilter = ((args.Length > 2) ? args[2] : string.Empty);
			if (string.IsNullOrEmpty(trFilter))
			{
				args.Context.AddString("Usage: shaderhelper transparent <DllName>");
				return;
			}
			string text = Plugin.ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(trFilter, StringComparison.OrdinalIgnoreCase));
			bool flag = text == null;
			if (flag)
			{
				text = trFilter;
				args.Context.AddString("ShaderHelperForMac: '" + trFilter + "' not in scan results (large embedded bundle?) — showing all transparent materials with dll='unknown'.");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			int num = 0;
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null || (Object)(object)val == (Object)(object)Plugin._transparentMat || (Object)(object)val == (Object)(object)Plugin._fallbackMat)
				{
					continue;
				}
				Plugin.ModShaderDlls.TryGetValue(((Object)val.shader).name, out string value);
				if (flag)
				{
					if (value != null)
					{
						continue;
					}
				}
				else if (!text.Equals(value, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				bool flag2 = Plugin._forceReplacedMaterialIds.Contains(((Object)val).GetInstanceID());
				if (flag2 || (Plugin.NeedsReplacement(val) && Plugin.GetAction(val) == ShaderAction.Transparent))
				{
					string text2 = Plugin.StripInstance(((Object)val).name);
					if (hashSet.Add(text2))
					{
						string text3 = (flag2 ? "replaced" : "pending");
						Plugin.Log.LogInfo((object)("[Trans] state=" + text3 + "  mat='" + text2 + "'  shader='" + ((Object)val.shader).name + "'  dll='" + (value ?? "unknown") + "'"));
						num++;
					}
				}
			}
			args.Context.AddString($"ShaderHelperForMac: {num} transparent material(s) from '{text}'. Add mat: rules to [fallback] to make them visible.");
			args.Context.AddString("Check BepInEx/LogOutput.log for material names.");
		}

		internal static void HandleLoaded(Plugin instance, ConsoleEventArgs args)
		{
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			string ldFilter = ((args.Length > 2) ? args[2] : string.Empty);
			bool flag = !string.IsNullOrEmpty(ldFilter);
			string text = (flag ? Plugin.ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(ldFilter, StringComparison.OrdinalIgnoreCase)) : null);
			if (flag && text == null)
			{
				args.Context.AddString("ShaderHelperForMac: '" + ldFilter + "' not in scan results (large embedded bundle?) — showing all materials with dll='unknown'.");
			}
			int num = 0;
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null || (Object)(object)val == (Object)(object)Plugin._transparentMat || (Object)(object)val == (Object)(object)Plugin._fallbackMat)
				{
					continue;
				}
				Plugin.ModShaderDlls.TryGetValue(((Object)val.shader).name, out string value);
				if (flag)
				{
					if (text != null)
					{
						if (!text.Equals(value, StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
					}
					else if (value != null)
					{
						continue;
					}
				}
				if (!((Object)val.shader).name.Equals("Standard", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string item = Plugin.StripInstance(((Object)val).name);
				if (!Plugin._baselineMatNames.Contains(item))
				{
					ShaderAction action = Plugin.GetAction(val);
					if (action == ShaderAction.Original)
					{
						Plugin.Log.LogInfo((object)string.Format("[Loaded] mat='{0}'  shader='{1}'  supported={2}  action={3}  color={4}  dll='{5}'", ((Object)val).name, ((Object)val.shader).name, val.shader.isSupported, action, val.color, value ?? "unknown"));
						num++;
					}
				}
			}
			string arg = (flag ? (" from '" + ldFilter + "'") : string.Empty);
			args.Context.AddString($"ShaderHelperForMac: logged {num} unhandled material(s){arg}. Check BepInEx/LogOutput.log.");
		}

		internal static void HandleDlls(Plugin instance, ConsoleEventArgs args)
		{
			string dlFilter = ((args.Length > 2) ? args[2] : string.Empty);
			bool dlHasFilter = !string.IsNullOrEmpty(dlFilter);
			string dlCanon = null;
			if (dlHasFilter)
			{
				dlCanon = Plugin._bundleToDll.Values.Concat(Plugin.ModShaderDlls.Values).FirstOrDefault((string d) => d.Equals(dlFilter, StringComparison.OrdinalIgnoreCase));
				if (dlCanon == null)
				{
					dlCanon = dlFilter;
				}
			}
			int count = Plugin._tocAttributedBundles.Count;
			int num = Plugin._bundleToDll.Count - count;
			Emit($"ShaderHelperForMac: _bundleToDll has {Plugin._bundleToDll.Count} bundle→DLL attribution(s) ({num} load-time, {count} toc-path).");
			List<IGrouping<string, KeyValuePair<string, string>>> list = Plugin._bundleToDll.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> kv) => !dlHasFilter || kv.Value.Equals(dlCanon, StringComparison.OrdinalIgnoreCase)).GroupBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Value, StringComparer.OrdinalIgnoreCase).OrderBy<IGrouping<string, KeyValuePair<string, string>>, string>((IGrouping<string, KeyValuePair<string, string>> g) => g.Key, StringComparer.Ordinal)
				.ToList();
			foreach (IGrouping<string, KeyValuePair<string, string>> item in list)
			{
				Emit($"  {item.Key}  ({item.Count()} bundle(s)):");
				foreach (KeyValuePair<string, string> item2 in item.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> k) => k.Key, StringComparer.Ordinal))
				{
					string text = (Plugin._tocAttributedBundles.Contains(item2.Key) ? "toc-path" : "load-time");
					Emit("    bundle: '" + item2.Key + "'  [" + text + "]");
				}
			}
			if (dlHasFilter && list.Count == 0)
			{
				Emit("  (no bundle attributions for '" + dlCanon + "')");
			}
			Emit($"ShaderHelperForMac: ModShaderDlls has {Plugin.ModShaderDlls.Count} shader→DLL attribution(s).");
			List<IGrouping<string, KeyValuePair<string, string>>> list2 = Plugin.ModShaderDlls.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> kv) => !dlHasFilter || kv.Value.Equals(dlCanon, StringComparison.OrdinalIgnoreCase)).GroupBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Value, StringComparer.OrdinalIgnoreCase).OrderBy<IGrouping<string, KeyValuePair<string, string>>, string>((IGrouping<string, KeyValuePair<string, string>> g) => g.Key, StringComparer.Ordinal)
				.ToList();
			foreach (IGrouping<string, KeyValuePair<string, string>> item3 in list2)
			{
				Emit($"  {item3.Key}  ({item3.Count()} shader(s)):");
				foreach (KeyValuePair<string, string> item4 in item3.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> k) => k.Key, StringComparer.Ordinal))
				{
					Emit("    shader: '" + item4.Key + "'");
				}
			}
			if (dlHasFilter && list2.Count == 0)
			{
				Emit("  (no shader attributions for '" + dlCanon + "')");
			}
			void Emit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[DLLs] " + line));
			}
		}
	}
	internal static class FallbackChainCommand
	{
		internal static void Handle(Plugin instance, ConsoleEventArgs args)
		{
			Emit("ShaderHelperForMac v3.2.0 — fallback / transparent chain state");
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			Emit($"  Resources.FindObjectsOfTypeAll<Shader>() snapshot: {array.Length} loaded shader object(s).");
			Emit("");
			Emit("  ─── FallbackChain (Plugin.FallbackChain) — used by InitAfterFrame + TryUpgradeFallbackShader ───");
			int activeId = (((Object)(object)Plugin.FallbackShader != (Object)null) ? ((Object)Plugin.FallbackShader).GetInstanceID() : 0);
			for (int i = 0; i < Plugin.FallbackChain.Length; i++)
			{
				string name = Plugin.FallbackChain[i];
				DumpChainEntry(Emit, i, name, array, activeId);
			}
			Emit("");
			Emit("  Plugin.FallbackShader     = " + (((Object)(object)Plugin.FallbackShader != (Object)null) ? $"'{((Object)Plugin.FallbackShader).name}'  id={((Object)Plugin.FallbackShader).GetInstanceID()}  isSupported={Plugin.FallbackShader.isSupported}" : "<null>"));
			Emit("  Plugin._fallbackMat       = " + DescribeMat(Plugin._fallbackMat));
			bool flag = (Object)(object)Plugin.FallbackShader != (Object)null && Plugin.CanonicalShaderIds.Contains(((Object)Plugin.FallbackShader).GetInstanceID());
			Emit($"  CanonicalShaderIds count  = {Plugin.CanonicalShaderIds.Count}  (FallbackShader id in canonical set: {flag})");
			Emit("");
			Emit("  ─── TransparentChain (Plugin.TransparentChain) — used by BuildTransparentMaterial + TryUpgradeTransparentShader ───");
			int activeId2 = (((Object)(object)Plugin._transparentMat != (Object)null && (Object)(object)Plugin._transparentMat.shader != (Object)null) ? ((Object)Plugin._transparentMat.shader).GetInstanceID() : 0);
			for (int j = 0; j < Plugin.TransparentChain.Length; j++)
			{
				string name2 = Plugin.TransparentChain[j];
				DumpChainEntry(Emit, j, name2, array, activeId2);
			}
			Emit("");
			Emit("  Plugin._transparentMat                 = " + DescribeMat(Plugin._transparentMat));
			Emit($"  Plugin._transparentShaderIsParticleCapable = {Plugin._transparentShaderIsParticleCapable}");
			void Emit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[FallbackChain] " + line));
			}
		}

		private static string DescribeMat(Material? mat)
		{
			if ((Object)(object)mat == (Object)null)
			{
				return "<null>";
			}
			Shader shader = mat.shader;
			if ((Object)(object)shader == (Object)null)
			{
				return "name='" + ((Object)mat).name + "'  shader=<null>";
			}
			return $"name='{((Object)mat).name}'  shader='{((Object)shader).name}'  shaderId={((Object)shader).GetInstanceID()}";
		}

		private static void DumpChainEntry(Action<string> Emit, int index, string name, Shader[] allShaders, int activeId)
		{
			Emit($"  [{index}] '{name}'");
			Shader val = Shader.Find(name);
			if ((Object)(object)val != (Object)null)
			{
				string arg = ((((Object)val).GetInstanceID() == activeId) ? "  ← ACTIVE" : "");
				Emit($"        Shader.Find:           id={((Object)val).GetInstanceID()}  isSupported={val.isSupported}{arg}");
			}
			else
			{
				Emit("        Shader.Find:           <null>");
			}
			Shader[] array = allShaders.Where((Shader s) => (Object)(object)s != (Object)null && ((Object)s).name == name).ToArray();
			Emit($"        Resources matches:     {array.Length}");
			for (int num = 0; num < array.Length; num++)
			{
				Shader val2 = array[num];
				string text = ((((Object)val2).GetInstanceID() == activeId) ? "  ← ACTIVE" : "");
				Emit($"          [{num}] id={((Object)val2).GetInstanceID()}  isSupported={val2.isSupported}{text}");
			}
		}
	}
	internal static class GateAuditCommands
	{
		internal static void HandlePink(Plugin self, ConsoleEventArgs args)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null || (Object)(object)val == (Object)(object)Plugin._transparentMat || (Object)(object)val == (Object)(object)Plugin._fallbackMat)
				{
					continue;
				}
				string text = Plugin.StripInstance(((Object)val).name);
				bool flag = Plugin._baselineMatNames.Contains(text);
				bool flag2 = Plugin._vanillaShaderNames.Contains(((Object)val.shader).name) || Plugin.ValheimShaderNameSet.Contains(((Object)val.shader).name) || Plugin.UnityBuiltInShaderNameSet.Contains(((Object)val.shader).name);
				bool flag3 = Plugin.CanonicalShaderIds.Contains(((Object)val.shader).GetInstanceID());
				bool flag4 = flag2 || flag3;
				bool flag5 = Plugin._prefabScopedModMatIds.Contains(((Object)val).GetInstanceID());
				if (flag && flag4 && !flag5)
				{
					num2++;
					continue;
				}
				if (ReplacementCore._replacedMats.ContainsKey(((Object)val).GetInstanceID()))
				{
					num3++;
					continue;
				}
				if (Plugin.IsHardMatRule(val))
				{
					num4++;
					continue;
				}
				if (Plugin.IsForceTransparent(((Object)val.shader).name) || Plugin.IsForceFallback(((Object)val.shader).name))
				{
					num4++;
					continue;
				}
				if (Plugin.CanonicalShaderIds.Contains(((Object)val.shader).GetInstanceID()))
				{
					num5++;
					continue;
				}
				ShaderAction action = Plugin.GetAction(val);
				if (action == ShaderAction.Original && hashSet.Add(text))
				{
					Plugin.ModShaderDlls.TryGetValue(((Object)val.shader).name, out string value);
					string text2 = (Plugin.IsParticleLike(val) ? "particle-like" : "solid");
					Plugin.Log.LogInfo((object)string.Format("[Pink] mat='{0}'  shader='{1}'  supported={2}  dll='{3}'  hint={4}", text, ((Object)val.shader).name, val.shader.isSupported, value ?? "unknown", text2));
					num++;
				}
			}
			args.Context.AddString($"ShaderHelperForMac: found {num} unhandled pink material(s) (skipped {num2} vanilla-gated, {num5} canonical-shader (rendering correctly), {num3} already-replaced, {num4} already-ruled). Check BepInEx/LogOutput.log for details.");
		}

		internal static void HandleNearby(Plugin self, ConsoleEventArgs args)
		{
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0733: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				args.Context.AddString("ShaderHelperForMac: no local player found.");
				return;
			}
			float num = 30f;
			bool flag = false;
			string nbDllFilter = string.Empty;
			for (int i = 2; i < args.Length; i++)
			{
				float result;
				if (args[i].Equals("mod", StringComparison.OrdinalIgnoreCase))
				{
					flag = true;
				}
				else if (float.TryParse(args[i], out result))
				{
					num = result;
				}
				else
				{
					nbDllFilter = args[i];
				}
			}
			if (!string.IsNullOrEmpty(nbDllFilter))
			{
				string text = Plugin.ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase));
				if (text != null)
				{
					nbDllFilter = text;
				}
				else
				{
					flag = true;
					args.Context.AddString("ShaderHelperForMac: '" + nbDllFilter + "' not in scan results (large embedded bundle) — applying mod filter to exclude vanilla materials.");
				}
			}
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			int num2 = 0;
			Renderer[] array2 = array;
			foreach (Renderer val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				float num4 = Vector3.Distance(((Component)val).transform.position, ((Component)localPlayer).transform.position);
				if (num4 > num)
				{
					continue;
				}
				string name = ((object)val).GetType().Name;
				Transform parent = ((Component)val).transform.parent;
				string text2 = ((parent != null) ? ((Object)parent).name : null) ?? "(root)";
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if ((Object)(object)val2 == (Object)null || (Object)(object)val2.shader == (Object)null)
					{
						continue;
					}
					Plugin.ModShaderDlls.TryGetValue(((Object)val2.shader).name, out string value);
					if (!string.IsNullOrEmpty(nbDllFilter))
					{
						bool flag2 = value != null;
						if ((flag2 && !value.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase)) || (!flag2 && Plugin.ModShaderDlls.Values.Any((string d) => d.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase))))
						{
							continue;
						}
					}
					if (flag)
					{
						string item = Plugin.StripInstance(((Object)val2).name);
						bool flag3 = Plugin._baselineMatNames.Contains(item);
						bool flag4 = Plugin._vanillaShaderNames.Contains(((Object)val2.shader).name) || Plugin.ValheimShaderNameSet.Contains(((Object)val2.shader).name) || Plugin.UnityBuiltInShaderNameSet.Contains(((Object)val2.shader).name);
						bool flag5 = Plugin.CanonicalShaderIds.Contains(((Object)val2.shader).GetInstanceID());
						bool flag6 = flag4 || flag5;
						bool flag7 = Plugin._prefabScopedModMatIds.Contains(((Object)val2).GetInstanceID());
						if (flag3 && flag6 && !flag7)
						{
							continue;
						}
					}
					ShaderAction action = Plugin.GetAction(val2);
					string text3 = (val2.HasProperty("_Color") ? ((object)val2.color/*cast due to .constrained prefix*/).ToString() : "n/a");
					string item2 = Plugin.StripInstance(((Object)val2).name);
					bool flag8 = Plugin._baselineMatNames.Contains(item2);
					bool flag9 = Plugin._vanillaShaderNames.Contains(((Object)val2.shader).name) || Plugin.ValheimShaderNameSet.Contains(((Object)val2.shader).name) || Plugin.UnityBuiltInShaderNameSet.Contains(((Object)val2.shader).name);
					bool flag10 = Plugin.CanonicalShaderIds.Contains(((Object)val2.shader).GetInstanceID());
					bool flag11 = flag9 || flag10;
					bool flag12 = Plugin._prefabScopedModMatIds.Contains(((Object)val2).GetInstanceID());
					bool flag13 = !(flag8 && flag11) || flag12;
					bool flag14 = (!Plugin.CanonicalShaderIds.Contains(((Object)val2.shader).GetInstanceID()) || Plugin.IsAggressivelySwappable(((Object)val2.shader).name)) && !Plugin.ValheimShaderNameSet.Contains(((Object)val2.shader).name) && (!ShaderScanner.IsLikelySafeShader(((Object)val2.shader).name) || Plugin.IsAggressivelySwappable(((Object)val2.shader).name));
					string text4 = ((action == ShaderAction.Original && flag13 && flag14) ? "yes" : "no");
					Plugin.Log.LogInfo((object)string.Format("[Near] dist={0:F1}  type={1}  parent='{2}'  go='{3}'  mat:{4}  shader='{5}'  supported={6}  action={7}  patch={8}  color={9}  dll='{10}'", num4, name, text2, ((Object)((Component)val).gameObject).name, Plugin.StripInstance(((Object)val2).name), ((Object)val2.shader).name, val2.shader.isSupported, action, text4, text3, value ?? "unknown"));
					num2++;
				}
			}
			CanvasRenderer[] array3 = Resources.FindObjectsOfTypeAll<CanvasRenderer>();
			CanvasRenderer[] array4 = array3;
			foreach (CanvasRenderer val3 in array4)
			{
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				float num7 = Vector3.Distance(((Component)val3).transform.position, ((Component)localPlayer).transform.position);
				if (num7 > num)
				{
					continue;
				}
				int materialCount = val3.materialCount;
				for (int num8 = 0; num8 < materialCount; num8++)
				{
					Material material = val3.GetMaterial(num8);
					if ((Object)(object)material == (Object)null || (Object)(object)material.shader == (Object)null)
					{
						continue;
					}
					Plugin.ModShaderDlls.TryGetValue(((Object)material.shader).name, out string value2);
					if (!string.IsNullOrEmpty(nbDllFilter))
					{
						bool flag15 = value2 != null;
						if ((flag15 && !value2.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase)) || (!flag15 && Plugin.ModShaderDlls.Values.Any((string d) => d.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase))))
						{
							continue;
						}
					}
					if (!flag || (!Plugin.CanonicalShaderIds.Contains(((Object)material.shader).GetInstanceID()) && !Plugin.ValheimShaderNameSet.Contains(((Object)material.shader).name) && !ShaderScanner.IsLikelySafeShader(((Object)material.shader).name)))
					{
						ShaderAction action2 = Plugin.GetAction(material);
						string text5 = (material.HasProperty("_Color") ? ((object)material.color/*cast due to .constrained prefix*/).ToString() : "n/a");
						Transform parent2 = ((Component)val3).transform.parent;
						string text6 = ((parent2 != null) ? ((Object)parent2).name : null) ?? "(root)";
						string text7 = ((Plugin.NeedsReplacement(material) && action2 == ShaderAction.Original && value2 != null) ? "yes" : "no");
						Plugin.Log.LogInfo((object)string.Format("[Near] dist={0:F1}  type=CanvasRenderer  parent='{1}'  go='{2}'  mat:{3}  shader='{4}'  supported={5}  action={6}  patch={7}  color={8}  dll='{9}'", num7, text6, ((Object)((Component)val3).gameObject).name, Plugin.StripInstance(((Object)material).name), ((Object)material.shader).name, material.shader.isSupported, action2, text7, text5, value2 ?? "unknown"));
						num2++;
					}
				}
			}
			string arg = ((!string.IsNullOrEmpty(nbDllFilter)) ? (" from '" + nbDllFilter + "'") : (flag ? " (mod filter)" : string.Empty));
			args.Context.AddString($"ShaderHelperForMac: found {num2} materials within {num} units{arg}. Check BepInEx/LogOutput.log.");
		}

		internal static void HandleCheckVanilla(Plugin self, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper checkvanilla <Name> [Name2] ...");
				args.Context.AddString("Reports whether each name is in any vanilla / mod-attribution set the plugin tracks.");
				return;
			}
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			for (int i = 2; i < args.Length; i++)
			{
				string text = args[i];
				string text2 = Plugin.StripInstance(text);
				bool flag = Plugin._baselineMatNames.Contains(text2);
				bool flag2 = Plugin._vanillaBundleNames.Contains(text);
				bool flag3 = Plugin.ValheimShaderNameSet.Contains(text);
				bool flag4 = Plugin.UnityBuiltInShaderNameSet.Contains(text);
				string value;
				bool flag5 = Plugin.ModShaderDlls.TryGetValue(text, out value);
				int num = 0;
				int num2 = 0;
				Material[] array2 = array;
				foreach (Material val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && Plugin.StripInstance(((Object)val).name).Equals(text2, StringComparison.OrdinalIgnoreCase))
					{
						num++;
						if (Plugin._prefabScopedModMatIds.Contains(((Object)val).GetInstanceID()))
						{
							num2++;
						}
					}
				}
				CvEmit("'" + text + "' base='" + text2 + "'");
				CvEmit($"  vanilla: baselineMat={flag}  vanillaBundle={flag2}  valheimShader={flag3}  unityBuiltinShader={flag4}");
				List<string> list = new List<string>();
				if (flag5)
				{
					list.Add("modShader(dll='" + value + "')");
				}
				CvEmit("  modAttribution: " + ((list.Count == 0) ? "<none>" : string.Join("  ", list)));
				if (num > 0)
				{
					CvEmit($"  liveInstances: {num}  prefabScopedTagged={num2}/{num}  (lane-5 option-3 veto-breaker)");
				}
				else
				{
					CvEmit("  liveInstances: 0  (no Material currently in memory carries this base name)");
				}
				string text3 = ((Plugin._baselineMatNames.Count > 0 || Plugin._vanillaShaderNames.Count > 0) ? $"cache (mats={Plugin._baselineMatNames.Count}, shaders={Plugin._vanillaShaderNames.Count}, bundles={Plugin._vanillaBundleNames.Count})" : "missing — name-side veto DISARMED; run `shaderhelper capturevanilla` from a clean install");
				CvEmit("  source: " + text3);
				string text4 = ((!flag) ? ((!flag2) ? ((!(flag3 || flag4)) ? ((!flag5 && num2 <= 0) ? ((num <= 0) ? "UNKNOWN — name not in any tracked set and no live Material in memory carries this base name." : "UNKNOWN — name is not in any vanilla set and not in any mod-attribution set; live instance(s) exist but the option-3 gate's name-side veto will fire UNLESS the material's shader is mod-owned (in which case the gate admits via shader-side).") : "MOD-OWNED — name is tagged in Plugin.ModShaderDlls and/or has a live instance under a [prefab]-scoped ancestor; replacement is permitted by the option-3 gate.") : "VANILLA SHADER — name matches a Valheim or Unity built-in shader name (Plugin.CanonicalShaderIds-equivalent name set).") : "VANILLA — name matches a vanilla AssetBundle name in Plugin._vanillaBundleNames.") : "VANILLA — name is in Plugin._baselineMatNames (Valheim-shipped material name set; replacement is structurally blocked by the option-3 gate).");
				CvEmit("  verdict: " + text4);
			}
			void CvEmit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[CheckVanilla] " + line));
			}
		}

		internal static void HandleExplain(Plugin self, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper explain <MaterialName> [MaterialName2] ...");
				args.Context.AddString("Shows the ordered rule evaluation for why a material lands on Fallback / Transparent / Original.");
				return;
			}
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			for (int i = 2; i < args.Length; i++)
			{
				string text = args[i];
				string text2 = Plugin.StripInstance(text);
				List<Material> list = new List<Material>();
				Material[] array2 = array;
				foreach (Material val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && Plugin.StripInstance(((Object)val).name).Equals(text2, StringComparison.OrdinalIgnoreCase))
					{
						list.Add(val);
					}
				}
				List<string> list2 = new List<string>();
				foreach (Material item7 in list)
				{
					if (!((Object)(object)item7 == (Object)null) && ReplacementCore._replacedMats.TryGetValue(((Object)item7).GetInstanceID(), out (string, ShaderAction) value))
					{
						object[] obj = new object[4]
						{
							((Object)item7).GetInstanceID(),
							value.Item1,
							value.Item2,
							null
						};
						Shader shader = item7.shader;
						obj[3] = ((shader != null) ? ((Object)shader).name : null) ?? "<null>";
						list2.Add(string.Format("  ⟲ HISTORY  id={0}  '{1}' → {2} (current shader: '{3}')", obj));
					}
				}
				if (list.Count > 1)
				{
					string text3 = $"[Explain] '{text2}' has {list.Count} live material(s) in memory — tracing each:";
					Plugin.Log.LogInfo((object)text3);
					args.Context.AddString(text3);
				}
				foreach (string item8 in list2)
				{
					Plugin.Log.LogInfo((object)item8);
					args.Context.AddString(item8);
				}
				if (list.Count > 0)
				{
					foreach (Material item9 in list)
					{
						ResolveTrace resolveTrace = new ResolveTrace();
						List<(string, ShaderAction)> list3 = new List<(string, ShaderAction)>();
						ShaderAction shaderAction = ActionResolver.Resolve(item9, resolveTrace);
						Plugin.ModShaderDlls.TryGetValue(((Object)item9.shader).name, out string value2);
						bool flag = Plugin._baselineMatNames.Contains(text2);
						bool flag2 = Plugin._vanillaShaderNames.Contains(((Object)item9.shader).name) || Plugin.ValheimShaderNameSet.Contains(((Object)item9.shader).name) || Plugin.UnityBuiltInShaderNameSet.Contains(((Object)item9.shader).name);
						bool flag3 = Plugin.CanonicalShaderIds.Contains(((Object)item9.shader).GetInstanceID());
						bool flag4 = flag2 || flag3;
						bool flag5 = Plugin._prefabScopedModMatIds.Contains(((Object)item9).GetInstanceID());
						bool flag6 = !(flag && flag4) || flag5;
						string text4 = string.Format("[Explain] mat='{0}'  matId={1}  shader='{2}'  shaderId={3}  supported={4}  dll='{5}'  optionGate={6} (nameInBaseline={7}, shaderVanillaByName={8}, shaderCanonicalById={9}, prefabScopeOverride={10})", text2, ((Object)item9).GetInstanceID(), ((Object)item9.shader).name, ((Object)item9.shader).GetInstanceID(), item9.shader.isSupported, value2 ?? "unknown", flag6 ? "PASS" : "FAIL", flag, flag2, flag3, flag5);
						if (Plugin._sweepDisabled)
						{
							string text5 = "[Explain] WARNING: Plugin._sweepDisabled=true (vanilla truth file empty). The replacement sweep will refuse on every trigger this session, regardless of the gate verdict above. Run `shaderhelper capturevanilla` from a clean install.";
							Plugin.Log.LogWarning((object)text5);
							args.Context.AddString(text5);
						}
						ShaderAction shaderAction2;
						string value3;
						if (!flag6)
						{
							list3.Add(("provenance gate FAIL → sweep skips this material (final=Original)", ShaderAction.Original));
							shaderAction2 = ShaderAction.Original;
						}
						else if (Plugin._matShaderOverrides.TryGetValue(text2, out value3))
						{
							list3.Add(("[useshader] override → binds resolved shader '" + value3 + "' (UseShader action — NOT the FallbackShader/Custom/Creature)", ShaderAction.UseShader));
							shaderAction2 = ShaderAction.UseShader;
						}
						else
						{
							bool flag7 = Plugin.IsHardMatRule(item9);
							bool flag8 = Plugin.CanonicalShaderIds.Contains(((Object)item9.shader).GetInstanceID());
							bool flag9 = Plugin.IsAggressivelySwappable(((Object)item9.shader).name);
							bool flag10 = Plugin.IsForceTransparent(((Object)item9.shader).name) || Plugin.IsForceFallback(((Object)item9.shader).name);
							if (flag8 && !flag7 && !flag9 && !flag10)
							{
								list3.Add(("canonical shader ID (vanilla-instance) + no hard rule + not aggressive + no force-prefix → skip (final=Original)", ShaderAction.Original));
								shaderAction2 = ShaderAction.Original;
							}
							else if (flag9 && !flag7)
							{
								list3.Add(("aggressive-family '" + ((Object)item9.shader).name + "' + no hard rule → Fallback default", ShaderAction.Fallback));
								shaderAction2 = ShaderAction.Fallback;
							}
							else
							{
								shaderAction2 = shaderAction;
								if (shaderAction2 == ShaderAction.Original)
								{
									bool flag11 = Plugin.IsParticleLikePublic(item9);
									ShaderAction shaderAction3 = ((!flag11) ? ShaderAction.Fallback : ShaderAction.Transparent);
									list3.Add(($"v2.1.0 auto-default: resolver→Original + gate-admitted + Plugin.IsParticleLike={flag11} → {shaderAction3}", shaderAction3));
									shaderAction2 = shaderAction3;
								}
							}
						}
						Plugin.Log.LogInfo((object)text4);
						args.Context.AddString(text4);
						foreach (var step in resolveTrace.Steps)
						{
							string item = step.reason;
							ShaderAction item2 = step.action;
							string text6 = $"  → {item2,-11}  {item}";
							Plugin.Log.LogInfo((object)text6);
							args.Context.AddString(text6);
						}
						if (list3.Count > 0)
						{
							string text7 = $"  resolver → {shaderAction}";
							Plugin.Log.LogInfo((object)text7);
							args.Context.AddString(text7);
							foreach (var item10 in list3)
							{
								string item3 = item10.Item1;
								ShaderAction item4 = item10.Item2;
								string text8 = $"  ↪ {item4,-11}  {item3}";
								Plugin.Log.LogInfo((object)text8);
								args.Context.AddString(text8);
							}
						}
						string text9 = $"[Explain] {text2}  matId={((Object)item9).GetInstanceID()}: effective action = {shaderAction2}" + ((list3.Count > 0 && shaderAction2 != shaderAction) ? $"  (resolver said {shaderAction}; overridden by sweep logic)" : "");
						Plugin.Log.LogInfo((object)text9);
						args.Context.AddString(text9);
					}
					continue;
				}
				if (Plugin.CheckMatNameRules(text2, out ShaderAction action, out string reason))
				{
					bool flag12 = Plugin._baselineMatNames.Contains(text2);
					string text10 = "[Explain] no live material named '" + text2 + "' — but a material-name rule IS configured:";
					Plugin.Log.LogInfo((object)text10);
					args.Context.AddString(text10);
					string text11 = $"  ✓ {action,-11}  {reason}";
					Plugin.Log.LogInfo((object)text11);
					args.Context.AddString(text11);
					string text12 = $"  option-3 gate: nameInBaseline={flag12}  " + (flag12 ? "(name is vanilla — option-3 veto will fire if the future material's shader is also vanilla; declare a [prefab] scope to break the veto for a same-named mod material)" : "(name is not vanilla — option-3 admits; rule will fire when the material loads)");
					Plugin.Log.LogInfo((object)text12);
					args.Context.AddString(text12);
					string text13 = $"[Explain] {text2}: action when material loads = {action} (dry-run — spawn/equip the item for a full trace)";
					Plugin.Log.LogInfo((object)text13);
					args.Context.AddString(text13);
					continue;
				}
				ResolveTrace resolveTrace2 = new ResolveTrace();
				ShaderAction shaderAction4 = ActionResolver.ResolveByShaderName(text, resolveTrace2);
				ShaderAction shaderAction5 = shaderAction4;
				string text14 = "[Explain] no live material named '" + text2 + "' — tracing as shader name '" + text + "'";
				Plugin.Log.LogInfo((object)text14);
				args.Context.AddString(text14);
				foreach (var step2 in resolveTrace2.Steps)
				{
					string item5 = step2.reason;
					ShaderAction item6 = step2.action;
					string text15 = $"  → {item6,-11}  {item5}";
					Plugin.Log.LogInfo((object)text15);
					args.Context.AddString(text15);
				}
				string text16 = $"[Explain] {text2}: effective action = {shaderAction5}";
				Plugin.Log.LogInfo((object)text16);
				args.Context.AddString(text16);
			}
		}

		internal static void HandleCheckRedesign(Plugin self, ConsoleEventArgs args)
		{
			Plugin.PopulateLane5FromSceneWalk();
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			int num = 0;
			int num2 = 0;
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			Material[] array2 = array;
			foreach (Material val in array2)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null || (Object)(object)val == (Object)(object)Plugin._transparentMat || (Object)(object)val == (Object)(object)Plugin._fallbackMat)
				{
					continue;
				}
				num++;
				if (Plugin.ModShaderDlls.TryGetValue(((Object)val.shader).name, out string value) && !string.IsNullOrEmpty(value))
				{
					if (!dictionary.ContainsKey(value))
					{
						dictionary[value] = 0;
					}
					dictionary[value]++;
				}
				else
				{
					num2++;
				}
			}
			int num3 = num - num2;
			Plugin.Log.LogInfo((object)$"[CheckRedesign] coverage: total={num} (matched-DLL={num3} unattributed={num2})");
			foreach (KeyValuePair<string, int> item in dictionary.OrderByDescending((KeyValuePair<string, int> p) => p.Value).ThenBy<KeyValuePair<string, int>, string>((KeyValuePair<string, int> p) => p.Key, StringComparer.Ordinal))
			{
				Plugin.Log.LogInfo((object)$"[CheckRedesign]   dll='{item.Key}'  materials={item.Value}");
			}
			Plugin.Log.LogInfo((object)$"[CheckRedesign]   dll='<unattributed>'  materials={num2}");
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			int num11 = 0;
			Material[] array3 = array;
			foreach (Material val2 in array3)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2.shader == (Object)null || (Object)(object)val2 == (Object)(object)Plugin._transparentMat || (Object)(object)val2 == (Object)(object)Plugin._fallbackMat)
				{
					continue;
				}
				num4++;
				string text = Plugin.StripInstance(((Object)val2).name);
				int instanceID = ((Object)val2).GetInstanceID();
				int instanceID2 = ((Object)val2.shader).GetInstanceID();
				string name = ((Object)val2.shader).name;
				bool flag = Plugin.IsJVLMockShader(name);
				bool flag2 = Plugin._baselineMatNames.Contains(text);
				bool flag3 = Plugin._vanillaShaderNames.Contains(name) || Plugin.ValheimShaderNameSet.Contains(name) || Plugin.UnityBuiltInShaderNameSet.Contains(name);
				bool flag4 = Plugin.CanonicalShaderIds.Contains(instanceID2);
				bool flag5 = flag3 || flag4;
				bool flag6 = Plugin._prefabScopedModMatIds.Contains(instanceID);
				bool gateAdmits = !flag && (!(flag2 && flag5) || flag6);
				ShaderAction shaderAction = ResolveEffective(gateAdmits, val2);
				bool flag7 = shaderAction != ShaderAction.Original;
				if (!flag7)
				{
					num5++;
				}
				else
				{
					num6++;
					switch (shaderAction)
					{
					case ShaderAction.Fallback:
						num7++;
						break;
					case ShaderAction.Transparent:
						num8++;
						break;
					case ShaderAction.UseShader:
						num9++;
						break;
					}
				}
				bool flag8 = flag2 && flag5 && !flag6;
				if (flag8 && flag7)
				{
					num10++;
					if (num11 < 200)
					{
						Plugin.Log.LogWarning((object)$"[CheckRedesign-Vanilla] mat='{text}' shader='{name}' matId={instanceID} shaderId={instanceID2} liveAction={shaderAction}  // TRUE vanilla leak (name+shader both vanilla, no prefab opt-in, but the live gate replaces)");
						num11++;
					}
				}
			}
			string text2 = $"[CheckRedesign] live-gate: total={num4} skip={num5} replace={num6} (fallback={num7} transparent={num8} useshader={num9}) vanilla-leaks={num10}";
			Plugin.Log.LogInfo((object)text2);
			if (num11 >= 200 && num10 > 200)
			{
				Plugin.Log.LogWarning((object)$"[CheckRedesign-Vanilla] (per-material vanilla-leak logs capped at {200}; {num10 - 200} additional lines suppressed)");
			}
			args.Context.AddString(text2);
			args.Context.AddString($"Coverage: {num} mat(s) total, {dictionary.Count} mod DLL(s) attributed; see [CheckRedesign] coverage block in log.");
			args.Context.AddString("v3.0.x correctness criterion: vanilla-leaks=0. The presence of any non-zero vanilla-leaks count is a vanilla-protection regression that must be triaged before any further v3.0.x release.");
			if (Plugin._baselineMatNames.Count == 0 && Plugin._vanillaShaderNames.Count == 0)
			{
				args.Context.AddString("WARNING: vanilla truth file is empty (no `Plugin._baselineMatNames`, no `Plugin._vanillaShaderNames`) — option-3 gate degenerates to admit-everything. The replacement sweep is Plugin._sweepDisabled (no replacements occur), but the report above will show an inflated `replace=` count if anything reached the gate. Run `shaderhelper capturevanilla` from a clean install before trusting these numbers.");
			}
			static ShaderAction ResolveEffective(bool flag9, Material mat)
			{
				if (!flag9)
				{
					return ShaderAction.Original;
				}
				if (Plugin.IsJVLMockShader(((Object)mat.shader).name))
				{
					return ShaderAction.Original;
				}
				bool flag10 = Plugin.IsHardMatRule(mat);
				string key = Plugin.StripInstance(((Object)mat).name);
				if (Plugin._matShaderOverrides.ContainsKey(key))
				{
					return ShaderAction.UseShader;
				}
				int instanceID3 = ((Object)mat.shader).GetInstanceID();
				if (Plugin.CanonicalShaderIds.Contains(instanceID3) && !flag10 && !Plugin.IsAggressivelySwappable(((Object)mat.shader).name))
				{
					return ShaderAction.Original;
				}
				if (Plugin.IsAggressivelySwappable(((Object)mat.shader).name) && !flag10)
				{
					return ShaderAction.Fallback;
				}
				ShaderAction shaderAction2 = ActionResolver.Resolve(mat);
				if (shaderAction2 == ShaderAction.Original)
				{
					return (!Plugin.IsParticleLike(mat)) ? ShaderAction.Fallback : ShaderAction.Transparent;
				}
				return shaderAction2;
			}
		}
	}
	internal static class InfoCommands
	{
		public static void HandleClassify(Plugin self, ConsoleEventArgs args)
		{
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			int num = 50;
			if (args.Length > 2 && int.TryParse(args[2], out var result) && result > 0)
			{
				num = result;
			}
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			int num11 = 0;
			int num12 = 0;
			int num13 = 0;
			int num14 = 0;
			int num15 = 0;
			int num16 = 0;
			List<string> list = new List<string>();
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			HashSet<int> hashSet = new HashSet<int>();
			Renderer[] array2 = array;
			foreach (Renderer val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				num2++;
				string name = ((object)val).GetType().Name;
				Transform parent = ((Component)val).transform.parent;
				string text = ((parent != null) ? ((Object)parent).name : null) ?? "(root)";
				GameObject gameObject = ((Component)val).gameObject;
				string text2 = ((gameObject != null) ? ((Object)gameObject).name : null) ?? "(?)";
				Material[] sharedMaterials = val.sharedMaterials;
				foreach (Material val2 in sharedMaterials)
				{
					if ((Object)(object)val2 == (Object)null || (Object)(object)val2.shader == (Object)null)
					{
						continue;
					}
					int instanceID = ((Object)val2).GetInstanceID();
					if (!hashSet.Add(instanceID))
					{
						continue;
					}
					num3++;
					string text3 = Plugin.StripInstancePublic(((Object)val2).name);
					bool flag = Plugin._baselineMatNames.Contains(text3);
					bool flag2 = Plugin._vanillaShaderNames.Contains(((Object)val2.shader).name) || Plugin.CanonicalShaderIds.Contains(((Object)val2.shader).GetInstanceID());
					bool flag3 = !(flag && flag2);
					if (!flag3 && Plugin._prefabScopedModMatIds.Contains(instanceID))
					{
						flag3 = true;
					}
					if (!flag3)
					{
						continue;
					}
					num4++;
					bool flag4 = Plugin.IsErrorPinkPublic(val2);
					bool flag5 = Plugin.IsParticleLikeShaderName(((Object)val2.shader).name);
					bool flag6 = Plugin.IsHdrEmission(val2);
					bool flag7 = flag4 || flag5 || flag6;
					bool flag8 = flag6 && !flag4 && !flag5;
					bool flag9 = val is MeshRenderer || val is SkinnedMeshRenderer;
					bool flag10 = val is ParticleSystemRenderer;
					if (flag9)
					{
						if (flag4)
						{
							num7++;
						}
						if (flag5)
						{
							num6++;
						}
						if (flag8)
						{
							num5++;
						}
						if (!flag7)
						{
							num8++;
						}
					}
					else if (flag10)
					{
						if (flag4)
						{
							num11++;
						}
						if (flag5)
						{
							num10++;
						}
						if (flag8)
						{
							num9++;
						}
						if (!flag7)
						{
							num12++;
						}
					}
					else
					{
						if (flag4)
						{
							num15++;
						}
						if (flag5)
						{
							num14++;
						}
						if (flag8)
						{
							num13++;
						}
						if (!flag7)
						{
							num16++;
						}
					}
					if (flag9 && flag8 && list.Count < num)
					{
						Plugin.ModShaderDlls.TryGetValue(((Object)val2.shader).name, out string value);
						Color val3 = (Color)(val2.HasProperty("_EmissionColor") ? val2.GetColor("_EmissionColor") : default(Color));
						list.Add("  parent='" + text + "' go='" + text2 + "' mat:" + text3 + "  shader='" + ((Object)val2.shader).name + "'  " + $"emission=RGBA({val3.r:F3},{val3.g:F3},{val3.b:F3},{val3.a:F3})  " + "dll='" + (value ?? "unknown") + "'");
					}
				}
			}
			EmitC("=== Classify: scene-wide IsParticleLike signal histogram ===");
			EmitC($"renderers walked: {num2}");
			EmitC($"materials probed: {num3}");
			EmitC($"materials eligible (option-3 admit): {num4}");
			EmitC("");
			EmitC("Histogram (counts where each signal fires; soleHdr = HDR signal but no errorPink AND no particle-keyword shader name):");
			EmitC("                       errorPink   particle-kw   sole-HDR   no-signal-Fallback");
			EmitC($"  MeshRenderer/SMR:    {num7,9}   {num6,11}   {num5,8}   {num8,18}");
			EmitC($"  ParticleSystemR:     {num11,9}   {num10,11}   {num9,8}   {num12,18}");
			EmitC($"  Other:               {num15,9}   {num14,11}   {num13,8}   {num16,18}");
			EmitC("");
			EmitC("The 'sole-HDR' column on the MeshRenderer/SMR row is the count of materials at risk of");
			EmitC("the v2.1.0 auto-default mis-classifying them as Transparent (invisible) when the user wants");
			EmitC("Fallback (solid). When this number is small (<=10), per-material `mat:` rules under");
			EmitC("[forcefallback] in the owning mod's <DllName>.txt are the documented remedy. When it is");
			EmitC("large (>=20), the v2.1.0 classifier itself is the structural failure point — see CHANGELOG");
			EmitC("v3.0.22 for the cost/benefit of a heuristic refinement vs. additional manual rules.");
			if (list.Count <= 0)
			{
				return;
			}
			EmitC("");
			EmitC($"=== Up to {num} per-material rows for MeshRenderer + sole-HDR-emission ===");
			foreach (string item in list)
			{
				EmitC(item);
			}
			if (num5 > list.Count)
			{
				EmitC($"  ... and {num5 - list.Count} more (raise the cap with `shaderhelper classify <N>`)");
			}
			void EmitC(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[Classify] " + line));
			}
		}

		public static void HandleDumpPrefabMap(Plugin self, ConsoleEventArgs args)
		{
			string pmFilter = ((args.Length > 2) ? args[2] : string.Empty);
			bool pmHasFilter = !string.IsNullOrEmpty(pmFilter);
			string pmCanon = null;
			if (pmHasFilter)
			{
				pmCanon = Plugin._prefabRootToDll.Values.FirstOrDefault((string d) => d.Equals(pmFilter, StringComparison.OrdinalIgnoreCase));
				if (pmCanon == null)
				{
					pmCanon = pmFilter;
				}
			}
			DumpEmit($"ShaderHelperForMac: _prefabRootToDll has {Plugin._prefabRootToDll.Count} entry(s).");
			List<IGrouping<string, KeyValuePair<string, string>>> list = Plugin._prefabRootToDll.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> kv) => !pmHasFilter || kv.Value.Equals(pmCanon, StringComparison.OrdinalIgnoreCase)).GroupBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Value, StringComparer.OrdinalIgnoreCase).OrderBy<IGrouping<string, KeyValuePair<string, string>>, string>((IGrouping<string, KeyValuePair<string, string>> g) => g.Key, StringComparer.Ordinal)
				.ToList();
			foreach (IGrouping<string, KeyValuePair<string, string>> item in list)
			{
				DumpEmit($"  {item.Key}  ({item.Count()} prefab-root(s)):");
				foreach (KeyValuePair<string, string> item2 in item.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> k) => k.Key, StringComparer.Ordinal))
				{
					DumpEmit("    " + item2.Key);
				}
			}
			if (pmHasFilter && list.Count == 0)
			{
				DumpEmit("  (no prefab-root attributions for '" + pmCanon + "')");
			}
			void DumpEmit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[PrefabMap] " + line));
			}
		}

		public static void HandleSuggest(Plugin self, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper suggest <DllName> [write]");
				args.Context.AddString("       (no `write` arg = dry-run; pass `write` to append the block to <DllName>.txt)");
				return;
			}
			string sgDllArg = args[2];
			bool flag = args.Length > 3 && args[3].Equals("write", StringComparison.OrdinalIgnoreCase);
			string sgDllName = Plugin._prefabRootToDll.Values.FirstOrDefault((string d) => d.Equals(sgDllArg, StringComparison.OrdinalIgnoreCase)) ?? sgDllArg;
			List<string> list = (from kv in Plugin._prefabRootToDll
				where kv.Value.Equals(sgDllName, StringComparison.OrdinalIgnoreCase)
				select kv.Key).OrderBy<string, string>((string n) => n, StringComparer.Ordinal).ToList();
			if (list.Count == 0)
			{
				args.Context.AddString("ShaderHelperForMac: no prefab-root attributions for '" + sgDllName + "'.");
				args.Context.AddString("Run 'shaderhelper dumpprefabmap' to see what's currently captured.");
				return;
			}
			string text = Path.Combine(Plugin.ConfigDir, sgDllName + ".txt");
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (File.Exists(text))
			{
				string[] array;
				try
				{
					array = File.ReadAllLines(text);
				}
				catch
				{
					array = Array.Empty<string>();
				}
				string text2 = string.Empty;
				string[] array2 = array;
				foreach (string text3 in array2)
				{
					string text4 = text3.TrimStart(Array.Empty<char>());
					string text5 = text4.TrimStart(new char[1] { '#' }).TrimStart(Array.Empty<char>());
					if (text5.StartsWith("[") && text5.EndsWith("]"))
					{
						text2 = text5.Substring(1, text5.Length - 2).ToLowerInvariant();
					}
					else if (text2.Equals("prefab", StringComparison.Ordinal))
					{
						string text6 = text5;
						int num2 = Plugin.IndexOfInlineComment(text6);
						if (num2 >= 0)
						{
							text6 = text6.Substring(0, num2);
						}
						text6 = text6.Trim();
						if (text6.Length > 0)
						{
							hashSet.Add(text6);
						}
					}
				}
			}
			List<string> list2 = new List<string>();
			int num3 = 0;
			int num4 = 0;
			foreach (string item in list)
			{
				if (Plugin._baselineMatNames.Contains(item))
				{
					num3++;
				}
				else if (hashSet.Contains(item))
				{
					num4++;
				}
				else
				{
					list2.Add(item);
				}
			}
			if (list2.Count == 0)
			{
				args.Context.AddString("ShaderHelperForMac: no new [prefab] lines to suggest for '" + sgDllName + "'.");
				args.Context.AddString($"  Captured: {list.Count}, already-present: {num4}, vanilla-name skipped: {num3}.");
				return;
			}
			args.Context.AddString($"ShaderHelperForMac: would add {list2.Count} [prefab] line(s) to '{sgDllName}.txt' (skipped {num4} already-present, {num3} vanilla-name colliding).");
			Plugin.Log.LogInfo((object)$"[Suggest] '{sgDllName}': {list2.Count} new [prefab] line(s) proposed:");
			foreach (string item2 in list2)
			{
				Plugin.Log.LogInfo((object)("[Suggest]   " + item2));
			}
			if (!flag)
			{
				args.Context.AddString("Dry-run: nothing written. Re-run with `write` to append:");
				args.Context.AddString("  shaderhelper suggest " + sgDllName + " write");
				return;
			}
			try
			{
				Directory.CreateDirectory(Plugin.ConfigDir);
				string text7 = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
				StringBuilder stringBuilder = new StringBuilder();
				if (File.Exists(text) && new FileInfo(text).Length > 0)
				{
					stringBuilder.AppendLine();
				}
				stringBuilder.AppendLine("# ─── shaderhelper suggest (" + text7 + ") ───");
				stringBuilder.AppendLine("# Auto-generated from the v2.1.9 prefab-root → DLL capture map.");
				stringBuilder.AppendLine("# Each line below is a GameObject root name observed in this mod's bundle at");
				stringBuilder.AppendLine("# load/tag time. Declaring them under [prefab] scopes any subsequent mat:");
				stringBuilder.AppendLine("# / suffix: rule to only fire on renderers under these ancestors — the safe");
				stringBuilder.AppendLine("# remediation for vanilla-name-collision materials (see CHANGELOG v2.0.17).");
				stringBuilder.AppendLine("# Review, delete any false positives, then save — the reload picks it up.");
				stringBuilder.AppendLine("[prefab]");
				foreach (string item3 in list2)
				{
					stringBuilder.AppendLine(item3);
				}
				stringBuilder.AppendLine("# ─── end suggest ───");
				File.AppendAllText(text, stringBuilder.ToString());
				Plugin.ReloadConfigFiles();
				args.Context.AddString($"ShaderHelperForMac: appended {list2.Count} [prefab] line(s) to '{text}'.");
				args.Context.AddString("Config reloaded. Lane-5 scope will apply on the next sweep.");
				Plugin.Log.LogInfo((object)$"[Suggest] Wrote {list2.Count} [prefab] line(s) to '{text}' and reloaded config.");
			}
			catch (Exception ex)
			{
				args.Context.AddString("ShaderHelperForMac: failed to write '" + text + "': " + ex.Message);
			}
		}

		public static void HandlePrefab(Plugin self, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper prefab <PrefabName>");
				args.Context.AddString("       (case-insensitive substring match on the GameObject name; (Clone) suffix is stripped before matching)");
				return;
			}
			string text = args[2];
			List<GameObject> list = new List<GameObject>();
			HashSet<int> hashSet = new HashSet<int>();
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			foreach (GameObject val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string text2 = Plugin.StripCloneSuffix(((Object)val).name);
					if (text2.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0 && hashSet.Add(((Object)val).GetInstanceID()))
					{
						list.Add(val);
					}
				}
			}
			if (list.Count == 0)
			{
				args.Context.AddString("ShaderHelperForMac: no GameObject matched '" + text + "'.");
				args.Context.AddString("  Try `shaderhelper dumpprefabmap` for a list of captured mod-owned prefab roots, or use a shorter substring.");
				return;
			}
			int num = 0;
			int num2 = 0;
			HashSet<int> hashSet2 = new HashSet<int>();
			foreach (GameObject item in list)
			{
				string name = ((Object)item).name;
				string arg = Plugin.StripCloneSuffix(name);
				Renderer[] componentsInChildren = item.GetComponentsInChildren<Renderer>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					Plugin.Log.LogInfo((object)("[Prefab] root='" + name + "'  (no renderers in hierarchy)"));
					continue;
				}
				Plugin.Log.LogInfo((object)$"[Prefab] root='{name}'  stripped='{arg}'  renderers={componentsInChildren.Length}");
				Renderer[] array2 = componentsInChildren;
				foreach (Renderer val2 in array2)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					StringBuilder stringBuilder = new StringBuilder();
					Transform val3 = ((Component)val2).transform;
					while ((Object)(object)val3 != (Object)null && (Object)(object)((Component)val3).gameObject != (Object)(object)item)
					{
						if (stringBuilder.Length > 0)
						{
							stringBuilder.Insert(0, '/');
						}
						stringBuilder.Insert(0, ((Object)val3).name);
						val3 = val3.parent;
					}
					string text3 = ((stringBuilder.Length == 0) ? "<root>" : stringBuilder.ToString());
					string name2 = ((object)val2).GetType().Name;
					Material[] sharedMaterials = val2.sharedMaterials;
					if (sharedMaterials == null || sharedMaterials.Length == 0)
					{
						Plugin.Log.LogInfo((object)("[Prefab]   go='" + text3 + "'  renderer=" + name2 + "  (no materials)"));
						continue;
					}
					Material[] array3 = sharedMaterials;
					foreach (Material val4 in array3)
					{
						if (!((Object)(object)val4 == (Object)null))
						{
							num++;
							bool flag = hashSet2.Add(((Object)val4).GetInstanceID());
							if (flag)
							{
								num2++;
							}
							string arg2 = (((Object)(object)val4.shader != (Object)null) ? ((Object)val4.shader).name : "<null>");
							bool flag2 = (Object)(object)val4.shader != (Object)null && val4.shader.isSupported;
							ShaderAction action = Plugin.GetAction(val4);
							if ((Object)(object)val4.shader == (Object)null || !Plugin.ModShaderDlls.TryGetValue(((Object)val4.shader).name, out string value))
							{
								value = null;
							}
							string arg3 = (flag ? string.Empty : "  (dup)");
							Plugin.Log.LogInfo((object)("[Prefab]   go='" + text3 + "'  renderer=" + name2 + "  " + $"mat='{((Object)val4).name}'  shader='{arg2}'  supported={flag2}  " + string.Format("action={0}  dll='{1}'{2}", action, value ?? "unknown", arg3)));
						}
					}
				}
			}
			args.Context.AddString($"ShaderHelperForMac: prefab '{text}' matched {list.Count} GameObject(s); " + $"logged {num} material slot(s) ({num2} unique). " + "Check BepInEx/LogOutput.log for [Prefab] lines.");
		}

		public static void HandleModPrefabs(Plugin self, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper modprefabs <DllName-or-FolderName>");
				args.Context.AddString("       (case-insensitive; tries the input as both a DLL basename and a BepInEx folder basename — see v3.0.39 CHANGELOG)");
				args.Context.AddString("       Run `shaderhelper dumpprefabmap` first to see which mod identifiers have prefab roots attributed.");
				return;
			}
			string mpQuery = args[2];
			if (string.IsNullOrEmpty(mpQuery))
			{
				return;
			}
			string mpCanon = Plugin._prefabRootToDll.Values.FirstOrDefault((string d) => d.Equals(mpQuery, StringComparison.OrdinalIgnoreCase));
			if (mpCanon == null)
			{
				args.Context.AddString("ShaderHelperForMac: no prefab roots attributed to '" + mpQuery + "'.");
				args.Context.AddString("  Run `shaderhelper dumpprefabmap` to see which mod identifiers ARE attributed.");
				args.Context.AddString("  If your mod is missing, the bundle attribution path missed it — please open an issue with");
				args.Context.AddString("  your `shaderhelper dumpprefabmap` output and the mod's BepInEx folder name.");
				return;
			}
			List<string> list = (from kv in Plugin._prefabRootToDll
				where kv.Value.Equals(mpCanon, StringComparison.OrdinalIgnoreCase)
				select kv.Key).OrderBy<string, string>((string n) => n, StringComparer.Ordinal).ToList();
			if (list.Count == 0)
			{
				args.Context.AddString("ShaderHelperForMac: '" + mpCanon + "' has zero prefab-root attributions (unexpected; report as a bug).");
				return;
			}
			Plugin.Log.LogInfo((object)$"[ModPrefabs] mod='{mpCanon}' has {list.Count} prefab-root(s) attributed.");
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			HashSet<int> hashSet = new HashSet<int>();
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			Dictionary<string, List<GameObject>> dictionary = new Dictionary<string, List<GameObject>>(StringComparer.OrdinalIgnoreCase);
			GameObject[] array2 = array;
			foreach (GameObject val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = Plugin.StripCloneSuffix(((Object)val).name);
				if (!string.IsNullOrEmpty(text))
				{
					if (!dictionary.TryGetValue(text, out var value))
					{
						value = (dictionary[text] = new List<GameObject>());
					}
					value.Add(val);
				}
			}
			foreach (string item in list)
			{
				num++;
				if (!dictionary.TryGetValue(item, out var value2) || value2.Count == 0)
				{
					Plugin.Log.LogInfo((object)("[ModPrefabs]   root='" + item + "'  (registered in _prefabRootToDll but no live GameObject in memory at command time)"));
					continue;
				}
				num2++;
				GameObject val2 = value2[0];
				Renderer[] componentsInChildren = val2.GetComponentsInChildren<Renderer>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					Plugin.Log.LogInfo((object)("[ModPrefabs]   root='" + item + "'  (no renderers in hierarchy — sound-only effect or non-rendering prefab)"));
					continue;
				}
				Plugin.Log.LogInfo((object)$"[ModPrefabs]   root='{item}'  renderers={componentsInChildren.Length}");
				Renderer[] array3 = componentsInChildren;
				foreach (Renderer val3 in array3)
				{
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					StringBuilder stringBuilder = new StringBuilder();
					Transform val4 = ((Component)val3).transform;
					while ((Object)(object)val4 != (Object)null && (Object)(object)((Component)val4).gameObject != (Object)(object)val2)
					{
						if (stringBuilder.Length > 0)
						{
							stringBuilder.Insert(0, '/');
						}
						stringBuilder.Insert(0, ((Object)val4).name);
						val4 = val4.parent;
					}
					string text2 = ((stringBuilder.Length == 0) ? "<root>" : stringBuilder.ToString());
					string name = ((object)val3).GetType().Name;
					Material[] sharedMaterials = val3.sharedMaterials;
					if (sharedMaterials == null || sharedMaterials.Length == 0)
					{
						Plugin.Log.LogInfo((object)("[ModPrefabs]     go='" + text2 + "'  renderer=" + name + "  (no materials)"));
						continue;
					}
					Material[] array4 = sharedMaterials;
					foreach (Material val5 in array4)
					{
						if (!((Object)(object)val5 == (Object)null))
						{
							num3++;
							bool flag = hashSet.Add(((Object)val5).GetInstanceID());
							if (flag)
							{
								num4++;
							}
							string arg = (((Object)(object)val5.shader != (Object)null) ? ((Object)val5.shader).name : "<null>");
							bool flag2 = (Object)(object)val5.shader != (Object)null && val5.shader.isSupported;
							ShaderAction action = Plugin.GetAction(val5);
							if ((Object)(object)val5.shader == (Object)null || !Plugin.ModShaderDlls.TryGetValue(((Object)val5.shader).name, out string value3))
							{
								value3 = null;
							}
							string arg2 = (flag ? string.Empty : "  (dup)");
							Plugin.Log.LogInfo((object)("[ModPrefabs]     go='" + text2 + "'  renderer=" + name + "  " + $"mat='{((Object)val5).name}'  shader='{arg}'  supported={flag2}  " + string.Format("action={0}  dll='{1}'{2}", action, value3 ?? "unknown", arg2)));
						}
					}
				}
			}
			Plugin.Log.LogInfo((object)($"[ModPrefabs] Total: {num2}/{num} roots had live GameObjects in memory; " + $"{num3} material slot(s) ({num4} unique)."));
			args.Context.AddString($"ShaderHelperForMac: mod '{mpCanon}' — {num} prefab-root(s) attributed; " + $"{num2} live in memory, {num4} unique material(s) reported. " + "Check BepInEx/LogOutput.log for [ModPrefabs] lines.");
		}

		public static void HandleBundles(Plugin self, ConsoleEventArgs args)
		{
			string text = ((args.Length > 2) ? args[2] : string.Empty);
			bool flag = !string.IsNullOrEmpty(text);
			EmitB("=== AssetBundle.GetAllLoadedAssetBundles() snapshot ===");
			if (flag)
			{
				EmitB("(filtering by case-insensitive substring '" + text + "')");
			}
			List<AssetBundle> source = (from ab in AssetBundle.GetAllLoadedAssetBundles()
				where (Object)(object)ab != (Object)null
				select ab).ToList();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			foreach (AssetBundle item in source.OrderBy<AssetBundle, string>((AssetBundle ab) => ((Object)ab).name, StringComparer.Ordinal))
			{
				num++;
				hashSet.Add(((Object)item).name);
				string text2;
				string value;
				if (Plugin._vanillaBundleNames.Contains(((Object)item).name))
				{
					text2 = "<vanilla>";
					num3++;
				}
				else if (Plugin._bundleToDll.TryGetValue(((Object)item).name, out value) && !string.IsNullOrEmpty(value))
				{
					text2 = value;
					num2++;
				}
				else
				{
					text2 = "<unknown>";
					num4++;
				}
				if (flag && ((Object)item).name.IndexOf(text, StringComparison.OrdinalIgnoreCase) < 0)
				{
					continue;
				}
				int num6;
				string text3;
				try
				{
					string[] allAssetNames = item.GetAllAssetNames();
					num6 = allAssetNames.Length;
					int num7 = Math.Min(allAssetNames.Length, 5);
					if (num7 == 0)
					{
						text3 = "[]";
					}
					else
					{
						StringBuilder stringBuilder = new StringBuilder("[");
						for (int num8 = 0; num8 < num7; num8++)
						{
							if (num8 > 0)
							{
								stringBuilder.Append(", ");
							}
							stringBuilder.Append("'").Append(allAssetNames[num8]).Append("'");
						}
						if (allAssetNames.Length > num7)
						{
							stringBuilder.Append(", … +").Append(allAssetNames.Length - num7).Append(" more");
						}
						stringBuilder.Append("]");
						text3 = stringBuilder.ToString();
					}
				}
				catch (Exception ex)
				{
					num6 = -1;
					text3 = "[<TOC read failed: " + ex.Message + ">]";
				}
				EmitB($"  name='{((Object)item).name}'  assets={num6}  attribution='{text2}'  tocSample={text3}");
				num5++;
			}
			int num9 = 0;
			foreach (KeyValuePair<string, string> item2 in Plugin._bundleToDll)
			{
				if (!string.IsNullOrEmpty(item2.Key) && !hashSet.Contains(item2.Key))
				{
					num9++;
				}
			}
			EmitB("=== Summary ===");
			EmitB($"loaded bundles total: {num}  (attributed={num2}, vanilla={num3}, unknown={num4})");
			if (flag)
			{
				EmitB($"loaded bundles matching filter '{text}': {num5}");
			}
			EmitB($"_bundleToDll entries with no currently-loaded bundle: {num9}");
			EmitB("  (non-zero ⇒ those bundles were tagged at load time but have since been unloaded —");
			EmitB("   common when a mod calls AssetBundle.Unload(false) after extracting prefabs.)");
			EmitB("=== End AssetBundle snapshot ===");
			args.Context.AddString($"ShaderHelperForMac: bundles snapshot — total={num} (attributed={num2}, vanilla={num3}, unknown={num4}); " + $"tagged-but-unloaded={num9}. Check BepInEx/LogOutput.log for [Bundles] lines.");
			void EmitB(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[Bundles] " + line));
			}
		}
	}
	internal static class MatDumpCommand
	{
		internal static void Handle(Plugin instance, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper matdump <MatName> [--save=<label>]");
				args.Context.AddString("       shaderhelper matdump --diff <labelA> <labelB>");
				args.Context.AddString("Dumps every shader property slot + keywords + provenance state for state comparison between sessions.");
				args.Context.AddString("Saved dumps live in BepInEx/config/ShaderHelperForMac/matdump/<label>.txt.");
				return;
			}
			if (args[2].Equals("--diff", StringComparison.OrdinalIgnoreCase))
			{
				if (args.Length < 5)
				{
					args.Context.AddString("Usage: shaderhelper matdump --diff <labelA> <labelB>");
					return;
				}
				string labelA = args[3];
				string labelB = args[4];
				string text = MatDump.RunMatDumpDiff(labelA, labelB);
				args.Context.AddString(text);
				return;
			}
			string name = args[2];
			string text2 = Plugin.StripInstancePublic(name);
			string text3 = null;
			for (int i = 3; i < args.Length; i++)
			{
				if (args[i].StartsWith("--save=", StringComparison.OrdinalIgnoreCase))
				{
					text3 = args[i].Substring("--save=".Length);
					break;
				}
			}
			List<Action<string>> list = new List<Action<string>>
			{
				delegate(string s)
				{
					Plugin.Log.LogInfo((object)s);
				}
			};
			StreamWriter streamWriter = null;
			string text4 = null;
			if (text3 != null)
			{
				try
				{
					string text5 = MatDump.SanitizeMatDumpLabel(text3);
					string text6 = Path.Combine(Plugin.ConfigDir, "matdump");
					Directory.CreateDirectory(text6);
					text4 = Path.Combine(text6, text5 + ".txt");
					StreamWriter writerRef;
					streamWriter = (writerRef = new StreamWriter(text4, append: false, Encoding.UTF8));
					list.Add(delegate(string s)
					{
						writerRef.WriteLine(s);
					});
					Plugin.Log.LogInfo((object)("[MatDump] saving to '" + text4 + "' (label='" + text5 + "')"));
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[MatDump] failed to open save file for label '" + text3 + "': " + ex.GetType().Name + ": " + ex.Message + " — continuing with log-only emission."));
					args.Context.AddString("ShaderHelperForMac: matdump save failed (" + ex.GetType().Name + "); dump was still emitted to the log.");
					streamWriter?.Dispose();
					streamWriter = null;
					list = new List<Action<string>>
					{
						delegate(string s)
						{
							Plugin.Log.LogInfo((object)s);
						}
					};
				}
			}
			int num = 0;
			try
			{
				Material[] array = Resources.FindObjectsOfTypeAll<Material>();
				foreach (Material val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && !((Object)(object)val == (Object)(object)Plugin._transparentMat) && !((Object)(object)val == (Object)(object)Plugin._fallbackMat) && Plugin.StripInstancePublic(((Object)val).name).Equals(text2, StringComparison.OrdinalIgnoreCase))
					{
						num++;
						MatDump.EmitMatDumpBlock(val, text2, list);
					}
				}
			}
			finally
			{
				streamWriter?.Flush();
				streamWriter?.Dispose();
			}
			if (num == 0)
			{
				if (text4 != null)
				{
					try
					{
						if (File.Exists(text4))
						{
							File.Delete(text4);
						}
					}
					catch
					{
					}
				}
				args.Context.AddString("ShaderHelperForMac: matdump '" + text2 + "' — matches=0 (no live material with that name). See BepInEx/LogOutput.log.");
			}
			else if (text4 != null)
			{
				args.Context.AddString($"ShaderHelperForMac: matdump '{text2}' — dumped {num} material(s) to log and to matdump/{Path.GetFileName(text4)}.");
			}
			else
			{
				args.Context.AddString($"ShaderHelperForMac: matdump '{text2}' — dumped {num} material(s). See BepInEx/LogOutput.log for [MatDump] lines.");
			}
		}
	}
	internal static class ObserverCommands
	{
		public static void HandleWatch(Plugin self, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper watch <MatName> [seconds]");
				args.Context.AddString("Logs per-frame material state for N seconds (default 5, max 30) — diagnoses flicker classes invisible to `explain`.");
				return;
			}
			string text = args[2];
			float num = 5f;
			if (args.Length > 3 && float.TryParse(args[3], out var result))
			{
				num = result;
			}
			if (num < 1f)
			{
				num = 1f;
			}
			if (num > 30f)
			{
				num = 30f;
			}
			if ((Object)(object)Plugin.Instance == (Object)null)
			{
				args.Context.AddString("ShaderHelperForMac: plugin not initialized; cannot start watch coroutine.");
				return;
			}
			((MonoBehaviour)Plugin.Instance).StartCoroutine(WatchMaterialCoroutine(text, num));
			args.Context.AddString($"ShaderHelperForMac: watching '{text}' for {num:F1}s — see BepInEx/LogOutput.log for per-frame [Watch] lines.");
		}

		public static void HandleWatchr(Plugin self, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper watchr <GameObjectName> [seconds] [--light]");
				args.Context.AddString("Logs per-frame RENDERER state for N seconds (default 5, max 30) — diagnoses flicker classes invisible to `watch`. Add --light for a throttled, dedup'd, FPS-friendly mode that stays playable enough to swing a weapon (use it to NAME a transient swing-trail material).");
				return;
			}
			string text = args[2];
			float num = 5f;
			bool flag = false;
			for (int i = 3; i < args.Length; i++)
			{
				float result;
				if (string.Equals(args[i], "--light", StringComparison.OrdinalIgnoreCase))
				{
					flag = true;
				}
				else if (float.TryParse(args[i], out result))
				{
					num = result;
				}
			}
			if (num < 1f)
			{
				num = 1f;
			}
			if (num > 30f)
			{
				num = 30f;
			}
			if ((Object)(object)Plugin.Instance == (Object)null)
			{
				args.Context.AddString("ShaderHelperForMac: plugin not initialized; cannot start watchr coroutine.");
				return;
			}
			((MonoBehaviour)Plugin.Instance).StartCoroutine(WatchRenderersCoroutine(text, num, flag));
			string arg = (flag ? " (--light: throttled 0.1s sampling, dedup'd, no overlap pass)" : "");
			args.Context.AddString($"ShaderHelperForMac: watching renderers under '{text}' for {num:F1}s{arg} — see BepInEx/LogOutput.log for [WatchR] lines.");
		}

		internal static IEnumerator WatchMaterialCoroutine(string matName, float duration)
		{
			if (string.IsNullOrEmpty(matName))
			{
				yield break;
			}
			string qBase = Plugin.StripInstance(matName);
			List<Material> initial = Collect();
			int startFrame = Time.frameCount;
			Plugin.Log.LogInfo((object)$"[Watch] begin  mat='{qBase}'  duration={duration:F1}s  matches={initial.Count}  frame={startFrame}");
			if (initial.Count == 0)
			{
				Plugin.Log.LogInfo((object)("[Watch] end    mat='" + qBase + "'  frames=0  distinctShaderIds=0  distinctMatIds=0  shaders=[]  (no matching materials found — nothing to watch)"));
				yield break;
			}
			HashSet<int> seenShaderIds = new HashSet<int>();
			HashSet<int> seenMatIds = new HashSet<int>();
			HashSet<string> seenTriplets = new HashSet<string>(StringComparer.Ordinal);
			int frameCount = 0;
			float endTime = Time.realtimeSinceStartup + duration;
			while (Time.realtimeSinceStartup < endTime)
			{
				frameCount++;
				int frameNum = Time.frameCount;
				List<Material> current = Collect();
				foreach (Material mat in current)
				{
					if (!((Object)(object)mat == (Object)null) && !((Object)(object)mat.shader == (Object)null))
					{
						int matId = ((Object)mat).GetInstanceID();
						int shaderId = ((Object)mat.shader).GetInstanceID();
						string shaderName = ((Object)mat.shader).name ?? "<null>";
						bool canonical = Plugin.CanonicalShaderIds.Contains(shaderId);
						bool supported = mat.shader.isSupported;
						string colorStr = (mat.HasProperty("_Color") ? ((object)mat.color/*cast due to .constrained prefix*/).ToString() : "n/a");
						int queue = mat.renderQueue;
						string[] keywords = mat.shaderKeywords;
						string keywordStr = ((keywords == null || keywords.Length == 0) ? "<none>" : string.Join("|", keywords));
						seenMatIds.Add(matId);
						seenShaderIds.Add(shaderId);
						seenTriplets.Add($"('{shaderName}', {shaderId}, supported={supported})");
						Plugin.Log.LogInfo((object)($"[Watch] frame={frameNum}  matId={matId}  shaderId={shaderId}  shaderName='{shaderName}'" + $"  canonical={canonical}  supported={supported}  color={colorStr}  queue={queue}" + "  keywords=" + keywordStr));
					}
				}
				yield return null;
			}
			int endFrame = Time.frameCount;
			string triplets = ((seenTriplets.Count == 0) ? "[]" : ("[" + string.Join(", ", seenTriplets.OrderBy<string, string>((string s) => s, StringComparer.Ordinal)) + "]"));
			Plugin.Log.LogInfo((object)($"[Watch] end    mat='{qBase}'  frames={frameCount}  distinctShaderIds={seenShaderIds.Count}" + $"  distinctMatIds={seenMatIds.Count}  startFrame={startFrame}  endFrame={endFrame}  shaders={triplets}"));
			List<Material> Collect()
			{
				List<Material> list = new List<Material>();
				Material[] array = Resources.FindObjectsOfTypeAll<Material>();
				foreach (Material val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && !((Object)(object)val == (Object)(object)Plugin._transparentMat) && !((Object)(object)val == (Object)(object)Plugin._fallbackMat) && Plugin.StripInstance(((Object)val).name).Equals(qBase, StringComparison.OrdinalIgnoreCase))
					{
						list.Add(val);
					}
				}
				return list;
			}
		}

		internal static IEnumerator WatchRenderersCoroutine(string rootName, float duration, bool light = false)
		{
			if (string.IsNullOrEmpty(rootName))
			{
				yield break;
			}
			List<Renderer> initial = Collect();
			int startFrame = Time.frameCount;
			Plugin.Log.LogInfo((object)$"[WatchR] begin  root='{rootName}'  duration={duration:F1}s  matches={initial.Count}  frame={startFrame}");
			if (initial.Count == 0)
			{
				Plugin.Log.LogInfo((object)("[WatchR] end    root='" + rootName + "'  frames=0  renderer-count=0  (no matching renderers found — nothing to watch)"));
				yield break;
			}
			if (light)
			{
				HashSet<string> lightSeen = new HashSet<string>(StringComparer.Ordinal);
				int lightSamples = 0;
				int lightNewLines = 0;
				float lightEnd = Time.realtimeSinceStartup + duration;
				while (Time.realtimeSinceStartup < lightEnd)
				{
					lightSamples++;
					int lframeNum = Time.frameCount;
					foreach (Renderer r in Collect())
					{
						if ((Object)(object)r == (Object)null)
						{
							continue;
						}
						Material[] shared = r.sharedMaterials;
						if (shared == null)
						{
							continue;
						}
						List<string> nameParts = new List<string>(shared.Length);
						for (int k = 0; k < shared.Length; k++)
						{
							if ((Object)(object)shared[k] == (Object)null)
							{
								nameParts.Add("null");
								continue;
							}
							string[] obj = new string[5]
							{
								"'",
								Plugin.StripInstance(((Object)shared[k]).name),
								"'(",
								null,
								null
							};
							Shader shader = shared[k].shader;
							obj[3] = ((shader != null) ? ((Object)shader).name : null) ?? "<null>";
							obj[4] = ")";
							nameParts.Add(string.Concat(obj));
						}
						if (nameParts.Count != 0)
						{
							string lightSet = string.Join(", ", nameParts);
							string lightKey = PathOf(((Component)r).transform) + " :: " + lightSet;
							if (lightSeen.Add(lightKey))
							{
								lightNewLines++;
								Plugin.Log.LogInfo((object)($"[WatchR-light]  frame={lframeNum}  type={((object)r).GetType().Name}  go='{PathOf(((Component)r).transform)}'" + $"  enabled={r.enabled}  sharedMats=[{lightSet}]"));
							}
						}
					}
					yield return (object)new WaitForSeconds(0.1f);
				}
				Plugin.Log.LogInfo((object)($"[WatchR-light] end    root='{rootName}'  samples={lightSamples}  distinctNewLines={lightNewLines}" + "  (0.1s throttled, dedup'd by go-path+sharedMats name-set; per-frame transition counters intentionally omitted in light mode)"));
				yield break;
			}
			Dictionary<string, bool> lastEnabled = new Dictionary<string, bool>(StringComparer.Ordinal);
			Dictionary<string, string> lastSharedSet = new Dictionary<string, string>(StringComparer.Ordinal);
			Dictionary<string, int> lastInstId = new Dictionary<string, int>(StringComparer.Ordinal);
			Dictionary<string, HashSet<string>> perPathSharedSets = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
			Dictionary<string, HashSet<int>> perPathInstIds = new Dictionary<string, HashSet<int>>(StringComparer.Ordinal);
			int enabledTransitions = 0;
			int sharedSetTransitions = 0;
			int instIdTransitions = 0;
			bool hadMPB = false;
			bool keepDisabledEverSeen = false;
			int frameCount = 0;
			int framesWithOverlap = 0;
			float endTime = Time.realtimeSinceStartup + duration;
			while (Time.realtimeSinceStartup < endTime)
			{
				frameCount++;
				int frameNum = Time.frameCount;
				List<Renderer> current = Collect();
				Bounds[] frameBounds = (Bounds[])(object)new Bounds[current.Count];
				bool[] frameHasBounds = new bool[current.Count];
				Vector3[] framePositions = (Vector3[])(object)new Vector3[current.Count];
				for (int i = 0; i < current.Count; i++)
				{
					Renderer rr = current[i];
					if (!((Object)(object)rr == (Object)null))
					{
						framePositions[i] = ((Component)rr).transform.position;
						try
						{
							frameBounds[i] = rr.bounds;
							frameHasBounds[i] = true;
						}
						catch
						{
							frameHasBounds[i] = false;
						}
					}
				}
				List<int>[] frameOverlaps = new List<int>[current.Count];
				bool anyOverlapThisFrame = false;
				for (int j = 0; j < current.Count; j++)
				{
					frameOverlaps[j] = new List<int>();
				}
				for (int l = 0; l < current.Count; l++)
				{
					if (!frameHasBounds[l])
					{
						continue;
					}
					for (int m = l + 1; m < current.Count; m++)
					{
						if (frameHasBounds[m] && ((Bounds)(ref frameBounds[l])).Intersects(frameBounds[m]))
						{
							frameOverlaps[l].Add(m);
							frameOverlaps[m].Add(l);
							anyOverlapThisFrame = true;
						}
					}
				}
				if (anyOverlapThisFrame)
				{
					framesWithOverlap++;
				}
				Plugin.Log.LogInfo((object)$"[WatchR] frame={frameNum}  renderer-count={current.Count}  anyOverlap={anyOverlapThisFrame}");
				for (int n = 0; n < current.Count; n++)
				{
					Renderer r2 = current[n];
					if ((Object)(object)r2 == (Object)null)
					{
						continue;
					}
					string path = PathOf(((Component)r2).transform);
					string type = ((object)r2).GetType().Name;
					bool enabled = r2.enabled;
					bool hasMPB = r2.HasPropertyBlock();
					if (hasMPB)
					{
						hadMPB = true;
					}
					Material[] shared2 = r2.sharedMaterials;
					List<string> idParts = new List<string>((shared2 != null) ? shared2.Length : 0);
					List<string> nameParts2 = new List<string>((shared2 != null) ? shared2.Length : 0);
					if (shared2 != null)
					{
						for (int num = 0; num < shared2.Length; num++)
						{
							idParts.Add(((Object)(object)shared2[num] == (Object)null) ? "null" : ((Object)shared2[num]).GetInstanceID().ToString());
							if ((Object)(object)shared2[num] == (Object)null)
							{
								nameParts2.Add("null");
								continue;
							}
							string[] obj3 = new string[5]
							{
								"'",
								Plugin.StripInstance(((Object)shared2[num]).name),
								"'(",
								null,
								null
							};
							Shader shader2 = shared2[num].shader;
							obj3[3] = ((shader2 != null) ? ((Object)shader2).name : null) ?? "<null>";
							obj3[4] = ")";
							nameParts2.Add(string.Concat(obj3));
						}
					}
					string sharedIdSet = string.Join(",", idParts);
					string sharedMatSet = ((nameParts2.Count == 0) ? "(none)" : string.Join(", ", nameParts2));
					int instId = 0;
					string instIdStr = "shared";
					if (shared2 != null && shared2.Length != 0 && (Object)(object)shared2[0] != (Object)null)
					{
						Material sm = r2.sharedMaterial;
						if ((Object)(object)sm != (Object)null && ((Object)sm).GetInstanceID() != ((Object)shared2[0]).GetInstanceID())
						{
							instId = ((Object)sm).GetInstanceID();
							instIdStr = instId.ToString();
						}
					}
					bool keepDisabled = (Object)(object)((Component)r2).GetComponent<KeepRendererDisabled>() != (Object)null;
					if (keepDisabled)
					{
						keepDisabledEverSeen = true;
					}
					if (lastEnabled.TryGetValue(path, out var prevEnabled) && prevEnabled != enabled)
					{
						enabledTransitions++;
					}
					lastEnabled[path] = enabled;
					if (lastSharedSet.TryGetValue(path, out string prevShared) && !string.Equals(prevShared, sharedIdSet, StringComparison.Ordinal))
					{
						sharedSetTransitions++;
					}
					lastSharedSet[path] = sharedIdSet;
					if (!perPathSharedSets.TryGetValue(path, out HashSet<string> setForPath))
					{
						setForPath = (perPathSharedSets[path] = new HashSet<string>(StringComparer.Ordinal));
					}
					setForPath.Add(sharedIdSet);
					if (lastInstId.TryGetValue(path, out var prevInst) && prevInst != instId)
					{
						instIdTransitions++;
					}
					lastInstId[path] = instId;
					if (!perPathInstIds.TryGetValue(path, out HashSet<int> instSetForPath))
					{
						instSetForPath = (perPathInstIds[path] = new HashSet<int>());
					}
					instSetForPath.Add(instId);
					Vector3 pos = framePositions[n];
					string posStr = $"({pos.x:F2},{pos.y:F2},{pos.z:F2})";
					string boundsStr;
					if (frameHasBounds[n])
					{
						Vector3 bc = ((Bounds)(ref frameBounds[n])).center;
						Vector3 bs = ((Bounds)(ref frameBounds[n])).size;
						boundsStr = $"(c=({bc.x:F2},{bc.y:F2},{bc.z:F2}) s=({bs.x:F2},{bs.y:F2},{bs.z:F2}))";
					}
					else
					{
						boundsStr = "n/a";
					}
					string overlapsStr = ((frameOverlaps[n].Count == 0) ? "[]" : ("[" + string.Join(",", frameOverlaps[n]) + "]"));
					Plugin.Log.LogInfo((object)($"[WatchR]   r={n}  type={type}  go='{path}'  enabled={enabled}  hasMPB={hasMPB}" + $"  sharedMatIds=[{sharedIdSet}]  sharedMats=[{sharedMatSet}]  instMatId={instIdStr}  keepDisabled={keepDisabled}" + "  pos=" + posStr + "  bounds=" + boundsStr + "  overlaps=" + overlapsStr));
					prevShared = null;
					setForPath = null;
					instSetForPath = null;
				}
				yield return null;
			}
			int endFrame = Time.frameCount;
			int distinctPaths = perPathSharedSets.Count;
			int pathsWithMultipleSharedSets = 0;
			int pathsWithMultipleInstIds = 0;
			foreach (KeyValuePair<string, HashSet<string>> item in perPathSharedSets)
			{
				if (item.Value.Count > 1)
				{
					pathsWithMultipleSharedSets++;
				}
			}
			foreach (KeyValuePair<string, HashSet<int>> item2 in perPathInstIds)
			{
				if (item2.Value.Count > 1)
				{
					pathsWithMultipleInstIds++;
				}
			}
			Plugin.Log.LogInfo((object)($"[WatchR] end    root='{rootName}'  frames={frameCount}  startFrame={startFrame}  endFrame={endFrame}" + $"  distinctPaths={distinctPaths}" + $"  distinctEnabledTransitions={enabledTransitions}" + $"  distinctSharedMatIdSetTransitions={sharedSetTransitions}" + $"  pathsWithMultipleSharedMatIdSets={pathsWithMultipleSharedSets}" + $"  distinctInstMatIdTransitions={instIdTransitions}" + $"  pathsWithMultipleInstMatIds={pathsWithMultipleInstIds}" + $"  hadMPB={hadMPB}  keepDisabledEverSeen={keepDisabledEverSeen}" + $"  framesWithOverlap={framesWithOverlap}"));
			List<Renderer> Collect()
			{
				List<Renderer> list = new List<Renderer>();
				Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
				foreach (Renderer val in array)
				{
					if (!((Object)(object)val == (Object)null) && Matches(val))
					{
						list.Add(val);
					}
				}
				return list;
			}
			bool Matches(Renderer val)
			{
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				Transform val2 = ((Component)val).transform;
				while ((Object)(object)val2 != (Object)null)
				{
					string a = Plugin.StripCloneSuffix(((Object)val2).name);
					if (string.Equals(a, rootName, StringComparison.OrdinalIgnoreCase))
					{
						return true;
					}
					val2 = val2.parent;
				}
				return false;
			}
			static string PathOf(Transform t)
			{
				if ((Object)(object)t == (Object)null)
				{
					return "<null>";
				}
				List<string> list = new List<string>();
				while ((Object)(object)t != (Object)null)
				{
					list.Add(Plugin.StripCloneSuffix(((Object)t).name));
					t = t.parent;
				}
				list.Reverse();
				return string.Join("/", list);
			}
		}
	}
	internal static class PsProbeCommand
	{
		internal static void Handle(Plugin instance, ConsoleEventArgs args)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0153: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				args.Context.AddString("ShaderHelperForMac: no local player found.");
				return;
			}
			float num = 30f;
			if (args.Length > 2 && float.TryParse(args[2], out var result))
			{
				num = result;
			}
			if (args.Length > 3 && float.TryParse(args[3], out var result2) && result2 > 0f)
			{
				float num2 = Mathf.Min(result2, 60f);
				if (Plugin._matShaderOverrides.Count == 0)
				{
					args.Context.AddString("ShaderHelperForMac: psprobe-watch requires at least one [useshader] mat: rule in a per-mod txt — duration-window mode filters by mat-name match against the [useshader] override set. Add a [useshader] section to the relevant per-mod config and re-run.");
					return;
				}
				args.Context.AddString($"ShaderHelperForMac: psprobe-watch starting — {num2:F0}s window @ ~10Hz, " + $"filtered by [useshader] mat-name match (currently {Plugin._matShaderOverrides.Count} rule(s)). " + "Trigger your transient FX now; results in [PSProbe-Watch] log lines.");
				((MonoBehaviour)instance).StartCoroutine(WatchCoroutine(num, num2, localPlayer));
				return;
			}
			ParticleSystemRenderer[] array = Resources.FindObjectsOfTypeAll<ParticleSystemRenderer>();
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			MaterialPropertyBlock mpbScratch = new MaterialPropertyBlock();
			ParticleSystemRenderer[] array2 = array;
			foreach (ParticleSystemRenderer val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				float num7 = Vector3.Distance(((Component)val).transform.position, ((Component)localPlayer).transform.position);
				if (!(num7 > num))
				{
					EmitProbeLine("PSProbe", val, num7, mpbScratch, out var rendererEnabled, out var keepDisabledAttached, out var zeroParticles);
					if (!rendererEnabled)
					{
						num4++;
					}
					if (keepDisabledAttached)
					{
						num5++;
					}
					if (zeroParticles)
					{
						num6++;
					}
					num3++;
				}
			}
			args.Context.AddString($"ShaderHelperForMac: psprobe scanned {num3} ParticleSystemRenderer(s) within {num:F0} units " + $"(disabled={num4}, KeepRendererDisabled={num5}, particleCount=0:{num6}). " + "See [PSProbe] lines in BepInEx/LogOutput.log.");
		}

		private static IEnumerator WatchCoroutine(float radius, float seconds, Player player)
		{
			Dictionary<int, string> priorFingerprintByRendererId = new Dictionary<int, string>();
			MaterialPropertyBlock mpbScratch = new MaterialPropertyBlock();
			float deadline = Time.realtimeSinceStartup + seconds;
			int totalEmits = 0;
			int totalSamples = 0;
			long totalPsrsSeen = 0L;
			long totalPassedRadius = 0L;
			long totalSharedMatsNonEmpty = 0L;
			long totalPassedFilter = 0L;
			bool firstSampleDumpPending = true;
			while (Time.realtimeSinceStartup < deadline)
			{
				totalSamples++;
				if ((Object)(object)player == (Object)null)
				{
					Plugin.Log.LogInfo((object)"[PSProbe-Watch] aborted — local player no longer present.");
					yield break;
				}
				ParticleSystemRenderer[] psRenderers = Resources.FindObjectsOfTypeAll<ParticleSystemRenderer>();
				totalPsrsSeen += psRenderers.Length;
				if (firstSampleDumpPending && psRenderers.Length != 0)
				{
					int dumped = 0;
					int totalInRadius = 0;
					ParticleSystemRenderer[] array = psRenderers;
					foreach (ParticleSystemRenderer psr in array)
					{
						if ((Object)(object)psr == (Object)null)
						{
							continue;
						}
						float d = Vector3.Distance(((Component)psr).transform.position, ((Component)player).transform.position);
						if (d > radius)
						{
							continue;
						}
						totalInRadius++;
						if (dumped < 200)
						{
							Material[] sharedMats = ((Renderer)psr).sharedMaterials;
							string mat0;
							if (sharedMats == null || sharedMats.Length == 0)
							{
								mat0 = "<empty>";
							}
							else if ((Object)(object)sharedMats[0] == (Object)null)
							{
								mat0 = "<null>";
							}
							else
							{
								string matName = Plugin.StripInstance(((Object)sharedMats[0]).name);
								string shaderName = (((Object)(object)sharedMats[0].shader != (Object)null) ? ((Object)sharedMats[0].shader).name : "<null-shader>");
								mat0 = matName + "/" + shaderName;
							}
							ManualLogSource log = Plugin.Log;
							object arg = d;
							Transform parent = ((Component)psr).transform.parent;
							log.LogInfo((object)(string.Format("[PSProbe-Watch-First] dist={0:F1} parent='{1}' ", arg, ((parent != null) ? ((Object)parent).name : null) ?? "(root)") + $"go='{((Object)((Component)psr).gameObject).name}' matCount={((sharedMats != null) ? sharedMats.Length : 0)} mat0={mat0}"));
							dumped++;
						}
					}
					Plugin.Log.LogInfo((object)($"[PSProbe-Watch-First] sample-1 summary: psrsSeen={psRenderers.Length} " + $"inRadius={totalInRadius} dumped={dumped} (cap=200)"));
					firstSampleDumpPending = false;
				}
				ParticleSystemRenderer[] array2 = psRenderers;
				foreach (ParticleSystemRenderer psr2 in array2)
				{
					if ((Object)(object)psr2 == (Object)null)
					{
						continue;
					}
					float dist = Vector3.Distance(((Component)psr2).transform.position, ((Component)player).transform.position);
					if (dist > radius)
					{
						continue;
					}
					totalPassedRadius++;
					Material[] sharedMatsForCount = ((Renderer)psr2).sharedMaterials;
					if (sharedMatsForCount != null && sharedMatsForCount.Length != 0)
					{
						totalSharedMatsNonEmpty++;
					}
					if (HasMaterialUnderUseShaderRule(psr2))
					{
						totalPassedFilter++;
						int rendererId = ((Object)psr2).GetInstanceID();
						int particleCount = 0;
						bool emissionEnabled = false;
						bool colorOverLifeEnabled = false;
						ParticleSystem ps = ((Component)psr2).gameObject.GetComponent<ParticleSystem>();
						if ((Object)(object)ps != (Object)null)
						{
							particleCount = ps.particleCount;
							EmissionModule emission = ps.emission;
							emissionEnabled = ((EmissionModule)(ref emission)).enabled;
							ColorOverLifetimeModule colorOverLifetime = ps.colorOverLifetime;
							colorOverLifeEnabled = ((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled;
						}
						int particleBucket = ((particleCount != 0) ? ((particleCount < 10) ? 1 : ((particleCount < 100) ? 2 : 3)) : 0);
						bool hasMpb = ((Renderer)psr2).HasPropertyBlock();
						string fingerprint = $"{((Renderer)psr2).enabled}/{particleBucket}/{emissionEnabled}/{colorOverLifeEnabled}/{(int)psr2.renderMode}/{hasMpb}";
						if (!priorFingerprintByRendererId.TryGetValue(rendererId, out string prior) || !(prior == fingerprint))
						{
							priorFingerprintByRendererId[rendererId] = fingerprint;
							EmitProbeLine("PSProbe-Watch", psr2, dist, mpbScratch, out var _, out var _, out var _);
							totalEmits++;
							prior = null;
						}
					}
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			Plugin.Log.LogInfo((object)($"[PSProbe-Watch] finished — {totalSamples} samples over {seconds:F1}s; " + $"{totalEmits} state-change emit(s) across {priorFingerprintByRendererId.Count} distinct renderer(s) " + "under [useshader] mat: rule(s)."));
			Plugin.Log.LogInfo((object)($"[PSProbe-Watch] funnel: totalPsrsSeen={totalPsrsSeen} " + $"totalPassedRadius={totalPassedRadius} " + $"totalSharedMatsNonEmpty={totalSharedMatsNonEmpty} " + $"totalPassedFilter={totalPassedFilter}"));
		}

		private static bool HasMaterialUnderUseShaderRule(ParticleSystemRenderer psr)
		{
			Material[] sharedMaterials = ((Renderer)psr).sharedMaterials;
			if (sharedMaterials == null)
			{
				return false;
			}
			Material[] array = sharedMaterials;
			foreach (Material val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string key = Plugin.StripInstance(((Object)val).name);
					if (Plugin._matShaderOverrides.ContainsKey(key))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsUnderModPrefabAncestor(Transform t)
		{
			while ((Object)(object)t != (Object)null)
			{
				string item = Plugin.StripCloneSuffix(((Object)t).name);
				if (Plugin._modPrefabRootNames.Contains(item))
				{
					return true;
				}
				t = t.parent;
			}
			return false;
		}

		private static string ProbePropertyBlockColor(MaterialPropertyBlock mpb, string propertyName)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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)
			Color color = mpb.GetColor(propertyName);
			if (color == Color.clear)
			{
				return "unset";
			}
			return $"({color.r:F2},{color.g:F2},{color.b:F2},{color.a:F2})";
		}

		private static void EmitProbeLine(string tag, ParticleSystemRenderer psr, float dist, MaterialPropertyBlock mpbScratch, out bool rendererEnabled, out bool keepDisabledAttached, out bool zeroParticles)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected I4, but got Unknown
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Component)psr).transform.parent;
			string text = ((parent != null) ? ((Object)parent).name : null) ?? "(root)";
			string name = ((Object)((Component)psr).gameObject).name;
			rendererEnabled = ((Renderer)psr).enabled;
			keepDisabledAttached = (Object)(object)((Component)psr).gameObject.GetComponent<KeepRendererDisabled>() != (Object)null;
			ParticleSystem component = ((Component)psr).gameObject.GetComponent<ParticleSystem>();
			zeroParticles = false;
			string text2;
			if ((Object)(object)component == (Object)null)
			{
				text2 = "ps=<null>";
			}
			else
			{
				bool flag = component.IsAlive(true);
				int particleCount = component.particleCount;
				zeroParticles = particleCount == 0;
				EmissionModule emission = component.emission;
				bool enabled = ((EmissionModule)(ref emission)).enabled;
				float rateOverTimeMultiplier = ((EmissionModule)(ref emission)).rateOverTimeMultiplier;
				MainModule main = component.main;
				MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
				Color color = ((MinMaxGradient)(ref startColor)).color;
				float startSizeMultiplier = ((MainModule)(ref main)).startSizeMultiplier;
				ColorOverLifetimeModule colorOverLifetime = component.colorOverLifetime;
				string text3;
				if (((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled)
				{
					MinMaxGradient color2 = ((ColorOverLifetimeModule)(ref colorOverLifetime)).color;
					ParticleSystemGradientMode mode = ((MinMaxGradient)(ref color2)).mode;
					ParticleSystemGradientMode val = mode;
					float num;
					float num2;
					float num3;
					switch ((int)val)
					{
					case 1:
						num = ((((MinMaxGradient)(ref color2)).gradient != null) ? ((MinMaxGradient)(ref color2)).gradient.Evaluate(0f).a : 1f);
						num2 = ((((MinMaxGradient)(ref color2)).gradient != null) ? ((MinMaxGradient)(ref color2)).gradient.Evaluate(0.5f).a : 1f);
						num3 = ((((MinMaxGradient)(ref color2)).gradient != null) ? ((MinMaxGradient)(ref color2)).gradient.Evaluate(1f).a : 1f);
						break;
					case 3:
						num = (((((MinMaxGradient)(ref color2)).gradientMin != null) ? ((MinMaxGradient)(ref color2)).gradientMin.Evaluate(0f).a : 1f) + ((((MinMaxGradient)(ref color2)).gradientMax != null) ? ((MinMaxGradient)(ref color2)).gradientMax.Evaluate(0f).a : 1f)) * 0.5f;
						num2 = (((((MinMaxGradient)(ref color2)).gradientMin != null) ? ((MinMaxGradient)(ref color2)).gradientMin.Evaluate(0.5f).a : 1f) + ((((MinMaxGradient)(ref color2)).gradientMax != null) ? ((MinMaxGradient)(ref color2)).gradientMax.Evaluate(0.5f).a : 1f)) * 0.5f;
						num3 = (((((MinMaxGradient)(ref color2)).gradientMin != null) ? ((MinMaxGradient)(ref color2)).gradientMin.Evaluate(1f).a : 1f) + ((((MinMaxGradient)(ref color2)).gradientMax != null) ? ((MinMaxGradient)(ref color2)).gradientMax.Evaluate(1f).a : 1f)) * 0.5f;
						break;
					case 2:
						num = (num2 = (num3 = (((MinMaxGradient)(ref color2)).colorMin.a + ((MinMaxGradient)(ref color2)).colorMax.a) * 0.5f));
						break;
					default:
						num = (num2 = (num3 = ((MinMaxGradient)(ref color2)).color.a));
						break;
					}
					text3 = $"colorOverLife.on=True a@0.0={num:F2} a@0.5={num2:F2} a@1.0={num3:F2}";
				}
				else
				{
					text3 = "colorOverLife.on=False";
				}
				text2 = $"ps=alive:{flag}  count={particleCount}  emit.on={enabled}  emit.rateMul={rateOverTimeMultiplier:F2}  " + $"start.color=({color.r:F2},{color.g:F2},{color.b:F2},{color.a:F2})  start.sizeMul={startSizeMultiplier:F2}  " + text3;
			}
			string text4 = $"renderMode={psr.renderMode}  lengthScale={psr.lengthScale:F2}  velocityScale={psr.velocityScale:F2}";
			Material trailMaterial = psr.trailMaterial;
			string text5;
			if ((Object)(object)trailMaterial == (Object)null)
			{
				text5 = "trailMat=<null>";
			}
			else
			{
				string arg = (((Object)(object)trailMaterial.shader != (Object)null) ? ((Object)trailMaterial.shader).name : "<null>");
				text5 = $"trailMat='{Plugin.StripInstance(((Object)trailMaterial).name)}' trailShader='{arg}' trailMatId={((Object)trailMaterial).GetInstanceID()}";
			}
			string text9;
			if (((Renderer)psr).HasPropertyBlock())
			{
				mpbScratch.Clear();
				((Renderer)psr).GetPropertyBlock(mpbScratch);
				string text6 = ProbePropertyBlockColor(mpbScratch, "_Color");
				string text7 = ProbePropertyBlockColor(mpbScratch, "_MainColor");
				string text8 = ProbePropertyBlockColor(mpbScratch, "_TintColor");
				text9 = "mpb=YES mpb._Color=" + text6 + " mpb._MainColor=" + text7 + " mpb._TintColor=" + text8;
			}
			else
			{
				text9 = "mpb=NO";
			}
			Material[] sharedMaterials = ((Renderer)psr).sharedMaterials;
			int num4 = ((sharedMaterials != null) ? sharedMaterials.Length : 0);
			string text10;
			if (num4 == 0)
			{
				text10 = "mats=<empty>";
			}
			else
			{
				List<string> list = new List<string>(num4);
				Material[] array = sharedMaterials;
				foreach (Material val2 in array)
				{
					if ((Object)(object)val2 == (Object)null || (Object)(object)val2.shader == (Object)null)
					{
						list.Add("mat=<null>");
						continue;
					}
					ShaderAction action = Plugin.GetAction(val2);
					Plugin.ModShaderDlls.TryGetValue(((Object)val2.shader).name, out string value);
					bool flag2 = Plugin.IsParticleCapableShaderName(((Object)val2.shader).name);
					string text11 = Plugin.StripInstance(((Object)val2).name);
					string text12 = BuildHasPropertySummary(val2, text11);
					list.Add($"mat='{text11}' shader='{((Object)val2.shader).name}' supp={val2.shader.isSupported} " + string.Format("pCap={0} action={1} dll='{2}'{3}", flag2, action, value ?? "unknown", text12));
				}
				text10 = string.Join("  | ", list);
			}
			Plugin.Log.LogInfo((object)($"[{tag}] dist={dist:F1}  parent='{text}'  go='{name}'  " + string.Format("renderer.enabled={0}  KeepRendererDisabled={1}  ", rendererEnabled, keepDisabledAttached ? "ATTACHED" : "no") + text2 + "  " + text4 + "  " + text5 + "  " + text9 + "  || " + text10));
		}

		private static string BuildHasPropertySummary(Material mat, string baseMatName)
		{
			if (!Plugin._matShaderPropertyOverrides.TryGetValue(baseMatName, out List<(string, string)> value) || value == null || value.Count == 0)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (var item2 in value)
			{
				string item = item2.Item1;
				stringBuilder.Append("  hasProp.").Append(item).Append('=')
					.Append(mat.HasProperty(item) ? "True" : "False");
			}
			return stringBuilder.ToString();
		}
	}
	internal static class ResolveShaderCommand
	{
		internal static void Handle(Plugin instance, ConsoleEventArgs args)
		{
			if (args.Args == null || args.Args.Length < 3)
			{
				Emit("Usage: shaderhelper resolveshader <ShaderName>");
				Emit("  Example: shaderhelper resolveshader Particles/Standard Unlit2");
				return;
			}
			string targetName = string.Join(" ", args.Args.Skip(2)).Trim();
			if (string.IsNullOrEmpty(targetName))
			{
				Emit("Usage: shaderhelper resolveshader <ShaderName>");
				return;
			}
			Emit("ShaderHelperForMac v3.2.0 — resolveshader '" + targetName + "'");
			Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
			Material[] array2 = Resources.FindObjectsOfTypeAll<Material>();
			Emit($"  snapshot: {array.Length} loaded shader object(s), {array2.Length} loaded material(s).");
			Emit("");
			Shader[] array3 = array.Where((Shader s) => (Object)(object)s != (Object)null && ((Object)s).name == targetName).ToArray();
			Emit("  ─── Shader instances with name == '" + targetName + "' ───");
			Emit($"  Resources matches: {array3.Length}");
			int num = (((Object)(object)Plugin._fallbackMat != (Object)null && (Object)(object)Plugin._fallbackMat.shader != (Object)null) ? ((Object)Plugin._fallbackMat.shader).GetInstanceID() : 0);
			int num2 = (((Object)(object)Plugin._transparentMat != (Object)null && (Object)(object)Plugin._transparentMat.shader != (Object)null) ? ((Object)Plugin._transparentMat.shader).GetInstanceID() : 0);
			for (int num3 = 0; num3 < array3.Length; num3++)
			{
				Shader val = array3[num3];
				int instanceID = ((Object)val).GetInstanceID();
				bool flag = Plugin.CanonicalShaderIds.Contains(instanceID);
				int num4 = 0;
				try
				{
					num4 = val.passCount;
				}
				catch
				{
				}
				string text = "";
				if (instanceID == num)
				{
					text += "  ← _fallbackMat.shader";
				}
				if (instanceID == num2)
				{
					text += "  ← _transparentMat.shader";
				}
				Emit($"    [{num3}] id={instanceID}  isSupported={val.isSupported}  passCount={num4}  inCanonical={flag}{text}");
			}
			Emit("");
			Shader val2 = Shader.Find(targetName);
			if ((Object)(object)val2 != (Object)null)
			{
				int instanceID2 = ((Object)val2).GetInstanceID();
				bool flag2 = Plugin.CanonicalShaderIds.Contains(instanceID2);
				Emit($"  Shader.Find('{targetName}') = id={instanceID2}  isSupported={val2.isSupported}  inCanonical={flag2}");
			}
			else
			{
				Emit("  Shader.Find('" + targetName + "') = <null>");
			}
			Emit("");
			Material[] array4 = array2.Where((Material m) => (Object)(object)m != (Object)null && (Object)(object)m.shader != (Object)null && ((Object)m.shader).name == targetName).ToArray();
			Emit("  ─── Materials with shader.name == '" + targetName + "' ───");
			Emit($"  count: {array4.Length}");
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
			for (int num5 = 0; num5 < array4.Length; num5++)
			{
				Material val3 = array4[num5];
				int instanceID3 = ((Object)val3).GetInstanceID();
				int instanceID4 = ((Object)val3.shader).GetInstanceID();
				string text2 = Plugin.StripInstance(((Object)val3).name ?? string.Empty);
				bool flag3 = !string.IsNullOrEmpty(text2) && Plugin._baselineMatNames.Contains(text2);
				bool flag4 = Plugin.CanonicalShaderIds.Contains(instanceID4);
				dictionary[instanceID4] = ((!dictionary.TryGetValue(instanceID4, out var value)) ? 1 : (value + 1));
				if (flag3)
				{
					dictionary2[instanceID4] = ((!dictionary2.TryGetValue(instanceID4, out var value2)) ? 1 : (value2 + 1));
				}
				if (num5 < 50)
				{
					Emit($"    [{num5}] mat='{text2}'  matId={instanceID3}  shaderId={instanceID4}  nameInBaseline={flag3}  shaderCanonicalById={flag4}");
				}
				else if (num5 == 50)
				{
					Emit($"    … (truncated; per-instance totals below cover the full set of {array4.Length})");
				}
			}
			Emit("");
			Emit("  ─── Per-shader-instance bucket totals ───");
			if (dictionary.Count == 0)
			{
				Emit("    (no materials matched)");
				return;
			}
			foreach (KeyValuePair<int, int> item in dictionary.OrderByDescending((KeyValuePair<int, int> p) => p.Value))
			{
				bool flag5 = Plugin.CanonicalShaderIds.Contains(item.Key);
				int value3;
				int num6 = (dictionary2.TryGetValue(item.Key, out value3) ? value3 : 0);
				Emit($"    shaderId={item.Key}  totalMats={item.Value}  vanillaMats={num6}  inCanonical={flag5}");
			}
			void Emit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[ResolveShader] " + line));
			}
		}
	}
	internal static class StatusCommand
	{
		internal static void Handle(Plugin instance, ConsoleEventArgs args)
		{
			Emit("ShaderHelperForMac v3.2.0");
			Shader? fallbackShader = Plugin.FallbackShader;
			Emit("  Fallback shader:        " + (((fallbackShader != null) ? ((Object)fallbackShader).name : null) ?? "none"));
			Emit($"  Canonical IDs:          {Plugin.CanonicalShaderIds.Count}");
			Emit($"  Transparent DLLs:       {Plugin._useTransparentDlls.Count}");
			Emit($"  Fallback DLLs:          {Plugin._useFallbackDlls.Count}");
			Emit($"  Original DLLs:          {Plugin._useOriginalDlls.Count}");
			Emit($"  Transparent mat rules:  {Plugin._transparentMatNames.Count} name(s), {Plugin._transparentMatSuffixes.Count} suffix(es)");
			Emit($"  Fallback mat rules:     {Plugin._fallbackMatNames.Count} name(s), {Plugin._fallbackMatSuffixes.Count} suffix(es)");
			Emit($"  Force-fallback prefixes:    {Plugin._forceFallbackPrefixSet.Count}");
			Emit($"  Force-transparent prefixes: {Plugin._forceTransparentPrefixSet.Count}");
			Emit($"  Hide-renderer mat rules:    {Plugin._hideRendererMatNames.Count} name(s), {Plugin._hideRendererMatSuffixes.Count} suffix(es)");
			Emit($"  Vanilla shader names:   {Plugin._vanillaShaderNames.Count}  (option-3 shaderVanillaByName input)");
			Emit($"  Baseline mat names:     {Plugin._baselineMatNames.Count}  (option-3 nameInBaseline input)");
			string text = ((Plugin._baselineMatNames.Count > 0 || Plugin._vanillaShaderNames.Count > 0) ? $"cache (mats={Plugin._baselineMatNames.Count}, shaders={Plugin._vanillaShaderNames.Count}, bundles={Plugin._vanillaBundleNames.Count})" : "missing — name-side veto DISARMED; run `shaderhelper capturevanilla` from a clean install");
			Emit("  Vanilla source:         " + text);
			if (Plugin._useTransparentDlls.Count + Plugin._useFallbackDlls.Count + Plugin._useOriginalDlls.Count <= 0)
			{
				return;
			}
			if (Plugin._useTransparentDlls.Count > 0)
			{
				Emit("    Transparent DLLs: [" + string.Join(", ", Plugin._useTransparentDlls.OrderBy<string, string>((string d) => d, StringComparer.Ordinal)) + "]");
			}
			if (Plugin._useFallbackDlls.Count > 0)
			{
				Emit("    Fallback DLLs:    [" + string.Join(", ", Plugin._useFallbackDlls.OrderBy<string, string>((string d) => d, StringComparer.Ordinal)) + "]");
			}
			if (Plugin._useOriginalDlls.Count > 0)
			{
				Emit("    Original DLLs:    [" + string.Join(", ", Plugin._useOriginalDlls.OrderBy<string, string>((string d) => d, StringComparer.Ordinal)) + "]");
			}
			void Emit(string line)
			{
				args.Context.AddString(line);
				Plugin.Log.LogInfo((object)("[Status] " + line));
			}
		}
	}
	internal static class WhymatCommand
	{
		internal static void Handle(Plugin instance, ConsoleEventArgs args)
		{
			if (args.Length < 3)
			{
				args.Context.AddString("Usage: shaderhelper whymat <MaterialName> [MaterialName2] ...");
				return;
			}
			Plugin.Log.LogInfo((object)$"[WhyMat] diag: baselineMatNames={Plugin._baselineMatNames.Count}  vanillaShaderNames={Plugin._vanillaShaderNames.Count}");
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			for (int i = 2; i < args.Length; i++)
			{
				string text = args[i];
				string text2 = Plugin.StripInstancePublic(text);
				bool flag = Plugin._baselineMatNames.Contains(text2);
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				string text3 = string.Empty;
				bool flag2 = false;
				bool flag3 = false;
				bool flag4 = false;
				Material[] array2 = array;
				foreach (Material val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && Plugin.StripInstancePublic(((Object)val).name).Equals(text2, StringComparison.OrdinalIgnoreCase))
					{
						num++;
						bool flag5 = Plugin._vanillaShaderNames.Contains(((Object)val.shader).name) || Plugin.ValheimShaderNameSet.Contains(((Object)val.shader).name) || Plugin.UnityBuiltInShaderNameSet.Contains(((Object)val.shader).name);
						bool flag6 = Plugin.CanonicalShaderIds.Contains(((Object)val.shader).GetInstanceID());
						bool flag7 = flag5 || flag6;
						bool flag8 = Plugin._prefabScopedModMatIds.Contains(((Object)val).GetInstanceID());
						if (!(flag && flag7) || flag8)
						{
							num2++;
						}
						else
						{
							num3++;
						}
						if (num == 1)
						{
							text3 = ((Object)val.shader).name;
							flag2 = flag5;
							flag3 = flag6;
							flag4 = flag8;
						}
					}
				}
				string text4 = $"[WhyMat] '{text}' base='{text2}'  nameInBaseline={flag}  matsFound={num}  optionGate(PASS={num2}, FAIL={num3})";
				Plugin.Log.LogInfo((object)text4);
				args.Context.AddString(text4);
				if (num > 0)
				{
					string text5 = $"[WhyMat]   first-instance shader='{text3}'  shaderVanillaByName={flag2}  shaderCanonicalById={flag3}  prefabScopeOverride={flag4}";
					Plugin.Log.LogInfo((object)text5);
					args.Context.AddString(text5);
				}
			}
		}
	}
}