using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
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 UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ShaderHelperForMac")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0+dc76ebddf22ee462381df86da6106e4dcc2b673f")]
[assembly: AssemblyProduct("ShaderHelperForMac")]
[assembly: AssemblyTitle("ShaderHelperForMac")]
[assembly: AssemblyVersion("2.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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 Postfix()
		{
			Plugin.Log.LogDebug((object)"[ZNetScene.Awake] Postfix — running post-ZNetScene sweep.");
			Plugin.TryUpgradeFallbackShader();
			if ((Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Plugin.Instance.SweepMaterialsCoroutine());
			}
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator), "GenerateDungeon")]
	internal static class PatchDungeonGeneratorGenerate
	{
		private static void Postfix()
		{
			Plugin.Log.LogDebug((object)"[DungeonGenerator.GenerateDungeon] Postfix — sweeping materials after dungeon generation.");
			if ((Object)(object)Plugin.Instance != (Object)null)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Plugin.Instance.SweepMaterialsCoroutine());
			}
		}
	}
	[HarmonyPatch(typeof(VisEquipment), "AttachItem")]
	internal static class PatchVisEquipmentAttachItem
	{
		private static void Postfix()
		{
			if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				Plugin.Instance.SweepMaterials();
			}
		}
	}
	[HarmonyPatch(typeof(AssetBundle), "LoadAsset", new Type[]
	{
		typeof(string),
		typeof(Type)
	})]
	internal static class PatchAssetBundleLoadAsset
	{
		private static void Postfix(Object __result)
		{
			if (!(__result == (Object)null))
			{
				Material val = (Material)(object)((__result is Material) ? __result : null);
				if (val != null)
				{
					Plugin.TryReplaceMaterialPublic(val);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Shader), "Find")]
	internal static class PatchShaderFind
	{
		private static void Postfix(ref Shader? __result)
		{
			if (!((Object)(object)__result == (Object)null) && (!__result.isSupported || ((Object)__result).name.StartsWith("Hidden/InternalErrorShader", StringComparison.OrdinalIgnoreCase)) && !Plugin.CanonicalShaderIds.Contains(((Object)__result).GetInstanceID()) && !ShaderScanner.IsLikelySafeShader(((Object)__result).name) && Plugin.ShouldReplace(((Object)__result).name))
			{
				Shader replacementShader = Plugin.GetReplacementShader(((Object)__result).name);
				if ((Object)(object)replacementShader != (Object)null)
				{
					__result = replacementShader;
				}
			}
		}
	}
	[DefaultExecutionOrder(30000)]
	internal 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;
			}
		}
	}
	[BepInPlugin("drummercraig.shaderhelperformac", "ShaderHelperForMac", "2.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private enum ShaderAction
		{
			Transparent,
			Fallback,
			Original
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass67_0
		{
			public string name;

			internal bool <InitAfterFrame>b__0(Shader sh)
			{
				if (((Object)sh).name == name)
				{
					return sh.isSupported;
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass67_1
		{
			public string name;

			internal bool <InitAfterFrame>b__1(Shader sh)
			{
				return ((Object)sh).name == name;
			}
		}

		[CompilerGenerated]
		private sealed class <InitAfterFrame>d__67 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <InitAfterFrame>d__67(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
					Log.LogDebug((object)$"Scanning {array.Length} loaded shader objects for a supported fallback.");
					string[] fallbackChain = FallbackChain;
					for (int i = 0; i < fallbackChain.Length; i++)
					{
						<>c__DisplayClass67_0 CS$<>8__locals0 = new <>c__DisplayClass67_0
						{
							name = fallbackChain[i]
						};
						Shader val = Shader.Find(CS$<>8__locals0.name) ?? ((IEnumerable<Shader>)array).FirstOrDefault((Func<Shader, bool>)((Shader sh) => ((Object)sh).name == CS$<>8__locals0.name && sh.isSupported));
						if ((Object)(object)val != (Object)null && val.isSupported)
						{
							FallbackShader = val;
							Log.LogDebug((object)$"Using fallback shader (supported): '{CS$<>8__locals0.name}'  id={((Object)FallbackShader).GetInstanceID()}");
							break;
						}
					}
					if ((Object)(object)FallbackShader == (Object)null)
					{
						fallbackChain = FallbackChain;
						for (int i = 0; i < fallbackChain.Length; i++)
						{
							<>c__DisplayClass67_1 CS$<>8__locals1 = new <>c__DisplayClass67_1
							{
								name = fallbackChain[i]
							};
							Shader val2 = Shader.Find(CS$<>8__locals1.name) ?? ((IEnumerable<Shader>)array).FirstOrDefault((Func<Shader, bool>)((Shader sh) => ((Object)sh).name == CS$<>8__locals1.name));
							if ((Object)(object)val2 != (Object)null)
							{
								FallbackShader = val2;
								Log.LogWarning((object)$"Using fallback shader (unsupported, last resort): '{CS$<>8__locals1.name}'  id={((Object)FallbackShader).GetInstanceID()}");
								break;
							}
						}
					}
					BuildTransparentMaterial();
					if ((Object)(object)FallbackShader == (Object)null)
					{
						Log.LogWarning((object)"No fallback shader found — transparent-only sweep running; will retry full init on next scene load.");
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					CollectCanonicalShaderIds();
					BuildReplacementMaterials();
					plugin._initialized = true;
					try
					{
						new Harmony("drummercraig.shaderhelperformac").PatchAll();
						Log.LogDebug((object)"Harmony patches installed.");
					}
					catch (Exception ex)
					{
						Log.LogError((object)("Harmony patching error (some patches may be missing): " + ex.Message));
					}
					plugin.RegisterCommands();
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				case 2:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)plugin).StartCoroutine(plugin.SweepMaterialsCoroutine());
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				case 4:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)plugin).StartCoroutine(plugin.SweepMaterialsCoroutine());
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					((MonoBehaviour)plugin).StartCoroutine(plugin.PeriodicSweepCoroutine());
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <PeriodicSweepCoroutine>d__68 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PeriodicSweepCoroutine>d__68(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				int num = <>1__state;
				Plugin plugin = <>4__this;
				float periodicSweepInterval;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_002d;
				case 1:
					<>1__state = -1;
					goto IL_002d;
				case 2:
					<>1__state = -1;
					if (plugin._initialized && !((Object)(object)Player.m_localPlayer == (Object)null))
					{
						<>2__current = ((MonoBehaviour)plugin).StartCoroutine(plugin.SweepMaterialsCoroutine());
						<>1__state = 3;
						return true;
					}
					goto IL_002d;
				case 3:
					{
						<>1__state = -1;
						goto IL_002d;
					}
					IL_002d:
					periodicSweepInterval = PeriodicSweepInterval;
					if (periodicSweepInterval <= 0f)
					{
						<>2__current = (object)new WaitForSeconds(5f);
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(periodicSweepInterval);
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SweepAfterFrame>d__69 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SweepAfterFrame>d__69(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)plugin).StartCoroutine(plugin.SweepMaterialsCoroutine());
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SweepAndNotifyCoroutine>d__91 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SweepAndNotifyCoroutine>d__91(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((MonoBehaviour)plugin).StartCoroutine(plugin.SweepMaterialsCoroutine());
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					MessageHud instance = MessageHud.instance;
					if (instance != null)
					{
						instance.ShowMessage((MessageType)2, "Shader sweep complete", 0, (Sprite)null, false);
					}
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SweepMaterialsCoroutine>d__94 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Plugin <>4__this;

			private int <replaced>5__2;

			private Renderer[] <allRenderers>5__3;

			private Material[] <allMaterials>5__4;

			private int <ri>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SweepMaterialsCoroutine>d__94(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<allRenderers>5__3 = null;
				<allMaterials>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Plugin plugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (plugin._sweepRunning)
					{
						return false;
					}
					if ((Object)(object)_transparentMat == (Object)null && (Object)(object)_fallbackMat == (Object)null)
					{
						return false;
					}
					plugin._sweepRunning = true;
					<replaced>5__2 = 0;
					<allRenderers>5__3 = Resources.FindObjectsOfTypeAll<Renderer>();
					<ri>5__5 = 0;
					goto IL_02d2;
				case 1:
					<>1__state = -1;
					goto IL_02c0;
				case 2:
					<>1__state = -1;
					goto IL_033a;
				case 3:
					{
						<>1__state = -1;
						goto IL_03da;
					}
					IL_034c:
					if (<ri>5__5 < <allMaterials>5__4.Length)
					{
						<replaced>5__2 += TryReplaceMaterial(<allMaterials>5__4[<ri>5__5]);
						if (<ri>5__5 % 100 == 0)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						goto IL_033a;
					}
					<ri>5__5 = 0;
					goto IL_03ec;
					IL_02c0:
					<ri>5__5++;
					goto IL_02d2;
					IL_033a:
					<ri>5__5++;
					goto IL_034c;
					IL_03ec:
					if (<ri>5__5 < <allRenderers>5__3.Length)
					{
						Renderer val = <allRenderers>5__3[<ri>5__5];
						if (!((Object)(object)val == (Object)null))
						{
							Material[] sharedMaterials = val.sharedMaterials;
							foreach (Material mat in sharedMaterials)
							{
								<replaced>5__2 += TryReplaceMaterial(mat);
							}
							if (<ri>5__5 % 100 == 0)
							{
								<>2__current = null;
								<>1__state = 3;
								return true;
							}
						}
						goto IL_03da;
					}
					if (<replaced>5__2 > 0)
					{
						Log.LogInfo((object)$"Replaced {<replaced>5__2} material(s).");
					}
					plugin._sweepRunning = false;
					return false;
					IL_02d2:
					if (<ri>5__5 < <allRenderers>5__3.Length)
					{
						Renderer val2 = <allRenderers>5__3[<ri>5__5];
						if (!((Object)(object)val2 == (Object)null))
						{
							bool flag = false;
							bool flag2 = false;
							Material[] sharedMaterials = val2.sharedMaterials;
							foreach (Material val3 in sharedMaterials)
							{
								if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.shader == (Object)null) && !((Object)(object)val3 == (Object)(object)_transparentMat) && !((Object)(object)val3 == (Object)(object)_fallbackMat))
								{
									if (_forceReplacedMaterialIds.Contains(((Object)val3).GetInstanceID()))
									{
										flag2 = true;
										break;
									}
									if ((NeedsReplacement(val3) || IsExplicitMatRule(val3)) && GetAction(val3) != ShaderAction.Original)
									{
										flag = true;
										break;
									}
								}
							}
							if (flag2 && val2 is ParticleSystemRenderer && val2.enabled)
							{
								val2.enabled = false;
								if ((Object)(object)((Component)val2).gameObject.GetComponent<KeepRendererDisabled>() == (Object)null)
								{
									((Component)val2).gameObject.AddComponent<KeepRendererDisabled>();
								}
								Log.LogDebug((object)("[RendererDisable] '" + ((Object)((Component)val2).gameObject).name + "' — ParticleSystemRenderer disabled (shared mat was force-replaced)."));
							}
							else if (flag)
							{
								Material[] materials = val2.materials;
								bool flag3 = false;
								bool flag4 = true;
								for (int j = 0; j < materials.Length; j++)
								{
									if (!((Object)(object)materials[j] == (Object)null) && !((Object)(object)materials[j].shader == (Object)null) && NeedsReplacement(materials[j]))
									{
										if (GetAction(materials[j]) != 0)
										{
											flag4 = false;
										}
										if (TryReplaceMaterial(materials[j]) > 0)
										{
											flag3 = true;
											<replaced>5__2++;
										}
									}
								}
								if (flag3)
								{
									val2.materials = materials;
									if (flag4 && val2 is ParticleSystemRenderer)
									{
										val2.enabled = false;
										if ((Object)(object)((Component)val2).gameObject.GetComponent<KeepRendererDisabled>() == (Object)null)
										{
											((Component)val2).gameObject.AddComponent<KeepRendererDisabled>();
										}
										Log.LogDebug((object)("[InstanceFix] '" + ((Object)((Component)val2).gameObject).name + "' — disabled ParticleSystemRenderer (force-transparent)."));
									}
									else
									{
										Log.LogDebug((object)$"[InstanceFix] '{((Object)((Component)val2).gameObject).name}' — {materials.Length} instance mat(s) updated.");
									}
								}
							}
							if (<ri>5__5 % 100 == 0)
							{
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
						}
						goto IL_02c0;
					}
					<allMaterials>5__4 = Resources.FindObjectsOfTypeAll<Material>();
					<ri>5__5 = 0;
					goto IL_034c;
					IL_03da:
					<ri>5__5++;
					goto IL_03ec;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string PluginGuid = "drummercraig.shaderhelperformac";

		public const string PluginName = "ShaderHelperForMac";

		public const string PluginVersion = "2.0.0";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private FileSystemWatcher? _watcher;

		private ConfigEntry<bool> _cfgDefaultAllTransparent;

		private ConfigEntry<string> _cfgForceTransparentPrefixes;

		private ConfigEntry<string> _cfgForceFallbackPrefixes;

		private ConfigEntry<float> _cfgPeriodicSweepInterval;

		private static Plugin? _instance;

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

		private static readonly string[] FallbackChain = new string[3] { "Custom/Creature", "Custom/Piece", "Custom/Vegetation" };

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

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

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

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

		private 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"
		};

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

		private static Material? _transparentMat;

		private static Material? _fallbackMat;

		private bool _initialized;

		private bool _sweepRunning;

		private const int SweepBatchSize = 100;

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


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


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

		internal static bool DefaultAllTransparent => _instance?._cfgDefaultAllTransparent.Value ?? true;

		internal static string ForceTransparentPrefixes => _instance?._cfgForceTransparentPrefixes.Value ?? string.Empty;

		internal static string ForceFallbackPrefixes => _instance?._cfgForceFallbackPrefixes.Value ?? string.Empty;

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

		internal static Shader? FallbackShader { get; private set; }

		private void Awake()
		{
			Instance = this;
			_instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			_cfgDefaultAllTransparent = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Default All Transparent", false, "When true, all unsupported shaders are made transparent automatically. Add DLL names to useoriginalshader.txt to skip specific mods. When false, shaders are left as-is (pink) unless the DLL is listed in usetransparentshader.txt or usefallbackshader.txt.");
			_cfgForceTransparentPrefixes = ((BaseUnityPlugin)this).Config.Bind<string>("General", "Force Transparent Shader Prefixes", "", "Comma-separated list of shader name prefixes that are always made transparent, regardless of the Default All Transparent setting. Clear this value to disable all forced replacements.");
			_cfgForceFallbackPrefixes = ((BaseUnityPlugin)this).Config.Bind<string>("General", "Force Fallback Shader Prefixes", "", "Comma-separated list of shader name prefixes that always use the fallback shader, even if Unity reports the shader as supported on Metal. Use this for mod shaders that render pink despite isSupported=true (e.g. Dreanegade/).");
			_cfgPeriodicSweepInterval = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Periodic Sweep Interval", 30f, "How often (in seconds) to re-sweep all materials after the initial load. Catches shaders on objects that spawn dynamically (VFX, status effects, etc.). Set to 0 to disable the periodic sweep.");
			Log.LogDebug((object)$"[Config] DefaultAllTransparent = {_cfgDefaultAllTransparent.Value}");
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string item = StripInstance(((Object)val).name);
					_baselineMatNames.Add(item);
				}
			}
			Log.LogDebug((object)$"Baseline materials captured: {_baselineMatNames.Count}");
			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 item2 in ModShaderDlls.Values.Distinct())
			{
				Log.LogDebug((object)("  Shaders found in: '" + item2 + "'"));
			}
			EnsureConfigFiles();
			ReloadConfigFiles();
			StartConfigWatcher();
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

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

		private static void EnsureConfigFiles()
		{
			Directory.CreateDirectory(ConfigDir);
			string path = Path.Combine(ConfigDir, 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(ConfigDir, 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(ConfigDir, UseOriginalShaderFile);
			if (!File.Exists(path3))
			{
				File.WriteAllText(path3, "# Mods listed here will be left completely untouched (shaders not changed).\n# Use when DefaultAllTransparent=true but you want a specific mod left as-is.\n#\n# One DLL name per line (without the .dll extension), case-insensitive.\n# Lines starting with # are comments.\n#\n");
			}
		}

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

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

		private static void LoadModFile(string filePath)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
			string text = string.Empty;
			string[] array = File.ReadAllLines(filePath);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2.StartsWith("#"))
				{
					continue;
				}
				if (text2.StartsWith("[") && text2.EndsWith("]"))
				{
					text = text2.Substring(1, text2.Length - 2).ToLowerInvariant();
					continue;
				}
				switch (text)
				{
				case "default":
					if (text2.Equals("fallback", StringComparison.OrdinalIgnoreCase))
					{
						_useFallbackDlls.Add(fileNameWithoutExtension);
					}
					else if (text2.Equals("transparent", StringComparison.OrdinalIgnoreCase))
					{
						_useTransparentDlls.Add(fileNameWithoutExtension);
					}
					else if (text2.Equals("original", StringComparison.OrdinalIgnoreCase))
					{
						_useOriginalDlls.Add(fileNameWithoutExtension);
					}
					break;
				case "fallback":
					ParseRuleLine(text2, _useFallbackDlls, _fallbackMatNames, _fallbackMatSuffixes);
					break;
				case "transparent":
					ParseRuleLine(text2, _useTransparentDlls, _transparentMatNames, _transparentMatSuffixes);
					break;
				case "original":
					if (text2.StartsWith("mat:", StringComparison.OrdinalIgnoreCase))
					{
						_originalMatNames.Add(text2.Substring(4).Trim());
					}
					else if (!text2.StartsWith("suffix:", StringComparison.OrdinalIgnoreCase))
					{
						_useOriginalDlls.Add(text2);
					}
					break;
				case "forcefallback":
					_forceFallbackPrefixSet.Add(text2);
					break;
				case "forcetransparent":
					_forceTransparentPrefixSet.Add(text2);
					break;
				}
			}
		}

		private static void ReloadConfigFiles()
		{
			_useTransparentDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_useFallbackDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_useOriginalDlls = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_transparentMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_fallbackMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_originalMatNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_transparentMatSuffixes = new List<string>();
			_fallbackMatSuffixes = new List<string>();
			_forceFallbackPrefixSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_forceTransparentPrefixSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			_builtInFallbackPrefixes.Clear();
			_builtInTransparentPrefixes.Clear();
			_builtInTransparentPrefixes.Add("Legacy Shaders/Particles/");
			_forceTransparentPrefixSet.Add("Legacy Shaders/Particles/");
			string[] array = ForceFallbackPrefixes.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					_forceFallbackPrefixSet.Add(text);
				}
			}
			array = ForceTransparentPrefixes.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					_forceTransparentPrefixSet.Add(text2);
				}
			}
			LoadConfigFile(UseTransparentShaderFile, _useTransparentDlls, _transparentMatNames, _transparentMatSuffixes);
			LoadConfigFile(UseFallbackShaderFile, _useFallbackDlls, _fallbackMatNames, _fallbackMatSuffixes);
			HashSet<string> matNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			List<string> matSuffixes = new List<string>();
			LoadConfigFile(UseOriginalShaderFile, _useOriginalDlls, matNames, matSuffixes);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { UseTransparentShaderFile, UseFallbackShaderFile, UseOriginalShaderFile };
			array = Directory.GetFiles(ConfigDir, "*.txt");
			foreach (string text3 in array)
			{
				if (!hashSet.Contains(Path.GetFileName(text3)))
				{
					LoadModFile(text3);
				}
			}
			Log.LogDebug((object)($"Config loaded: {_useTransparentDlls.Count} transparent, {_useFallbackDlls.Count} fallback, {_useOriginalDlls.Count} original DLL(s); " + $"{_transparentMatNames.Count + _transparentMatSuffixes.Count} transparent mat rule(s), " + $"{_fallbackMatNames.Count + _fallbackMatSuffixes.Count} fallback mat rule(s); " + $"{_forceFallbackPrefixSet.Count} force-fallback prefix(es), {_forceTransparentPrefixSet.Count} force-transparent prefix(es)."));
		}

		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(InitAfterFrame());
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(SweepAfterFrame());
			}
		}

		[IteratorStateMachine(typeof(<InitAfterFrame>d__67))]
		private IEnumerator InitAfterFrame()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitAfterFrame>d__67(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<PeriodicSweepCoroutine>d__68))]
		private IEnumerator PeriodicSweepCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PeriodicSweepCoroutine>d__68(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SweepAfterFrame>d__69))]
		private IEnumerator SweepAfterFrame()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SweepAfterFrame>d__69(0)
			{
				<>4__this = this
			};
		}

		private void RegisterCommands()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			new ConsoleCommand("shaderhelper", "[sweep|scan|pink|status]  ShaderHelperForMac — manually trigger a material sweep, scan a mod's shaders, find unhandled pink materials, or show status.", (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				//IL_0a76: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a82: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d03: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d0f: Unknown result type (might be due to invalid IL or missing references)
				//IL_1378: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e51: Unknown result type (might be due to invalid IL or missing references)
				//IL_0e56: Unknown result type (might be due to invalid IL or missing references)
				//IL_0c0d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0c12: Unknown result type (might be due to invalid IL or missing references)
				string text = ((args.Length > 1) ? args[1].ToLowerInvariant() : "help");
				switch (text)
				{
				case "reload":
					ReloadConfigFiles();
					args.Context.AddString("ShaderHelperForMac: config reloaded.");
					break;
				case "sweep":
					if (!_initialized)
					{
						args.Context.AddString("ShaderHelperForMac: not yet initialized — enter a world first.");
					}
					else
					{
						ReloadConfigFiles();
						args.Context.AddString("ShaderHelperForMac: running sweep...");
						SweepMaterialsWithNotify();
					}
					break;
				case "dumpmod":
				{
					string dumpTarget = ((args.Length > 2) ? args[2] : string.Empty);
					if (string.IsNullOrEmpty(dumpTarget))
					{
						args.Context.AddString("Usage: shaderhelper dumpmod <DllName>");
					}
					else
					{
						List<string> list6 = (from kv in ModShaderDlls
							where kv.Value.Equals(dumpTarget, StringComparison.OrdinalIgnoreCase)
							select kv.Key into n
							orderby n
							select n).ToList();
						args.Context.AddString($"ShaderHelperForMac: {list6.Count} shader(s) recorded for '{dumpTarget}':");
						foreach (string item15 in list6)
						{
							Log.LogInfo((object)("[DumpMod] '" + item15 + "'"));
						}
						args.Context.AddString("See BepInEx/LogOutput.log for the full list.");
					}
					break;
				}
				case "scan":
				{
					string text22 = ((args.Length > 2) ? args[2] : string.Empty);
					if (string.IsNullOrEmpty(text22))
					{
						args.Context.AddString("Usage: shaderhelper scan <DllName>");
					}
					else
					{
						int num14 = 0;
						Material[] array = Resources.FindObjectsOfTypeAll<Material>();
						foreach (Material val17 in array)
						{
							if (!((Object)(object)val17 == (Object)null) && !((Object)(object)val17.shader == (Object)null) && ModShaderDlls.TryGetValue(((Object)val17.shader).name, out string value20) && value20.Equals(text22, StringComparison.OrdinalIgnoreCase))
							{
								Log.LogInfo((object)$"[Scan] mat='{((Object)val17).name}'  shader='{((Object)val17.shader).name}'  supported={val17.shader.isSupported}");
								num14++;
							}
						}
						args.Context.AddString($"ShaderHelperForMac: found {num14} material(s) from '{text22}'. Check BepInEx/LogOutput.log for details.");
					}
					break;
				}
				case "pink":
				{
					int num6 = 0;
					HashSet<string> hashSet3 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
					Material[] array = Resources.FindObjectsOfTypeAll<Material>();
					foreach (Material val10 in array)
					{
						if (!((Object)(object)val10 == (Object)null) && !((Object)(object)val10.shader == (Object)null) && !((Object)(object)val10 == (Object)(object)_transparentMat) && NeedsReplacement(val10) && GetAction(val10) == ShaderAction.Original)
						{
							string text15 = StripInstance(((Object)val10).name);
							if (hashSet3.Add(text15))
							{
								ModShaderDlls.TryGetValue(((Object)val10.shader).name, out string value14);
								Log.LogInfo((object)string.Format("[Pink] mat='{0}'  shader='{1}'  supported={2}  dll='{3}'", text15, ((Object)val10.shader).name, val10.shader.isSupported, value14 ?? "unknown"));
								num6++;
							}
						}
					}
					args.Context.AddString($"ShaderHelperForMac: found {num6} unhandled pink material(s). Check BepInEx/LogOutput.log for details.");
					break;
				}
				case "shaders":
				{
					int num13 = 0;
					Shader[] array5 = Resources.FindObjectsOfTypeAll<Shader>();
					foreach (Shader val16 in array5)
					{
						if (!((Object)(object)val16 == (Object)null) && (!((Object)val16).name.StartsWith("Hidden/") || ((Object)val16).name.Contains("InternalError")) && !((Object)val16).name.StartsWith("GUI/") && !((Object)val16).name.StartsWith("UI/"))
						{
							ModShaderDlls.TryGetValue(((Object)val16).name, out string value19);
							bool flag12 = ValheimShaderNameSet.Contains(((Object)val16).name);
							Log.LogInfo((object)string.Format("[Shader] name='{0}'  supported={1}  dll='{2}'  valheim={3}", ((Object)val16).name, val16.isSupported, value19 ?? "unknown", flag12));
							num13++;
						}
					}
					args.Context.AddString($"ShaderHelperForMac: dumped {num13} shader(s). Check BepInEx/LogOutput.log.");
					break;
				}
				case "renderers":
				{
					int num5 = 0;
					Renderer[] array2 = Resources.FindObjectsOfTypeAll<Renderer>();
					foreach (Renderer val8 in array2)
					{
						if (!((Object)(object)val8 == (Object)null))
						{
							Material[] array = val8.sharedMaterials;
							foreach (Material val9 in array)
							{
								if (!((Object)(object)val9 == (Object)null) && !((Object)(object)val9.shader == (Object)null) && !(((Object)val9.shader).name == "Standard") && !(((Object)val9.shader).name == "Sprites/Default"))
								{
									ModShaderDlls.TryGetValue(((Object)val9.shader).name, out string value13);
									ShaderAction action = GetAction(val9);
									Log.LogInfo((object)string.Format("[Rend] go='{0}'  mat='{1}'  shader='{2}'  supported={3}  action={4}  dll='{5}'", ((Object)((Component)val8).gameObject).name, ((Object)val9).name, ((Object)val9.shader).name, val9.shader.isSupported, action, value13 ?? "unknown"));
									num5++;
								}
							}
						}
					}
					args.Context.AddString($"ShaderHelperForMac: found {num5} renderer material(s). Check BepInEx/LogOutput.log.");
					break;
				}
				case "all":
				{
					int num7 = 0;
					Material[] array = Resources.FindObjectsOfTypeAll<Material>();
					foreach (Material val11 in array)
					{
						if (!((Object)(object)val11 == (Object)null) && !((Object)(object)val11.shader == (Object)null) && !((Object)(object)val11 == (Object)(object)_transparentMat) && !((Object)(object)val11 == (Object)(object)_fallbackMat) && !(((Object)val11.shader).name == "Standard") && !(((Object)val11.shader).name == "Sprites/Default") && !ShaderScanner.IsLikelySafeShader(((Object)val11.shader).name))
						{
							ModShaderDlls.TryGetValue(((Object)val11.shader).name, out string value15);
							ShaderAction action2 = GetAction(val11);
							Log.LogInfo((object)string.Format("[All] mat='{0}'  shader='{1}'  supported={2}  action={3}  dll='{4}'", ((Object)val11).name, ((Object)val11.shader).name, val11.shader.isSupported, action2, value15 ?? "unknown"));
							num7++;
						}
					}
					args.Context.AddString($"ShaderHelperForMac: dumped {num7} material(s). Check BepInEx/LogOutput.log for details.");
					break;
				}
				case "nearby":
				{
					Player localPlayer = Player.m_localPlayer;
					if ((Object)(object)localPlayer == (Object)null)
					{
						args.Context.AddString("ShaderHelperForMac: no local player found.");
					}
					else
					{
						float num9 = 30f;
						bool flag9 = false;
						string nbDllFilter = string.Empty;
						for (int k = 2; k < args.Length; k++)
						{
							float result;
							if (args[k].Equals("mod", StringComparison.OrdinalIgnoreCase))
							{
								flag9 = true;
							}
							else if (float.TryParse(args[k], out result))
							{
								num9 = result;
							}
							else
							{
								nbDllFilter = args[k];
							}
						}
						if (!string.IsNullOrEmpty(nbDllFilter))
						{
							string text17 = ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase));
							if (text17 != null)
							{
								nbDllFilter = text17;
							}
							else
							{
								flag9 = true;
								args.Context.AddString("ShaderHelperForMac: '" + nbDllFilter + "' not in scan results (large embedded bundle) — applying mod filter to exclude vanilla materials.");
							}
						}
						Renderer[] array3 = Resources.FindObjectsOfTypeAll<Renderer>();
						int num10 = 0;
						Renderer[] array2 = array3;
						Color color;
						foreach (Renderer val13 in array2)
						{
							if (!((Object)(object)val13 == (Object)null))
							{
								float num11 = Vector3.Distance(((Component)val13).transform.position, ((Component)localPlayer).transform.position);
								if (!(num11 > num9))
								{
									string name = ((object)val13).GetType().Name;
									Transform parent = ((Component)val13).transform.parent;
									string text18 = ((parent != null) ? ((Object)parent).name : null) ?? "(root)";
									Material[] array = val13.sharedMaterials;
									foreach (Material val14 in array)
									{
										if (!((Object)(object)val14 == (Object)null) && !((Object)(object)val14.shader == (Object)null))
										{
											ModShaderDlls.TryGetValue(((Object)val14.shader).name, out string value17);
											if (!string.IsNullOrEmpty(nbDllFilter))
											{
												bool flag10 = value17 != null;
												if ((flag10 && !value17.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase)) || (!flag10 && ModShaderDlls.Values.Any((string d) => d.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase))))
												{
													continue;
												}
											}
											if (!flag9 || (!CanonicalShaderIds.Contains(((Object)val14.shader).GetInstanceID()) && !ValheimShaderNameSet.Contains(((Object)val14.shader).name) && !ShaderScanner.IsLikelySafeShader(((Object)val14.shader).name) && !((Object)val14.shader).name.StartsWith("Lux Lit Particles/", StringComparison.OrdinalIgnoreCase)))
											{
												ShaderAction action4 = GetAction(val14);
												object obj;
												if (!val14.HasProperty("_Color"))
												{
													obj = "n/a";
												}
												else
												{
													color = val14.color;
													obj = ((object)(Color)(ref color)).ToString();
												}
												string text19 = (string)obj;
												Log.LogInfo((object)string.Format("[Near] dist={0:F1}  type={1}  parent='{2}'  go='{3}'  mat:{4}  shader='{5}'  supported={6}  action={7}  color={8}  dll='{9}'", num11, name, text18, ((Object)((Component)val13).gameObject).name, StripInstance(((Object)val14).name), ((Object)val14.shader).name, val14.shader.isSupported, action4, text19, value17 ?? "unknown"));
												num10++;
											}
										}
									}
								}
							}
						}
						CanvasRenderer[] array4 = Resources.FindObjectsOfTypeAll<CanvasRenderer>();
						foreach (CanvasRenderer val15 in array4)
						{
							if (!((Object)(object)val15 == (Object)null))
							{
								float num12 = Vector3.Distance(((Component)val15).transform.position, ((Component)localPlayer).transform.position);
								if (!(num12 > num9))
								{
									int materialCount = val15.materialCount;
									for (int l = 0; l < materialCount; l++)
									{
										Material material = val15.GetMaterial(l);
										if (!((Object)(object)material == (Object)null) && !((Object)(object)material.shader == (Object)null))
										{
											ModShaderDlls.TryGetValue(((Object)material.shader).name, out string value18);
											if (!string.IsNullOrEmpty(nbDllFilter))
											{
												bool flag11 = value18 != null;
												if ((flag11 && !value18.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase)) || (!flag11 && ModShaderDlls.Values.Any((string d) => d.Equals(nbDllFilter, StringComparison.OrdinalIgnoreCase))))
												{
													continue;
												}
											}
											if (!flag9 || (!CanonicalShaderIds.Contains(((Object)material.shader).GetInstanceID()) && !ValheimShaderNameSet.Contains(((Object)material.shader).name) && !ShaderScanner.IsLikelySafeShader(((Object)material.shader).name)))
											{
												ShaderAction action5 = GetAction(material);
												object obj2;
												if (!material.HasProperty("_Color"))
												{
													obj2 = "n/a";
												}
												else
												{
													color = material.color;
													obj2 = ((object)(Color)(ref color)).ToString();
												}
												string text20 = (string)obj2;
												Transform parent2 = ((Component)val15).transform.parent;
												string text21 = ((parent2 != null) ? ((Object)parent2).name : null) ?? "(root)";
												Log.LogInfo((object)string.Format("[Near] dist={0:F1}  type=CanvasRenderer  parent='{1}'  go='{2}'  mat:{3}  shader='{4}'  supported={5}  action={6}  color={7}  dll='{8}'", num12, text21, ((Object)((Component)val15).gameObject).name, StripInstance(((Object)material).name), ((Object)material.shader).name, material.shader.isSupported, action5, text20, value18 ?? "unknown"));
												num10++;
											}
										}
									}
								}
							}
						}
						string arg2 = ((!string.IsNullOrEmpty(nbDllFilter)) ? (" from '" + nbDllFilter + "'") : (flag9 ? " (mod filter)" : string.Empty));
						args.Context.AddString($"ShaderHelperForMac: found {num10} materials within {num9} units{arg2}. Check BepInEx/LogOutput.log.");
					}
					break;
				}
				case "transparent":
				{
					string trFilter = ((args.Length > 2) ? args[2] : string.Empty);
					if (string.IsNullOrEmpty(trFilter))
					{
						args.Context.AddString("Usage: shaderhelper transparent <DllName>");
					}
					else
					{
						string text12 = ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(trFilter, StringComparison.OrdinalIgnoreCase));
						bool flag6 = text12 == null;
						if (flag6)
						{
							text12 = trFilter;
							args.Context.AddString("ShaderHelperForMac: '" + trFilter + "' not in scan results (large embedded bundle?) — showing all transparent materials with dll='unknown'.");
						}
						HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
						int num4 = 0;
						Material[] array = Resources.FindObjectsOfTypeAll<Material>();
						foreach (Material val7 in array)
						{
							if (!((Object)(object)val7 == (Object)null) && !((Object)(object)val7.shader == (Object)null) && !((Object)(object)val7 == (Object)(object)_transparentMat) && !((Object)(object)val7 == (Object)(object)_fallbackMat))
							{
								ModShaderDlls.TryGetValue(((Object)val7.shader).name, out string value12);
								if (flag6)
								{
									if (value12 != null)
									{
										continue;
									}
								}
								else if (!text12.Equals(value12, StringComparison.OrdinalIgnoreCase))
								{
									continue;
								}
								bool flag7 = _forceReplacedMaterialIds.Contains(((Object)val7).GetInstanceID());
								if (flag7 || (NeedsReplacement(val7) && GetAction(val7) == ShaderAction.Transparent))
								{
									string text13 = StripInstance(((Object)val7).name);
									if (hashSet2.Add(text13))
									{
										string text14 = (flag7 ? "replaced" : "pending");
										Log.LogInfo((object)("[Trans] state=" + text14 + "  mat='" + text13 + "'  shader='" + ((Object)val7.shader).name + "'  dll='" + (value12 ?? "unknown") + "'"));
										num4++;
									}
								}
							}
						}
						args.Context.AddString($"ShaderHelperForMac: {num4} transparent material(s) from '{text12}'. Add mat: rules to [fallback] to make them visible.");
						args.Context.AddString("Check BepInEx/LogOutput.log for material names.");
					}
					break;
				}
				case "loaded":
				{
					string ldFilter = ((args.Length > 2) ? args[2] : string.Empty);
					bool flag8 = !string.IsNullOrEmpty(ldFilter);
					string text16 = (flag8 ? ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(ldFilter, StringComparison.OrdinalIgnoreCase)) : null);
					if (flag8 && text16 == null)
					{
						args.Context.AddString("ShaderHelperForMac: '" + ldFilter + "' not in scan results (large embedded bundle?) — showing all materials with dll='unknown'.");
					}
					int num8 = 0;
					Material[] array = Resources.FindObjectsOfTypeAll<Material>();
					foreach (Material val12 in array)
					{
						if (!((Object)(object)val12 == (Object)null) && !((Object)(object)val12.shader == (Object)null) && !((Object)(object)val12 == (Object)(object)_transparentMat) && !((Object)(object)val12 == (Object)(object)_fallbackMat))
						{
							ModShaderDlls.TryGetValue(((Object)val12.shader).name, out string value16);
							if (flag8)
							{
								if (text16 != null)
								{
									if (!text16.Equals(value16, StringComparison.OrdinalIgnoreCase))
									{
										continue;
									}
								}
								else if (value16 != null)
								{
									continue;
								}
							}
							if (((Object)val12.shader).name.Equals("Standard", StringComparison.OrdinalIgnoreCase))
							{
								string item14 = StripInstance(((Object)val12).name);
								if (!_baselineMatNames.Contains(item14))
								{
									ShaderAction action3 = GetAction(val12);
									if (action3 == ShaderAction.Original)
									{
										Log.LogInfo((object)string.Format("[Loaded] mat='{0}'  shader='{1}'  supported={2}  action={3}  color={4}  dll='{5}'", ((Object)val12).name, ((Object)val12.shader).name, val12.shader.isSupported, action3, val12.color, value16 ?? "unknown"));
										num8++;
									}
								}
							}
						}
					}
					string arg = (flag8 ? (" from '" + ldFilter + "'") : string.Empty);
					args.Context.AddString($"ShaderHelperForMac: logged {num8} unhandled material(s){arg}. Check BepInEx/LogOutput.log.");
					break;
				}
				case "status":
				{
					args.Context.AddString("ShaderHelperForMac v2.0.0");
					args.Context.AddString($"  DefaultAllTransparent:  {DefaultAllTransparent}");
					Terminal context = args.Context;
					Shader? fallbackShader = FallbackShader;
					context.AddString("  Fallback shader:        " + (((fallbackShader != null) ? ((Object)fallbackShader).name : null) ?? "none"));
					args.Context.AddString($"  Canonical IDs:          {CanonicalShaderIds.Count}");
					args.Context.AddString($"  Transparent DLLs:       {_useTransparentDlls.Count}");
					args.Context.AddString($"  Fallback DLLs:          {_useFallbackDlls.Count}");
					args.Context.AddString($"  Original DLLs:          {_useOriginalDlls.Count}");
					args.Context.AddString($"  Transparent mat rules:  {_transparentMatNames.Count} name(s), {_transparentMatSuffixes.Count} suffix(es)");
					args.Context.AddString($"  Fallback mat rules:     {_fallbackMatNames.Count} name(s), {_fallbackMatSuffixes.Count} suffix(es)");
					args.Context.AddString($"  Force-fallback prefixes:    {_forceFallbackPrefixSet.Count}");
					args.Context.AddString($"  Force-transparent prefixes: {_forceTransparentPrefixSet.Count}");
					break;
				}
				case "initmod":
				{
					string dllArg = ((args.Length > 2) ? args[2] : string.Empty);
					bool flag = args.Length > 3 && args[3].Equals("force", StringComparison.OrdinalIgnoreCase);
					if (string.IsNullOrEmpty(dllArg))
					{
						args.Context.AddString("Usage: shaderhelper initmod <DllName> [force]");
					}
					else
					{
						string dllName = ModShaderDlls.Values.FirstOrDefault((string d) => d.Equals(dllArg, StringComparison.OrdinalIgnoreCase));
						bool flag2 = dllName == null;
						if (flag2)
						{
							dllName = dllArg;
							args.Context.AddString("ShaderHelperForMac: '" + dllArg + "' not in scan results (likely a large embedded bundle).");
							args.Context.AddString("Scanning all unsupported materials in memory — spawn/equip mod items first for best coverage.");
						}
						string text2 = Path.Combine(ConfigDir, dllName + ".txt");
						if (File.Exists(text2) && !flag)
						{
							args.Context.AddString("ShaderHelperForMac: '" + dllName + ".txt' already exists.");
							args.Context.AddString("Use 'shaderhelper initmod " + dllName + " force' to overwrite.");
						}
						else
						{
							HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
							List<(string, bool, string)> list = new List<(string, bool, string)>();
							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)_transparentMat) && !((Object)(object)val == (Object)(object)_fallbackMat))
								{
									if (!flag2)
									{
										if (!ModShaderDlls.TryGetValue(((Object)val.shader).name, out string value) || !value.Equals(dllName, StringComparison.OrdinalIgnoreCase))
										{
											continue;
										}
									}
									else if (!NeedsReplacement(val.shader))
									{
										continue;
									}
									string text3 = StripInstance(((Object)val).name);
									if (hashSet.Add(text3))
									{
										bool item = IsErrorPink(val) || val.renderQueue > 2450 || (val.HasProperty("_Mode") && val.GetFloat("_Mode") >= 2f) || IsHdrEmission(val);
										list.Add((text3, item, ((Object)val.shader).name));
									}
								}
							}
							array = Resources.FindObjectsOfTypeAll<Material>();
							foreach (Material val2 in array)
							{
								if (!((Object)(object)val2 == (Object)null) && _replacedMats.TryGetValue(((Object)val2).GetInstanceID(), out (string, ShaderAction) value2))
								{
									var (text4, _) = value2;
									if ((flag2 || (ModShaderDlls.TryGetValue(text4, out string value3) && value3.Equals(dllName, StringComparison.OrdinalIgnoreCase))) && !ValheimShaderNameSet.Contains(text4) && !ShaderScanner.IsLikelySafeShader(text4))
									{
										string text5 = StripInstance(((Object)val2).name);
										if (hashSet.Add(text5))
										{
											bool item2 = text4.IndexOf("Particle", StringComparison.OrdinalIgnoreCase) >= 0 || text4.IndexOf("Alpha", StringComparison.OrdinalIgnoreCase) >= 0 || text4.IndexOf("Additive", StringComparison.OrdinalIgnoreCase) >= 0 || text4.IndexOf("Glow", StringComparison.OrdinalIgnoreCase) >= 0 || text4.IndexOf("Effect", StringComparison.OrdinalIgnoreCase) >= 0 || text4.IndexOf("VFX", StringComparison.OrdinalIgnoreCase) >= 0;
											list.Add((text5, item2, text4));
										}
									}
								}
							}
							if (list.Count != 0)
							{
								SortedDictionary<string, int> sortedDictionary = new SortedDictionary<string, int>(StringComparer.OrdinalIgnoreCase);
								SortedDictionary<string, int> sortedDictionary2 = new SortedDictionary<string, int>(StringComparer.OrdinalIgnoreCase);
								array = Resources.FindObjectsOfTypeAll<Material>();
								foreach (Material val3 in array)
								{
									if (!((Object)(object)val3 == (Object)null) && _replacedMats.TryGetValue(((Object)val3).GetInstanceID(), out (string, ShaderAction) value4))
									{
										var (text6, shaderAction) = value4;
										if ((flag2 || (ModShaderDlls.TryGetValue(text6, out string value5) && value5.Equals(dllName, StringComparison.OrdinalIgnoreCase))) && !ShaderScanner.IsLikelySafeShader(text6) && !ValheimShaderNameSet.Contains(text6))
										{
											Shader val4 = Shader.Find(text6);
											bool num = (Object)(object)val4 != (Object)null && val4.isSupported;
											bool flag3 = IsForceFallback(text6) || IsForceTransparent(text6);
											if (num || flag3)
											{
												switch (shaderAction)
												{
												case ShaderAction.Fallback:
												{
													sortedDictionary.TryGetValue(text6, out var value7);
													sortedDictionary[text6] = value7 + 1;
													break;
												}
												case ShaderAction.Transparent:
												{
													sortedDictionary2.TryGetValue(text6, out var value6);
													sortedDictionary2[text6] = value6 + 1;
													break;
												}
												}
											}
										}
									}
								}
								SortedSet<string> sortedSet = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
								SortedSet<string> sortedSet2 = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
								array = Resources.FindObjectsOfTypeAll<Material>();
								foreach (Material val5 in array)
								{
									if (!((Object)(object)val5 == (Object)null) && !((Object)(object)val5.shader == (Object)null) && !((Object)(object)val5 == (Object)(object)_transparentMat) && !((Object)(object)val5 == (Object)(object)_fallbackMat) && val5.shader.isSupported && !CanonicalShaderIds.Contains(((Object)val5.shader).GetInstanceID()) && !ValheimShaderNameSet.Contains(((Object)val5.shader).name) && !ShaderScanner.IsLikelySafeShader(((Object)val5.shader).name))
									{
										Shader val6 = Shader.Find(((Object)val5.shader).name);
										if ((!((Object)(object)val6 != (Object)null) || !CanonicalShaderIds.Contains(((Object)val6).GetInstanceID())) && !sortedDictionary.ContainsKey(((Object)val5.shader).name) && !sortedDictionary2.ContainsKey(((Object)val5.shader).name))
										{
											if (!flag2)
											{
												if (!ModShaderDlls.TryGetValue(((Object)val5.shader).name, out string value8) || !value8.Equals(dllName, StringComparison.OrdinalIgnoreCase))
												{
													continue;
												}
											}
											else
											{
												string item3 = StripInstance(((Object)val5).name);
												if (_baselineMatNames.Contains(item3))
												{
													continue;
												}
											}
											if (IsSuspectTransparentShader(((Object)val5.shader).name))
											{
												sortedSet2.Add(((Object)val5.shader).name);
											}
											else
											{
												sortedSet.Add(((Object)val5.shader).name);
											}
										}
									}
								}
								Dictionary<string, (int, int, List<string>)> dictionary = new Dictionary<string, (int, int, List<string>)>(StringComparer.OrdinalIgnoreCase);
								List<(string, bool)> list2 = new List<(string, bool)>();
								foreach (var item16 in list)
								{
									string item4 = item16.Item1;
									bool item5 = item16.Item2;
									string text7 = ExtractMatSuffix(item4);
									if (text7 == null)
									{
										list2.Add((item4, item5));
									}
									else
									{
										if (!dictionary.TryGetValue(text7, out var value9))
										{
											value9 = (0, 0, new List<string>());
										}
										value9 = (item5 ? (value9.Item1, value9.Item2 + 1, value9.Item3) : (value9.Item1 + 1, value9.Item2, value9.Item3));
										if (value9.Item3.Count < 4)
										{
											value9.Item3.Add(item4);
										}
										dictionary[text7] = value9;
									}
								}
								List<string> values = (flag2 ? (from n in list.Select<(string, bool, string), string>(((string name, bool isTransparent, string shaderName) m) => m.shaderName).Distinct<string>(StringComparer.OrdinalIgnoreCase)
									where !ShaderScanner.IsLikelySafeShader(n) && !IsForceFallback(n) && !IsForceTransparent(n)
									orderby n
									select n).ToList() : (from kv in ModShaderDlls
									where kv.Value.Equals(dllName, StringComparison.OrdinalIgnoreCase)
									select kv.Key into n
									orderby n
									select n).ToList());
								List<KeyValuePair<string, (int, int, List<string>)>> list3 = (from kv in dictionary
									orderby kv.Value.fb + kv.Value.tr descending, kv.Key
									select kv).ToList();
								StringBuilder stringBuilder = new StringBuilder();
								stringBuilder.AppendLine("# ShaderHelperForMac — config for: " + dllName);
								stringBuilder.AppendLine("# Place this file in: BepInEx/config/ShaderHelperForMac/");
								stringBuilder.AppendLine("# The plugin loads it automatically — no other action needed.");
								if (flag2)
								{
									stringBuilder.AppendLine("# NOTE: large embedded bundle — shader-to-DLL attribution unavailable.");
									stringBuilder.AppendLine("#       Broken shader(s) found: " + string.Join(", ", values));
								}
								else
								{
									stringBuilder.AppendLine("# Shader(s) in this mod: " + string.Join(", ", values));
								}
								stringBuilder.AppendLine($"# ({list.Count} unique material(s) scanned — spawn/equip items for full coverage)");
								stringBuilder.AppendLine("#");
								stringBuilder.AppendLine("# IF OBJECTS STILL RENDER PINK after installing this file:");
								stringBuilder.AppendLine("#   Step 1 — look at [forcefallback] below. Uncomment any 'Suspected' entry and");
								stringBuilder.AppendLine("#             run  shaderhelper sweep  in the console (F5). Try one at a time.");
								stringBuilder.AppendLine("#   Step 2 — do the same for [forcetransparent] if particles/smoke are pink.");
								stringBuilder.AppendLine("#   Step 3 — if a specific material is still wrong, add  mat:MaterialName");
								stringBuilder.AppendLine("#             to [fallback] or [transparent] and sweep again.");
								stringBuilder.AppendLine("# Regenerate this file: shaderhelper initmod " + dllName + " force");
								stringBuilder.AppendLine();
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("# [forcefallback]  ← START HERE if solid objects (armour, weapons, body) are pink");
								stringBuilder.AppendLine("# These shaders look valid to Unity but render pink on Mac. The plugin cannot");
								stringBuilder.AppendLine("# detect them automatically — entries here override that and force a fix.");
								stringBuilder.AppendLine("#   Active entries  = confirmed pink, already being fixed.");
								stringBuilder.AppendLine("#   # Commented     = suspected pink — uncomment + sweep to test.");
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("[forcefallback]");
								List<KeyValuePair<string, int>> list4 = sortedDictionary.Where((KeyValuePair<string, int> kv) => !IsCoveredByBuiltIn(kv.Key)).ToList();
								if (list4.Count > 0)
								{
									stringBuilder.AppendLine("# Confirmed (active — solid objects already fixed by these rules):");
									foreach (KeyValuePair<string, int> item17 in list4)
									{
										stringBuilder.AppendLine($"{item17.Key,-50}# {item17.Value} material(s) replaced");
									}
								}
								if (sortedSet.Count > 0)
								{
									stringBuilder.AppendLine("# Suspected (uncomment + sweep if solid objects still pink):");
									foreach (string item18 in sortedSet)
									{
										stringBuilder.AppendLine("# " + item18);
									}
								}
								if (list4.Count == 0 && sortedSet.Count == 0)
								{
									stringBuilder.AppendLine("# (none detected — paste a shader prefix here if solid objects render pink)");
								}
								stringBuilder.AppendLine();
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("# [forcetransparent]  ← check here if particles, smoke, or spell effects are pink");
								stringBuilder.AppendLine("# Same as above but for transparent/particle shaders.");
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("[forcetransparent]");
								List<KeyValuePair<string, int>> list5 = sortedDictionary2.Where((KeyValuePair<string, int> kv) => !IsCoveredByBuiltIn(kv.Key)).ToList();
								if (list5.Count > 0)
								{
									stringBuilder.AppendLine("# Confirmed (active — particle/effect shaders already fixed by these rules):");
									foreach (KeyValuePair<string, int> item19 in list5)
									{
										stringBuilder.AppendLine($"{item19.Key,-50}# {item19.Value} material(s) replaced");
									}
								}
								if (sortedSet2.Count > 0)
								{
									if (flag2)
									{
										stringBuilder.AppendLine("# (large-bundle scan: entries below may include shaders from other mods)");
									}
									stringBuilder.AppendLine("# Suspected (uncomment + sweep if particles or effects still pink):");
									foreach (string item20 in sortedSet2)
									{
										stringBuilder.AppendLine("# " + item20);
									}
								}
								if (list5.Count == 0 && sortedSet2.Count == 0)
								{
									stringBuilder.AppendLine("# (none detected — paste a shader prefix here if particles/effects render pink)");
								}
								stringBuilder.AppendLine();
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("# [fallback]  — handled automatically, no changes needed in most cases");
								stringBuilder.AppendLine("# These shaders are completely unsupported on Mac. The plugin replaces them with");
								stringBuilder.AppendLine("# the nearest Valheim-compatible solid shader using the rules below.");
								stringBuilder.AppendLine("#   suffix:XYZ  applies to every material whose name ends with _XYZ");
								stringBuilder.AppendLine("#   mat:Name    applies to one specific material by exact name");
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("[fallback]");
								bool flag4 = false;
								foreach (KeyValuePair<string, (int, int, List<string>)> item21 in list3)
								{
									string key = item21.Key;
									(int, int, List<string>) value10 = item21.Value;
									List<string> item6 = value10.Item3;
									int item7 = value10.Item2;
									int item8 = value10.Item1;
									string text8 = key;
									if (item8 != 0)
									{
										int num2 = item8 + item7;
										string text9 = ((item6.Count > 0) ? ("  # e.g. " + string.Join(", ", item6)) : string.Empty);
										if (item8 >= item7 && num2 >= 3)
										{
											stringBuilder.AppendLine($"suffix:{text8,-14}# {num2} material(s){text9}");
										}
										else
										{
											stringBuilder.AppendLine($"# suffix:{text8,-12}# {num2} material(s) ({item8} fallback, {item7} transparent){text9}");
										}
										flag4 = true;
									}
								}
								foreach (var item22 in list2.Where<(string, bool)>(((string name, bool isTransparent) x) => !x.isTransparent))
								{
									string item9 = item22.Item1;
									stringBuilder.AppendLine("# mat:" + item9);
									flag4 = true;
								}
								if (!flag4)
								{
									stringBuilder.AppendLine("# (none detected — add mat: or suffix: rules here if needed)");
								}
								stringBuilder.AppendLine();
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("# [transparent]  — handled automatically, no changes needed in most cases");
								stringBuilder.AppendLine("# Same as [fallback] but uses a transparent shader (for smoke, particles, glass).");
								stringBuilder.AppendLine("# ────────────────────────────────────────────────────────────────────────────────");
								stringBuilder.AppendLine("[transparent]");
								bool flag5 = false;
								foreach (KeyValuePair<string, (int, int, List<string>)> item23 in list3)
								{
									string key2 = item23.Key;
									(int, int, List<string>) value11 = item23.Value;
									List<string> item10 = value11.Item3;
									int item11 = value11.Item2;
									int item12 = value11.Item1;
									string text10 = key2;
									if (item11 != 0)
									{
										int num3 = item12 + item11;
										string text11 = ((item10.Count > 0) ? ("  # e.g. " + string.Join(", ", item10)) : string.Empty);
										if (item11 >= item12 && item12 == 0 && num3 >= 3)
										{
											stringBuilder.AppendLine($"suffix:{text10,-14}# {num3} material(s){text11}");
										}
										else
										{
											stringBuilder.AppendLine($"# suffix:{text10,-12}# {num3} material(s) ({item12} fallback, {item11} transparent){text11}");
										}
										flag5 = true;
									}
								}
								foreach (var item24 in list2.Where<(string, bool)>(((string name, bool isTransparent) x) => x.isTransparent))
								{
									string item13 = item24.Item1;
									stringBuilder.AppendLine("# mat:" + item13);
									flag5 = true;
								}
								if (!flag5)
								{
									stringBuilder.AppendLine("# (none detected — add mat: or suffix: rules here if needed)");
								}
								stringBuilder.AppendLine();
								stringBuilder.AppendLine("[original]");
								stringBuilder.AppendLine();
								stringBuilder.AppendLine("[default]");
								stringBuilder.AppendLine("fallback");
								try
								{
									File.WriteAllText(text2, stringBuilder.ToString());
									ReloadConfigFiles();
									args.Context.AddString($"ShaderHelperForMac: created '{dllName}.txt' — {list.Count} material(s) analyzed, {list3.Count} suffix group(s).");
									args.Context.AddString("File: " + text2);
									args.Context.AddString("Config reloaded. Run 'shaderhelper sweep' to apply new rules.");
									Log.LogInfo((object)$"[InitMod] Wrote '{dllName}.txt': {list.Count} materials, {list3.Count} suffix groups.");
									break;
								}
								catch (Exception ex)
								{
									args.Context.AddString("ShaderHelperForMac: failed to write file: " + ex.Message);
									break;
								}
							}
							args.Context.AddString("ShaderHelperForMac: no materials found in memory.");
							args.Context.AddString("Spawn or equip the mod's items first, then re-run.");
						}
					}
					break;
				}
				default:
					args.Context.AddString("Usage:  shaderhelper sweep                    — run a material sweep immediately");
					args.Context.AddString("        shaderhelper nearby [radius] [DllName|mod] — log materials near the player; filter by mod DLL name or use 'mod' to skip vanilla");
					args.Context.AddString("        shaderhelper transparent <DllName>     — log materials ShaderHelper made (or will make) 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 initmod <DllName> [force] — generate a starter config file for a mod");
					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 (finds dynamic dungeon objects)");
					args.Context.AddString("        shaderhelper all                       — log ALL loaded materials regardless of action (diagnostics)");
					args.Context.AddString("        shaderhelper status                    — show current plugin state");
					break;
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			Log.LogDebug((object)"Console command 'shaderhelper' registered.");
			static bool IsSuspectTransparentShader(string sn)
			{
				if (sn.IndexOf("Particle", StringComparison.OrdinalIgnoreCase) < 0 && sn.IndexOf("VFX", StringComparison.OrdinalIgnoreCase) < 0 && sn.IndexOf("Effect", StringComparison.OrdinalIgnoreCase) < 0 && sn.IndexOf("Glow", StringComparison.OrdinalIgnoreCase) < 0 && sn.IndexOf("Emission", StringComparison.OrdinalIgnoreCase) < 0 && sn.IndexOf("Additive", StringComparison.OrdinalIgnoreCase) < 0)
				{
					return sn.IndexOf("Alpha", StringComparison.OrdinalIgnoreCase) >= 0;
				}
				return true;
			}
		}

		private static void CollectCanonicalShaderIds()
		{
			string[] valheimShaderNames = ValheimShaderNames;
			for (int i = 0; i < valheimShaderNames.Length; i++)
			{
				Shader val = Shader.Find(valheimShaderNames[i]);
				if ((Object)(object)val != (Object)null)
				{
					CanonicalShaderIds.Add(((Object)val).GetInstanceID());
				}
			}
			Log.LogDebug((object)$"Registered {CanonicalShaderIds.Count} canonical Valheim shader ID(s).");
		}

		private static void BuildTransparentMaterial()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_006d: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_transparentMat != (Object)null)
			{
				return;
			}
			Shader val = Shader.Find("Sprites/Default") ?? Shader.Find("UI/Default") ?? Shader.Find("Unlit/Transparent");
			if ((Object)(object)val != (Object)null)
			{
				_transparentMat = new Material(val)
				{
					name = "ShaderFix_Transparent"
				};
				_transparentMat.color = new Color(0f, 0f, 0f, 0f);
				Log.LogDebug((object)("Transparent material ready (shader='" + ((Object)val).name + "')."));
				return;
			}
			Shader val2 = Shader.Find("Standard");
			if ((Object)(object)val2 != (Object)null)
			{
				_transparentMat = new Material(val2)
				{
					name = "ShaderFix_Transparent"
				};
				_transparentMat.SetFloat("_Mode", 3f);
				_transparentMat.SetInt("_SrcBlend", 5);
				_transparentMat.SetInt("_DstBlend", 10);
				_transparentMat.SetInt("_ZWrite", 0);
				_transparentMat.EnableKeyword("_ALPHABLEND_ON");
				_transparentMat.renderQueue = 3000;
				_transparentMat.color = new Color(0f, 0f, 0f, 0f);
				Log.LogDebug((object)"Transparent material ready (Standard Transparent).");
			}
			else
			{
				Log.LogWarning((object)"No transparent shader found — shader replacement will not work.");
			}
		}

		private static void BuildReplacementMaterials()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			BuildTransparentMaterial();
			if ((Object)(object)FallbackShader != (Object)null)
			{
				_fallbackMat = new Material(FallbackShader)
				{
					name = "ShaderFix_Fallback"
				};
				_fallbackMat.color = Color.white;
				Log.LogDebug((object)("Fallback material ready (shader='" + ((Object)FallbackShader).name + "')."));
			}
		}

		internal static void TryUpgradeFallbackShader()
		{
			if ((Object)(object)FallbackShader == (Object)null)
			{
				return;
			}
			Shader[] source = Resources.FindObjectsOfTypeAll<Shader>();
			string[] fallbackChain = 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;
				}
				if (((Object)val).GetInstanceID() != ((Object)FallbackShader).GetInstanceID())
				{
					Log.LogInfo((object)$"[ZNetScene.Awake] Upgraded fallback shader: '{((Object)FallbackShader).name}' (id={((Object)FallbackShader).GetInstanceID()}) → '{((Object)val).name}' (id={((Object)val).GetInstanceID()})");
					FallbackShader = val;
					if ((Object)(object)_fallbackMat != (Object)null)
					{
						_fallbackMat.shader = val;
					}
				}
				break;
			}
		}

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

		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 (DefaultAllTransparent)
			{
				return true;
			}
			if (value != null && (_useFallbackDlls.Contains(value) || _useTransparentDlls.Contains(value)))
			{
				return true;
			}
			return false;
		}

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

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

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

		private static bool IsCoveredByBuiltIn(string shaderName)
		{
			foreach (string builtInFallbackPrefix in _builtInFallbackPrefixes)
			{
				if (shaderName.StartsWith(builtInFallbackPrefix, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			foreach (string builtInTransparentPrefix in _builtInTransparentPrefixes)
			{
				if (shaderName.StartsWith(builtInTransparentPrefix, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

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

		private 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)
			if (mat.HasProperty("_Color"))
			{
				Color color = mat.color;
				if (color.r > 0.9f && color.g < 0.1f)
				{
					return color.b > 0.7f;
				}
				return false;
			}
			return false;
		}

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

		private 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)
			if (mat.HasProperty("_EmissionColor"))
			{
				Color color = mat.GetColor("_EmissionColor");
				if (!(color.r > 1f) && !(color.g > 1f))
				{
					return color.b > 1f;
				}
				return true;
			}
			return false;
		}

		private static bool NeedsReplacement(Material mat)
		{
			if (!NeedsReplacement(mat.shader))
			{
				return IsErrorPink(mat);
			}
			return true;
		}

		private static ShaderAction GetAction(Material mat)
		{
			if (CanonicalShaderIds.Contains(((Object)mat.shader).GetInstanceID()))
			{
				return ShaderAction.Original;
			}
			string name = ((Object)mat).name;
			name = StripInstance(name);
			if (_originalMatNames.Contains(name))
			{
				return ShaderAction.Original;
			}
			if (_transparentMatNames.Contains(name))
			{
				return ShaderAction.Transparent;
			}
			if (_fallbackMatNames.Contains(name))
			{
				return ShaderAction.Fallback;
			}
			if (IsErrorPink(mat))
			{
				return ShaderAction.Transparent;
			}
			foreach (string transparentMatSuffix in _transparentMatSuffixes)
			{
				if (name.EndsWith(transparentMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					return ShaderAction.Transparent;
				}
			}
			foreach (string fallbackMatSuffix in _fallbackMatSuffixes)
			{
				if (!name.EndsWith(fallbackMatSuffix, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				if (((Object)mat.shader).name != "Standard Double Sided")
				{
					if (mat.renderQueue > 2450)
					{
						return ShaderAction.Transparent;
					}
					if (mat.HasProperty("_Mode") && mat.GetFloat("_Mode") >= 2f)
					{
						return ShaderAction.Transparent;
					}
					if (IsHdrEmission(mat))
					{
						return ShaderAction.Transparent;
					}
				}
				return ShaderAction.Fallback;
			}
			return GetAction(((Object)mat.shader).name);
		}

		private static ShaderAction GetAction(string shaderName)
		{
			if (shaderName.StartsWith("Hidden/InternalErrorShader", StringComparison.OrdinalIgnoreCase))
			{
				return ShaderAction.Fallback;
			}
			if (shaderName.StartsWith("TextMeshPro/", StringComparison.OrdinalIgnoreCase) && shaderName.EndsWith(" (Surface)", StringComparison.OrdinalIgnoreCase))
			{
				return ShaderAction.Fallback;
			}
			if (IsForceTransparent(shaderName))
			{
				return ShaderAction.Transparent;
			}
			if (IsForceFallback(shaderName))
			{
				return ShaderAction.Fallback;
			}
			if (ValheimShaderNameSet.Contains(shaderName))
			{
				return ShaderAction.Fallback;
			}
			ModShaderDlls.TryGetValue(shaderName, out string value);
			if (value != null && _useOriginalDlls.Contains(value))
			{
				return ShaderAction.Original;
			}
			if (DefaultAllTransparent)
			{
				return ShaderAction.Transparent;
			}
			if (value != null && _useTransparentDlls.Contains(value))
			{
				return ShaderAction.Transparent;
			}
			if (value != null && _useFallbackDlls.Contains(value))
			{
				return ShaderAction.Fallback;
			}
			return ShaderAction.Original;
		}

		internal void SweepMaterials()
		{
			if (!_sweepRunning)
			{
				((MonoBehaviour)this).StartCoroutine(SweepMaterialsCoroutine());
			}
		}

		internal void SweepMaterialsWithNotify()
		{
			if (!_sweepRunning)
			{
				((MonoBehaviour)this).StartCoroutine(SweepAndNotifyCoroutine());
			}
		}

		[IteratorStateMachine(typeof(<SweepAndNotifyCoroutine>d__91))]
		private IEnumerator SweepAndNotifyCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SweepAndNotifyCoroutine>d__91(0)
			{
				<>4__this = this
			};
		}

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

		[IteratorStateMachine(typeof(<SweepMaterialsCoroutine>d__94))]
		internal IEnumerator SweepMaterialsCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SweepMaterialsCoroutine>d__94(0)
			{
				<>4__this = this
			};
		}

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

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

		private static int TryReplaceMaterial(Material? mat)
		{
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null || (Object)(object)mat.shader == (Object)null)
			{
				return 0;
			}
			if ((Object)(object)mat == (Object)(object)_transparentMat || (Object)(object)mat == (Object)(object)_fallbackMat)
			{
				return 0;
			}
			string item = StripInstance(((Object)mat).name);
			bool flag = IsExplicitMatRule(mat);
			bool flag2 = IsForceTransparent(((Object)mat.shader).name) || IsForceFallback(((Object)mat.shader).name);
			if (_forceReplacedMaterialIds.Contains(((Object)mat).GetInstanceID()) && !flag)
			{
				return 0;
			}
			if (CanonicalShaderIds.Contains(((Object)mat.shader).GetInstanceID()))
			{
				return 0;
			}
			if (_baselineMatNames.Contains(item) && !flag && !flag2)
			{
				return 0;
			}
			if (!NeedsReplacement(mat) && !flag)
			{
				return 0;
			}
			ShaderAction action = GetAction(mat);
			if (action == ShaderAction.Original)
			{
				return 0;
			}
			if (((Object)mat.shader).name.StartsWith("TextMeshPro/", StringComparison.OrdinalIgnoreCase) && ((Object)mat.shader).name.EndsWith(" (Surface)", StringComparison.OrdinalIgnoreCase))
			{
				string text = ((Object)mat.shader).name.Substring(0, ((Object)mat.shader).name.Length - " (Surface)".Length);
				Shader val = Shader.Find(text);
				if ((Object)(object)val != (Object)null && ((Object)val).GetInstanceID() != ((Object)mat.shader).GetInstanceID())
				{
					Log.LogDebug((object)("[TMP] '" + ((Object)mat.shader).name + "' → '" + text + "' on mat '" + ((Object)mat).name + "'"));
					_replacedMats[((Object)mat).GetInstanceID()] = (((Object)mat.shader).name, action);
					mat.shader = val;
					return 1;
				}
			}
			Material val2 = ((action == ShaderAction.Fallback) ? _fallbackMat : _transparentMat);
			if ((Object)(object)val2 == (Object)null)
			{
				return 0;
			}
			if (((Object)mat.shader).GetInstanceID() == ((Object)val2.shader).GetInstanceID())
			{
				return 0;
			}
			object obj;
			if (!mat.HasProperty("_Color"))
			{
				obj = "n/a";
			}
			else
			{
				Color color = mat.color;
				obj = ((object)(Color)(ref color)).ToString();
			}
			string text2 = (string)obj;
			Log.LogDebug((object)$"[{action}] '{((Object)mat.shader).name}' → '{((Object)val2.shader).name}' on mat '{((Object)mat).name}'  color={text2}.");
			_replacedMats[((Object)mat).GetInstanceID()] = (((Object)mat.shader).name, action);
			mat.shader = val2.shader;
			if (val2.HasProperty("_Color"))
			{
				mat.color = val2.color;
			}
			if (action == ShaderAction.Fallback)
			{
				if (mat.HasProperty("_EmissionColor"))
				{
					mat.SetColor("_EmissionColor", Color.black);
				}
				mat.DisableKeyword("_EMISSION");
			}
			if (action == ShaderAction.Transparent)
			{
				_forceReplacedMaterialIds.Add(((Object)mat).GetInstanceID());
			}
			return 1;
		}
	}
	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.LogInfo((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_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_001d: 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.LogInfo((object)("[Diag] " + fileNameWithoutExtension + ": resource '" + ((Resource)item).Name + "' read failed: " + ex.Message));
							continue;
						}
						if (IsUnityBundle(resourceData))
						{
							log.LogInfo((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.LogInfo((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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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.LogInfo((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.LogInfo((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.LogInfo((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.LogInfo((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.LogInfo((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.LogInfo((object)$"[Diag] pathId={info.PathId} baseOffset={absoluteByteOffset} byteSize={info.ByteSize} bytes=[{BitConverter.ToString(array)}]");
				}
				catch (Exception ex)
				{
					diagLog.LogInfo((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