using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalEnums;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Stitchwork;
using Stitchwork.GUI;
using Stitchwork.GUI.Pillars;
using Stitchwork.Handlers;
using Stitchwork.Packs;
using Stitchwork.Util;
using Stitchwork.Watchers;
using TMProOld;
using TeamCherry.Cinematics;
using TeamCherry.Localization;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.Scripting;
using UnityEngine.TextCore;
using UnityEngine.TextCore.LowLevel;
using UnityEngine.UI;
using UnityEngine.Video;
using UnityStandardAssets.ImageEffects;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Stitchwork")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.8.6.0")]
[assembly: AssemblyInformationalVersion("0.8.6+c28c073e0f977ca49375077628d1be4bda3c86ac")]
[assembly: AssemblyProduct("Stitchwork")]
[assembly: AssemblyTitle("Stitchwork")]
[assembly: AssemblyMetadata("GameLibsPin", "1.2.0-silksong1.0.30000")]
[assembly: AssemblyMetadata("DevTools", "false")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.8.6.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[HarmonyPatch]
public static class AnimationController
{
	private sealed class AnimEntry
	{
		public string Name;

		public int Seq;

		public tk2dSpriteAnimator Live;

		public bool Stale;

		public float LastSeenRealtime;

		public tk2dSpriteAnimationClip Clip;

		public tk2dSpriteCollectionData FrameColl;

		public int Frame;

		public int SpriteId;

		public string ClipName;

		public string CollName;

		public string SpriteName;

		public int FrameCount;

		public tk2dSpriteAnimation Library;

		public tk2dSpriteAnimationClip ViewClip;

		public int ViewFrame;

		public readonly List<string> RecentClips = new List<string>();
	}

	private sealed class ClipCoverage
	{
		public int Frames;

		public int Shared;

		public int SharedFromPack;

		public int PerClip;

		public readonly List<string> MissingShared = new List<string>();
	}

	private static bool Paused = false;

	private static bool FrameChangeRequested = false;

	private static bool Frozen = false;

	private static Vector3 FrozenPosition;

	private const string HeroName = "Hero_Hornet(Clone)";

	private const int MaxRecentClips = 5;

	private static readonly Dictionary<string, AnimEntry> _entries = new Dictionary<string, AnimEntry>();

	private static int _seqCounter = 0;

	private const int MaxEntries = 64;

	private static readonly Color ColStale = new Color(0.5f, 0.5f, 0.5f);

	private static bool _browseClips;

	private static Vector2 _objectScroll;

	private static Vector2 _clipScroll;

	private static string _clipSearch = "";

	private static tk2dSpriteCollectionData _lensColl;

	private static int _lensSpriteId = -1;

	private static string _lensSpriteName;

	private static Action _pendingUiAction;

	private static bool _previewPlaying;

	private static tk2dSpriteAnimationClip _previewClip;

	private static int _previewFrame;

	private static float _previewClock;

	private static float _previewFps = 12f;

	private const float PreviewFallbackFps = 12f;

	private static float _wsCountAt = -999f;

	private static int _wsListSize = -1;

	private static List<tk2dSpriteAnimationClip> _wsClips;

	private const float SuffixColW = 132f;

	private static GUIStyle _suffixStyle;

	private static readonly Dictionary<(int libId, string clip, string coll), ClipCoverage> _coverage = new Dictionary<(int, string, string), ClipCoverage>();

	private static int _coverageIndexVersion = -1;

	private static readonly FieldInfo _windyLibField = AccessTools.Field(typeof(HeroAnimationController), "windyAnimLib");

	private static readonly Type _heroConfigType = AccessTools.TypeByName("HeroControllerConfig");

	private static readonly FieldInfo _heroConfigOverrideLib = ((_heroConfigType != null) ? AccessTools.Field(_heroConfigType, "heroAnimOverrideLib") : null);

	private static readonly List<tk2dSpriteAnimation> _configOverrideLibs = new List<tk2dSpriteAnimation>();

	private static float _configLibsNextScan;

	private static readonly Dictionary<int, string> _libDominantColl = new Dictionary<int, string>();

	private static int _dominantCollVersion = -1;

	private const string KeybindHex = "#B78CFF";

	private static GUIStyle _transportStyle;

	private static GUIStyle _hintStyle;

	private static Texture2D _spritePreviewTex;

	private static int _spvCollId = 0;

	private static int _spvSpriteId = -1;

	private static int _spvFileVer = -1;

	private static readonly Dictionary<(int coll, int sprite), Texture2D> _thumbCache = new Dictionary<(int, int), Texture2D>();

	private static int _thumbFileVer = -1;

	private const int ThumbCacheCap = 96;

	private const int ThumbRenderSize = 96;

	private static Texture2D _previewWhite;

	private static string _reuseCacheKey = null;

	private static int _reuseFrameCount = 0;

	private static int _reuseClipCount = 0;

	private static readonly List<(tk2dSpriteAnimationClip Clip, List<int> Frames)> _reuseSources = new List<(tk2dSpriteAnimationClip, List<int>)>();

	private static string _anchorCacheKey = null;

	private static bool _anchorReplExists = false;

	private static string _anchorCurrent = null;

	private static string _anchorFilePath = null;

	private static string _anchorPackSource = null;

	public static string SelectedAnimator { get; private set; } = null;

	private static GUIStyle SuffixStyle
	{
		get
		{
			//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_001a: 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_0027: Expected O, but got Unknown
			object obj = _suffixStyle;
			if (obj == null)
			{
				GUIStyle val = new GUIStyle(GUIHelper.LabelStyle)
				{
					wordWrap = false,
					clipping = (TextClipping)1
				};
				_suffixStyle = val;
				obj = (object)val;
			}
			return (GUIStyle)obj;
		}
	}

	private static GUIStyle TransportStyle
	{
		get
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			int num = GUIHelper.FontSize(12);
			if (_transportStyle == null || _transportStyle.fontSize != num)
			{
				_transportStyle = new GUIStyle(GUI.skin.button)
				{
					fontSize = num,
					richText = true,
					alignment = (TextAnchor)4
				};
			}
			return _transportStyle;
		}
	}

	private static GUIStyle HintStyle
	{
		get
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			int num = GUIHelper.FontSize(12);
			if (_hintStyle == null || _hintStyle.fontSize != num)
			{
				_hintStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = num,
					wordWrap = true
				};
			}
			return _hintStyle;
		}
	}

	internal static void SelectFromWorldPick(string name)
	{
		SelectedAnimator = name;
		_browseClips = true;
	}

	public static void RegisterAnimator(tk2dSpriteAnimator animator)
	{
		if (!((Object)(object)animator == (Object)null) && !((Object)(object)((Component)animator).gameObject == (Object)null))
		{
			string name = ((Object)((Component)animator).gameObject).name;
			if (!_entries.TryGetValue(name, out var value))
			{
				value = new AnimEntry
				{
					Name = name,
					Seq = _seqCounter++
				};
				_entries[name] = value;
			}
			value.Live = animator;
			value.Stale = false;
		}
	}

	public static void ClearAnimators()
	{
		_entries.Clear();
		SelectedAnimator = null;
		Paused = false;
		Frozen = false;
		_seqCounter = 0;
		_browseClips = false;
		_clipSearch = "";
		ClearLens();
		StopPreview();
		_coverage.Clear();
		ClearThumbCache();
	}

	public static void ApplyPatches(Harmony harmony)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Expected O, but got Unknown
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Expected O, but got Unknown
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Expected O, but got Unknown
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Expected O, but got Unknown
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Expected O, but got Unknown
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Expected O, but got Unknown
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: Expected O, but got Unknown
		//IL_0246: Unknown result type (might be due to invalid IL or missing references)
		//IL_0254: Expected O, but got Unknown
		//IL_029b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a9: Expected O, but got Unknown
		//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_030b: Expected O, but got Unknown
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "Play", (Type[])null, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "Play", new Type[1] { typeof(string) }, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayWithNamePatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "Play", new Type[1] { typeof(tk2dSpriteAnimationClip) }, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayWithClipPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "PlayFromFrame", new Type[1] { typeof(int) }, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayFromFramePatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "PlayFromFrame", new Type[2]
		{
			typeof(string),
			typeof(int)
		}, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayFromFrameWithNamePatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "PlayFromFrame", new Type[2]
		{
			typeof(tk2dSpriteAnimationClip),
			typeof(int)
		}, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayFromFrameWithClipPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "PlayFrom", new Type[1] { typeof(float) }, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayFromPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "PlayFrom", new Type[2]
		{
			typeof(string),
			typeof(float)
		}, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayFromWithNamePatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "PlayFrom", new Type[2]
		{
			typeof(tk2dSpriteAnimationClip),
			typeof(float)
		}, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayFromWithClipPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteAnimator), "Play", new Type[3]
		{
			typeof(tk2dSpriteAnimationClip),
			typeof(float),
			typeof(float)
		}, (Type[])null), new HarmonyMethod(typeof(AnimationController), "PlayOverrideFpsPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
	}

	private static bool PlayPatchInternal(tk2dSpriteAnimator __instance)
	{
		long heapBefore = DevProfiler.SnapshotHeapBytes();
		try
		{
			if ((Object)(object)__instance != (Object)null)
			{
				RegisterAnimator(__instance);
				if (SelectedAnimator == ((Object)((Component)__instance).gameObject).name && Paused && !FrameChangeRequested)
				{
					return false;
				}
			}
			return true;
		}
		finally
		{
			DevProfiler.AddOpPositiveNetHeapDelta("Prefix.tk2dAnim.Play", heapBefore);
		}
	}

	public static bool PlayPatch(tk2dSpriteAnimator __instance)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayWithNamePatch(tk2dSpriteAnimator __instance, string name)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayWithClipPatch(tk2dSpriteAnimator __instance, tk2dSpriteAnimationClip clip)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayFromFramePatch(tk2dSpriteAnimator __instance, int frame)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayFromFrameWithNamePatch(tk2dSpriteAnimator __instance, string name, int frame)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayFromFrameWithClipPatch(tk2dSpriteAnimator __instance, tk2dSpriteAnimationClip clip, int frame)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayFromPatch(tk2dSpriteAnimator __instance, float clipStartTime)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayFromWithNamePatch(tk2dSpriteAnimator __instance, string name, float clipStartTime)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayFromWithClipPatch(tk2dSpriteAnimator __instance, tk2dSpriteAnimationClip clip, float clipStartTime)
	{
		return PlayPatchInternal(__instance);
	}

	public static bool PlayOverrideFpsPatch(tk2dSpriteAnimator __instance, tk2dSpriteAnimationClip clip, float clipStartTime, float overrideFps)
	{
		return PlayPatchInternal(__instance);
	}

	private static bool TryGetLiveSelected(out tk2dSpriteAnimator animator)
	{
		animator = null;
		if (SelectedAnimator != null && _entries.TryGetValue(SelectedAnimator, out var value) && (Object)(object)value.Live != (Object)null && (Object)(object)((Component)value.Live).gameObject != (Object)null)
		{
			animator = value.Live;
		}
		return (Object)(object)animator != (Object)null;
	}

	public static void Update()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		if (!GUIHelper.IsTextFieldFocused)
		{
			if (Input.GetKeyDown(Plugin.Config.AnimationControllerPauseKey))
			{
				TogglePause();
			}
			if (Input.GetKeyDown(Plugin.Config.AnimationControllerFreezeKey))
			{
				ToggleFreeze();
			}
			if (Input.GetKeyDown(Plugin.Config.AnimationControllerNextFrameKey))
			{
				StepFrame(1);
			}
			if (Input.GetKeyDown(Plugin.Config.AnimationControllerPrevFrameKey))
			{
				StepFrame(-1);
			}
		}
		if (Frozen && TryGetLiveSelected(out var animator))
		{
			((Component)animator).gameObject.transform.position = FrozenPosition;
		}
		if (_previewPlaying)
		{
			tk2dSpriteAnimationClip previewClip = _previewClip;
			if (previewClip == null || previewClip.frames == null || previewClip.frames.Length == 0)
			{
				StopPreview();
			}
			else
			{
				int num = previewClip.frames.Length;
				float num2 = 1f / _previewFps;
				_previewClock += Time.unscaledDeltaTime;
				while (_previewClock >= num2)
				{
					_previewClock -= num2;
					_previewFrame = (_previewFrame + 1) % num;
				}
			}
		}
		foreach (AnimEntry value in _entries.Values)
		{
			tk2dSpriteAnimator live = value.Live;
			if ((Object)(object)live == (Object)null || (Object)(object)((Component)live).gameObject == (Object)null)
			{
				value.Live = null;
				MarkStale(value);
				continue;
			}
			if (!((Component)live).gameObject.activeSelf || live.CurrentClip == null || live.CurrentFrame < 0 || live.CurrentFrame >= live.CurrentClip.frames.Length)
			{
				MarkStale(value);
				continue;
			}
			RefreshSnapshot(value, live);
			value.Stale = false;
			value.ViewClip = null;
			value.LastSeenRealtime = Time.realtimeSinceStartup;
		}
		if (_entries.Count > 64)
		{
			EvictOldestStale();
		}
	}

	private static void RefreshSnapshot(AnimEntry e, tk2dSpriteAnimator a)
	{
		tk2dSpriteAnimationClip currentClip = a.CurrentClip;
		int currentFrame = a.CurrentFrame;
		tk2dSpriteAnimationFrame val = currentClip.frames[currentFrame];
		if (e.ClipName != currentClip.name)
		{
			e.RecentClips.Remove(currentClip.name);
			e.RecentClips.Insert(0, currentClip.name);
			if (e.RecentClips.Count > 5)
			{
				e.RecentClips.RemoveAt(5);
			}
		}
		e.Clip = currentClip;
		e.Frame = currentFrame;
		e.FrameColl = val.spriteCollection;
		e.SpriteId = val.spriteId;
		e.ClipName = currentClip.name;
		e.FrameCount = currentClip.frames.Length;
		e.Library = a.Library;
		if ((Object)(object)e.FrameColl != (Object)null && val.spriteId >= 0 && val.spriteId < e.FrameColl.spriteDefinitions.Length)
		{
			e.CollName = ((Object)e.FrameColl).name;
			e.SpriteName = e.FrameColl.spriteDefinitions[val.spriteId].name;
		}
	}

	private static void MarkStale(AnimEntry e)
	{
		e.Stale = true;
		if (e.ViewClip == null && e.Clip != null)
		{
			e.ViewClip = e.Clip;
			e.ViewFrame = e.Frame;
		}
	}

	private static void EvictOldestStale()
	{
		List<AnimEntry> list = (from e in _entries.Values
			where e.Stale && e.Name != SelectedAnimator && e.Name != "Hero_Hornet(Clone)"
			orderby e.LastSeenRealtime
			select e).ToList();
		int num = _entries.Count - 64;
		int num2 = 0;
		while (num2 < list.Count && num > 0)
		{
			_entries.Remove(list[num2].Name);
			num2++;
			num--;
		}
	}

	private static void SelectAnimator(AnimEntry e)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		Frozen = false;
		if (Paused && TryGetLiveSelected(out var animator))
		{
			animator.Resume();
		}
		Paused = false;
		SelectedAnimator = e.Name;
		_browseClips = true;
		_clipSearch = "";
		_clipScroll = Vector2.zero;
		ClearLens();
		StopPreview();
	}

	private static void TogglePause()
	{
		StopPreview();
		if (TryGetLiveSelected(out var animator))
		{
			Paused = !Paused;
			if (Paused)
			{
				animator.Pause();
			}
			else
			{
				animator.Resume();
			}
		}
	}

	private static void ToggleFreeze()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		if (TryGetLiveSelected(out var animator))
		{
			Frozen = !Frozen;
			FrozenPosition = ((Component)animator).gameObject.transform.position;
		}
	}

	private static void StepFrame(int delta)
	{
		StopPreview();
		tk2dSpriteAnimator animator;
		if (SelectedAnimator != null && _entries.TryGetValue(SelectedAnimator, out var value) && (value.Stale || (Object)(object)value.Live == (Object)null))
		{
			if (value.ViewClip != null && value.ViewClip.frames != null && value.ViewClip.frames.Length != 0)
			{
				int num = value.ViewClip.frames.Length;
				value.ViewFrame = ((value.ViewFrame + delta) % num + num) % num;
			}
		}
		else if (TryGetLiveSelected(out animator) && Paused && animator.CurrentClip != null)
		{
			int num2 = animator.CurrentClip.frames.Length;
			if (num2 > 0)
			{
				int num3 = ((animator.CurrentFrame + delta) % num2 + num2) % num2;
				FrameChangeRequested = true;
				animator.PlayFromFrame(num3);
				animator.UpdateAnimation(Time.deltaTime);
				FrameChangeRequested = false;
			}
		}
	}

	private static float ResolvePreviewFps(AnimEntry e, tk2dSpriteAnimationClip clip)
	{
		return 12f;
	}

	private static void StopPreview()
	{
		_previewPlaying = false;
		_previewClip = null;
	}

	private static void ClearLens()
	{
		_lensColl = null;
		_lensSpriteId = -1;
		_lensSpriteName = null;
	}

	private static void SetLens(tk2dSpriteCollectionData coll, int spriteId, string spriteName)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		_lensColl = coll;
		_lensSpriteId = spriteId;
		_lensSpriteName = spriteName;
		_browseClips = true;
		_clipScroll = Vector2.zero;
		_clipSearch = "";
	}

	private static AnimEntry SelectedEntry()
	{
		if (SelectedAnimator == null || !_entries.TryGetValue(SelectedAnimator, out var value))
		{
			return null;
		}
		return value;
	}

	public static void DrawPillarContent()
	{
		AnimEntry animEntry = SelectedEntry();
		GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
		GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
		if (_browseClips && animEntry != null && animEntry.ClipName != null)
		{
			DrawClipStage(animEntry);
		}
		else
		{
			DrawObjectStage();
		}
		GUILayout.EndVertical();
		float num = GUIHelper.Scaled(190f);
		GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num) });
		DrawPreviewColumn(animEntry, num);
		GUILayout.EndVertical();
		GUILayout.EndHorizontal();
		GUIHelper.Space(4f);
		DrawConsole(animEntry);
		if (_pendingUiAction != null)
		{
			Action pendingUiAction = _pendingUiAction;
			_pendingUiAction = null;
			pendingUiAction();
		}
	}

	private static void DrawObjectStage()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: 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_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		Color backgroundColor = GUI.backgroundColor;
		GUI.backgroundColor = GUIHelper.ColConfirm;
		if (GUILayout.Button(Loc.T("Pick object in world"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(40f) }))
		{
			_pendingUiAction = delegate
			{
				WorldPickMode.Enter(WorldPickMode.Preset.Tk2d);
			};
		}
		GUI.backgroundColor = backgroundColor;
		if (_entries.Count == 0)
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("No animators registered."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			return;
		}
		_objectScroll = GUILayout.BeginScrollView(_objectScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
		foreach (AnimEntry item in from x in _entries.Values
			orderby (!(x.Name == "Hero_Hornet(Clone)")) ? 1 : 0, x.Seq
			select x)
		{
			if (item.ClipName != null)
			{
				DrawObjectRow(item);
			}
		}
		GUILayout.EndScrollView();
	}

	private static void DrawObjectRow(AnimEntry e)
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		bool flag = SelectedAnimator == e.Name;
		bool flag2 = e.Stale || (Object)(object)e.Live == (Object)null;
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		float num = GUIHelper.Scaled(40f);
		DrawSpriteThumb(GUILayoutUtility.GetRect(num, num, (GUILayoutOption[])(object)new GUILayoutOption[2]
		{
			GUILayout.Width(num),
			GUILayout.Height(num)
		}), e.FrameColl, e.SpriteId, flag2);
		GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
		GUI.contentColor = (flag ? GUIHelper.ColConfirm : (flag2 ? ColStale : Color.white));
		if (GUILayout.Button(e.Name, GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			_pendingUiAction = delegate
			{
				SelectAnimator(e);
			};
		}
		GUI.contentColor = Color.white;
		GUI.contentColor = (flag2 ? ColStale : GUIHelper.ColMuted);
		GUILayout.Label($"{e.ClipName}  ·  {e.Frame + 1}/{e.FrameCount}" + (flag2 ? ("   " + Loc.T("(stopped)")) : ""), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = Color.white;
		GUILayout.EndVertical();
		GUILayout.EndHorizontal();
		GUIHelper.Space(2f);
	}

	private static void DrawSpriteThumb(Rect r, tk2dSpriteCollectionData coll, int spriteId, bool dim)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0226: Unknown result type (might be due to invalid IL or missing references)
		//IL_0201: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_021b: Unknown result type (might be due to invalid IL or missing references)
		EnsurePreviewWhite();
		GUI.color = GUIHelper.ColSurface2;
		GUI.DrawTexture(r, (Texture)(object)_previewWhite);
		GUI.color = Color.white;
		if ((Object)(object)coll == (Object)null || coll.spriteDefinitions == null || spriteId < 0 || spriteId >= coll.spriteDefinitions.Length)
		{
			return;
		}
		tk2dSpriteDefinition val = coll.spriteDefinitions[spriteId];
		Material val2 = (((Object)(object)val.materialInst != (Object)null) ? val.materialInst : val.material);
		Texture val3 = (((Object)(object)val2 != (Object)null) ? val2.mainTexture : null);
		Vector2[] uvs = val.uvs;
		if ((Object)(object)val3 == (Object)null || uvs == null || uvs.Length < 4)
		{
			return;
		}
		Rect container = default(Rect);
		((Rect)(ref container))..ctor(((Rect)(ref r)).x + 2f, ((Rect)(ref r)).y + 2f, ((Rect)(ref r)).width - 4f, ((Rect)(ref r)).height - 4f);
		GUI.color = (Color)(dim ? new Color(1f, 1f, 1f, 0.45f) : Color.white);
		Texture2D uprightThumb = GetUprightThumb(coll, spriteId, val, val3);
		if ((Object)(object)uprightThumb != (Object)null)
		{
			GUI.DrawTexture(ScaleToFitRect(container, ((Texture)uprightThumb).width, ((Texture)uprightThumb).height), (Texture)(object)uprightThumb);
		}
		else
		{
			float num = uvs.Min((Vector2 v) => v.x);
			float num2 = uvs.Max((Vector2 v) => v.x);
			float num3 = uvs.Min((Vector2 v) => v.y);
			float num4 = uvs.Max((Vector2 v) => v.y);
			int texW = Mathf.Max(1, Mathf.RoundToInt((num2 - num) * (float)val3.width));
			int texH = Mathf.Max(1, Mathf.RoundToInt((num4 - num3) * (float)val3.height));
			GUI.DrawTextureWithTexCoords(ScaleToFitRect(container, texW, texH), val3, new Rect(num, num3, num2 - num, num4 - num3), true);
		}
		GUI.color = Color.white;
	}

	private static void DrawClipStage(AnimEntry e)
	{
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Unknown result type (might be due to invalid IL or missing references)
		//IL_0368: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0440: Unknown result type (might be due to invalid IL or missing references)
		//IL_0470: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0515: Unknown result type (might be due to invalid IL or missing references)
		//IL_0539: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
		bool flag = e.Stale || (Object)(object)e.Live == (Object)null;
		bool live = !flag && (Object)(object)e.Live != (Object)null && (Object)(object)((Component)e.Live).gameObject != (Object)null;
		if (GUILayout.Button("◂  " + e.Name + "   ·   " + Loc.T("click to change object"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			_pendingUiAction = delegate
			{
				_browseClips = false;
			};
		}
		if (flag)
		{
			GUI.contentColor = ColStale;
			GUILayout.Label(Loc.T("(stopped — inspecting the snapshot)"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		tk2dSpriteAnimation library = e.Library;
		if ((Object)(object)library == (Object)null || library.clips == null || library.clips.Length == 0)
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("No clip library on this object."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			return;
		}
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.Label(Loc.T("Search:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(60f) });
		_clipSearch = GUIHelper.TextField(_clipSearch, GUILayout.ExpandWidth(true), GUIHelper.Height(32f));
		GUILayout.EndHorizontal();
		if (_lensSpriteName != null)
		{
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = GUIHelper.ColWarn;
			if (GUILayout.Button(Loc.T("Reusing this sprite") + ": " + _lensSpriteName + "   ✕", GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				_pendingUiAction = ClearLens;
			}
			GUI.backgroundColor = backgroundColor;
		}
		List<tk2dSpriteAnimationClip> list = library.clips.Where((tk2dSpriteAnimationClip c) => c != null && !string.IsNullOrEmpty(c.name)).ToList();
		IEnumerable<tk2dSpriteAnimationClip> enumerable = SecondaryLibClips(e, library);
		if (enumerable != null)
		{
			list.AddRange(enumerable);
		}
		HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
		HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
		foreach (tk2dSpriteAnimationClip item in list)
		{
			if (!hashSet2.Add(item.name))
			{
				hashSet.Add(item.name);
			}
		}
		IEnumerable<tk2dSpriteAnimationClip> source = list;
		if (!string.IsNullOrEmpty(_clipSearch))
		{
			string q = _clipSearch;
			source = source.Where((tk2dSpriteAnimationClip c) => c.name.IndexOf(q, StringComparison.OrdinalIgnoreCase) >= 0);
		}
		if (_lensSpriteId >= 0)
		{
			source = source.Where((tk2dSpriteAnimationClip c) => ClipUsesSprite(c, _lensColl, _lensSpriteId));
		}
		List<tk2dSpriteAnimationClip> list2 = source.OrderBy<tk2dSpriteAnimationClip, string>((tk2dSpriteAnimationClip c) => c.name, StringComparer.OrdinalIgnoreCase).ToList();
		HashSet<tk2dSpriteAnimationClip> mainSet = new HashSet<tk2dSpriteAnimationClip>(library.clips ?? Array.Empty<tk2dSpriteAnimationClip>());
		int num = list2.Count((tk2dSpriteAnimationClip c) => !mainSet.Contains(c));
		int num2 = list2.Count - num;
		GUI.contentColor = GUIHelper.ColFaint;
		GUILayout.Label((num > 0) ? string.Format(Loc.T("{0} + {1} variants"), num2, num) : $"{num2} / {library.clips.Length}", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = Color.white;
		bool reserveSuffixCol = false;
		string dominantCollection = GetDominantCollection(library);
		foreach (tk2dSpriteAnimationClip item2 in list2)
		{
			string text = PrimaryCollectionName(item2);
			if (text != null && (hashSet.Contains(item2.name) || !string.Equals(text, dominantCollection, StringComparison.Ordinal)))
			{
				reserveSuffixCol = true;
				break;
			}
		}
		string dominantCollection2 = GetDominantCollection(library);
		if (dominantCollection2 != null)
		{
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("Collection") + ": " + dominantCollection2, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		DrawBatchRow(list2);
		tk2dSpriteAnimationClip val = ((!flag) ? e.Clip : ((e.ViewClip != null) ? e.ViewClip : e.Clip));
		string currentClip = ((!flag) ? e.ClipName : ((e.ViewClip != null) ? e.ViewClip.name : e.ClipName));
		_clipScroll = GUILayout.BeginScrollView(_clipScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
		if (string.IsNullOrEmpty(_clipSearch) && _lensSpriteId < 0 && e.RecentClips.Count > 0)
		{
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("Recently played"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			foreach (string recentClip in e.RecentClips)
			{
				tk2dSpriteAnimationClip val2 = ((val != null && val.name == recentClip) ? val : FindClip(library, recentClip));
				if (val2 != null)
				{
					DrawClipRow(e, library, val2, val, currentClip, live, hashSet, reserveSuffixCol);
				}
			}
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("All clips"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		foreach (tk2dSpriteAnimationClip item3 in list2)
		{
			DrawClipRow(e, library, item3, val, currentClip, live, hashSet, reserveSuffixCol);
		}
		GUILayout.EndScrollView();
	}

	private static void DrawBatchRow(List<tk2dSpriteAnimationClip> list)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_012b: Unknown result type (might be due to invalid IL or missing references)
		if (AnimCanvasBatch.IsRunning)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(string.Format(Loc.T("Batch: {0}/{1}"), AnimCanvasBatch.Processed, AnimCanvasBatch.Total) + " · " + AnimCanvasBatch.CurrentClip, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.contentColor = Color.white;
			if (GUILayout.Button(Loc.T("Cancel"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(80f) }))
			{
				AnimCanvasBatch.Cancel();
			}
			GUILayout.EndHorizontal();
			return;
		}
		if (Time.unscaledTime - _wsCountAt > 2f || _wsClips == null || list.Count != _wsListSize)
		{
			_wsClips = AnimCanvasBatch.WithWorkspace(list);
			_wsListSize = list.Count;
			_wsCountAt = Time.unscaledTime;
		}
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUI.contentColor = GUIHelper.ColMuted;
		GUILayout.Label(Loc.T("Canvas:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(58f) });
		GUI.contentColor = Color.white;
		if (GUILayout.Button(string.Format(Loc.T("Extract {0} listed"), list.Count), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			AnimCanvasBatch.ExtractAll(list, fromCurrentRender: false);
		}
		if (GUILayout.Button(Loc.T("Extract As Rendered"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			AnimCanvasBatch.ExtractAll(list, fromCurrentRender: true);
		}
		GUI.enabled = _wsClips.Count > 0;
		if (GUILayout.Button(string.Format(Loc.T("Compile {0} workspaces"), _wsClips.Count), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			AnimCanvasBatch.CompileAll(_wsClips);
		}
		GUI.enabled = true;
		GUILayout.EndHorizontal();
	}

	private static void DrawClipRow(AnimEntry e, tk2dSpriteAnimation lib, tk2dSpriteAnimationClip clip, tk2dSpriteAnimationClip currentObj, string currentClip, bool live, HashSet<string> dupNames, bool reserveSuffixCol)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0231: Unknown result type (might be due to invalid IL or missing references)
		//IL_0289: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: Unknown result type (might be due to invalid IL or missing references)
		//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
		ClipCoverage coverage = GetCoverage(lib, clip);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		Color color = ((coverage.Shared == 0) ? GUIHelper.ColBorderHi : ((coverage.SharedFromPack > 0) ? GUIHelper.ColPackBlue : GUIHelper.ColConfirm));
		string text = string.Format("{0}: {1}/{2}", Loc.T("shared replacements"), coverage.Shared, coverage.Frames);
		if (coverage.SharedFromPack > 0)
		{
			text = text + " · " + string.Format(Loc.T("{0} from pack"), coverage.SharedFromPack);
		}
		if (coverage.Shared > 0 && coverage.Shared < coverage.Frames && coverage.MissingShared.Count > 0)
		{
			text = text + "\n" + Loc.T("not found") + ": " + string.Join(", ", coverage.MissingShared) + ((coverage.Frames - coverage.Shared > coverage.MissingShared.Count) ? ", …" : "");
		}
		GUIHelper.StatusDotSlot(DotStateFor(coverage.Shared, coverage.Frames), color, text);
		GUIHelper.StatusDotSlot(DotStateFor(coverage.PerClip, coverage.Frames), (coverage.PerClip > 0) ? GUIHelper.ColAccent : GUIHelper.ColBorderHi, string.Format("{0}: {1}/{2}", Loc.T("per-clip (Appliqué)"), coverage.PerClip, coverage.Frames));
		bool flag = ((currentObj != null) ? (clip == currentObj) : (clip.name == currentClip));
		GUI.contentColor = (flag ? GUIHelper.ColConfirm : Color.white);
		if (GUILayout.Button(clip.name, GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			PlayClip(e, clip, live);
		}
		GUI.contentColor = Color.white;
		GUI.contentColor = GUIHelper.ColFaint;
		GUILayout.Label($"×{((clip.frames != null) ? clip.frames.Length : 0)}", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(40f) });
		GUI.contentColor = Color.white;
		if (reserveSuffixCol)
		{
			string text2 = PrimaryCollectionName(clip);
			bool flag2 = dupNames?.Contains(clip.name) ?? false;
			bool num = text2 != null && (flag2 || !string.Equals(text2, GetDominantCollection(lib), StringComparison.Ordinal));
			GUI.contentColor = (flag ? GUIHelper.ColConfirm : GUIHelper.ColFaint);
			GUILayout.Label((GUIContent)((!num) ? ((object)GUIContent.none) : ((object)new GUIContent("· " + text2, text2))), SuffixStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(132f) });
			GUI.contentColor = Color.white;
		}
		GUILayout.EndHorizontal();
	}

	private static void PlayClip(AnimEntry e, tk2dSpriteAnimationClip clip, bool live)
	{
		StopPreview();
		if (live && (Object)(object)e.Live != (Object)null)
		{
			tk2dSpriteAnimator live2 = e.Live;
			Paused = true;
			live2.Pause();
			FrameChangeRequested = true;
			live2.Play(clip);
			live2.UpdateAnimation(Time.deltaTime);
			FrameChangeRequested = false;
		}
		else
		{
			e.ViewClip = clip;
			e.ViewFrame = 0;
		}
	}

	private static tk2dSpriteAnimationClip FindClip(tk2dSpriteAnimation lib, string name)
	{
		tk2dSpriteAnimationClip[] clips = lib.clips;
		foreach (tk2dSpriteAnimationClip val in clips)
		{
			if (val != null && val.name == name)
			{
				return val;
			}
		}
		return null;
	}

	private static bool ClipUsesSprite(tk2dSpriteAnimationClip clip, tk2dSpriteCollectionData coll, int spriteId)
	{
		if (clip == null || clip.frames == null || (Object)(object)coll == (Object)null)
		{
			return false;
		}
		tk2dSpriteAnimationFrame[] frames = clip.frames;
		foreach (tk2dSpriteAnimationFrame val in frames)
		{
			if ((Object)(object)val.spriteCollection == (Object)(object)coll && val.spriteId == spriteId)
			{
				return true;
			}
		}
		return false;
	}

	private static void RefreshConfigOverrideLibs()
	{
		if (_heroConfigOverrideLib == null || Time.realtimeSinceStartup < _configLibsNextScan)
		{
			return;
		}
		_configLibsNextScan = Time.realtimeSinceStartup + 5f;
		_configOverrideLibs.Clear();
		Object[] array = Resources.FindObjectsOfTypeAll(_heroConfigType);
		foreach (Object val in array)
		{
			if (!(val == (Object)null))
			{
				object? value = _heroConfigOverrideLib.GetValue(val);
				tk2dSpriteAnimation val2 = (tk2dSpriteAnimation)((value is tk2dSpriteAnimation) ? value : null);
				if (val2 != null && (Object)(object)val2 != (Object)null && val2.clips != null && !_configOverrideLibs.Contains(val2))
				{
					_configOverrideLibs.Add(val2);
				}
			}
		}
	}

	private static IEnumerable<tk2dSpriteAnimationClip> SecondaryLibClips(AnimEntry e, tk2dSpriteAnimation mainLib)
	{
		if (e == null)
		{
			return null;
		}
		tk2dSpriteAnimator live = e.Live;
		if ((Object)(object)live == (Object)null)
		{
			return null;
		}
		HeroAnimationController component = ((Component)live).GetComponent<HeroAnimationController>();
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		List<tk2dSpriteAnimation> list = new List<tk2dSpriteAnimation>();
		if (_windyLibField != null)
		{
			object? value = _windyLibField.GetValue(component);
			tk2dSpriteAnimation val = (tk2dSpriteAnimation)((value is tk2dSpriteAnimation) ? value : null);
			if (val != null && (Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)mainLib && val.clips != null)
			{
				list.Add(val);
			}
		}
		RefreshConfigOverrideLibs();
		foreach (tk2dSpriteAnimation configOverrideLib in _configOverrideLibs)
		{
			if ((Object)(object)configOverrideLib != (Object)null && (Object)(object)configOverrideLib != (Object)(object)mainLib && !list.Contains(configOverrideLib))
			{
				list.Add(configOverrideLib);
			}
		}
		if (list.Count == 0)
		{
			return null;
		}
		HashSet<tk2dSpriteAnimationClip> mainSet = new HashSet<tk2dSpriteAnimationClip>(mainLib.clips ?? Array.Empty<tk2dSpriteAnimationClip>());
		HashSet<tk2dSpriteAnimationClip> seen = new HashSet<tk2dSpriteAnimationClip>();
		return from c in list.SelectMany((tk2dSpriteAnimation l) => l.clips)
			where c != null && !string.IsNullOrEmpty(c.name) && !mainSet.Contains(c) && seen.Add(c)
			select c;
	}

	private static string GetDominantCollection(tk2dSpriteAnimation lib)
	{
		if (_dominantCollVersion != SpriteLoader.FileIndexVersion)
		{
			_libDominantColl.Clear();
			_dominantCollVersion = SpriteLoader.FileIndexVersion;
		}
		int instanceID = ((Object)lib).GetInstanceID();
		if (_libDominantColl.TryGetValue(instanceID, out var value))
		{
			return value;
		}
		Dictionary<string, int> dictionary = new Dictionary<string, int>();
		if (lib.clips != null)
		{
			tk2dSpriteAnimationClip[] clips = lib.clips;
			foreach (tk2dSpriteAnimationClip val in clips)
			{
				if (val == null || val.frames == null)
				{
					continue;
				}
				tk2dSpriteAnimationFrame[] frames = val.frames;
				for (int j = 0; j < frames.Length; j++)
				{
					tk2dSpriteCollectionData spriteCollection = frames[j].spriteCollection;
					if (!((Object)(object)spriteCollection == (Object)null))
					{
						dictionary[((Object)spriteCollection).name] = ((!dictionary.TryGetValue(((Object)spriteCollection).name, out var value2)) ? 1 : (value2 + 1));
					}
				}
			}
		}
		string text = null;
		int num = 0;
		foreach (KeyValuePair<string, int> item in dictionary)
		{
			if (item.Value > num)
			{
				num = item.Value;
				text = item.Key;
			}
		}
		_libDominantColl[instanceID] = text;
		return text;
	}

	private static string PrimaryCollectionName(tk2dSpriteAnimationClip clip)
	{
		if (clip.frames == null)
		{
			return null;
		}
		tk2dSpriteAnimationFrame[] frames = clip.frames;
		for (int i = 0; i < frames.Length; i++)
		{
			tk2dSpriteCollectionData spriteCollection = frames[i].spriteCollection;
			if ((Object)(object)spriteCollection != (Object)null)
			{
				return ((Object)spriteCollection).name;
			}
		}
		return null;
	}

	private static GUIHelper.DotState DotStateFor(int n, int total)
	{
		if (n > 0)
		{
			if (n < total)
			{
				return GUIHelper.DotState.Partial;
			}
			return GUIHelper.DotState.Full;
		}
		return GUIHelper.DotState.None;
	}

	private static ClipCoverage GetCoverage(tk2dSpriteAnimation lib, tk2dSpriteAnimationClip clip)
	{
		if (_coverageIndexVersion != SpriteLoader.FileIndexVersion)
		{
			_coverage.Clear();
			_coverageIndexVersion = SpriteLoader.FileIndexVersion;
		}
		(int, string, string) key = (((Object)lib).GetInstanceID(), clip.name, PrimaryCollectionName(clip));
		if (_coverage.TryGetValue(key, out var value))
		{
			return value;
		}
		value = new ClipCoverage();
		if (clip.frames != null)
		{
			tk2dSpriteAnimationFrame[] frames = clip.frames;
			foreach (tk2dSpriteAnimationFrame val in frames)
			{
				tk2dSpriteCollectionData spriteCollection = val.spriteCollection;
				if ((Object)(object)spriteCollection == (Object)null || spriteCollection.spriteDefinitions == null || val.spriteId < 0 || val.spriteId >= spriteCollection.spriteDefinitions.Length)
				{
					continue;
				}
				tk2dSpriteDefinition val2 = spriteCollection.spriteDefinitions[val.spriteId];
				if (!string.IsNullOrEmpty(val2.name))
				{
					value.Frames++;
					SpriteLoader.ReplacementSource spriteProvenance = SpriteLoader.GetSpriteProvenance(spriteCollection, val2);
					if (spriteProvenance != SpriteLoader.ReplacementSource.None)
					{
						value.Shared++;
					}
					else if (value.MissingShared.Count < 4)
					{
						string text = (((Object)(object)val2.material != (Object)null) ? ((Object)val2.material).name.Split(' ')[0] : "?");
						value.MissingShared.Add(val2.name + " (" + ((Object)spriteCollection).name + "/" + text + ")");
					}
					if (spriteProvenance == SpriteLoader.ReplacementSource.Pack)
					{
						value.SharedFromPack++;
					}
					if (AppliqueLoader.HasClipOverride(((Object)spriteCollection).name, clip.name, val2.name))
					{
						value.PerClip++;
					}
				}
			}
		}
		_coverage[key] = value;
		return value;
	}

	private static bool TryResolveDisplay(AnimEntry e, out tk2dSpriteAnimationClip clip, out tk2dSpriteCollectionData coll, out int spriteId, out int frame, out int frameCount)
	{
		clip = null;
		coll = null;
		spriteId = -1;
		frame = 0;
		frameCount = 0;
		if (e == null || e.ClipName == null)
		{
			return false;
		}
		if (_previewPlaying && _previewClip != null && _previewClip.frames != null && _previewClip.frames.Length != 0)
		{
			int num = _previewClip.frames.Length;
			int num2 = (_previewFrame % num + num) % num;
			tk2dSpriteAnimationFrame val = _previewClip.frames[num2];
			clip = _previewClip;
			coll = val.spriteCollection;
			spriteId = val.spriteId;
			frame = num2;
			frameCount = num;
			return true;
		}
		if ((e.Stale || (Object)(object)e.Live == (Object)null) && e.ViewClip != null && e.ViewClip.frames != null && e.ViewClip.frames.Length != 0)
		{
			int num3 = Mathf.Clamp(e.ViewFrame, 0, e.ViewClip.frames.Length - 1);
			tk2dSpriteAnimationFrame val2 = e.ViewClip.frames[num3];
			clip = e.ViewClip;
			coll = val2.spriteCollection;
			spriteId = val2.spriteId;
			frame = num3;
			frameCount = e.ViewClip.frames.Length;
		}
		else
		{
			clip = e.Clip;
			coll = e.FrameColl;
			spriteId = e.SpriteId;
			frame = e.Frame;
			frameCount = e.FrameCount;
		}
		return true;
	}

	private static void DrawPreviewColumn(AnimEntry e, float colW)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_021a: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0228: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		//IL_0329: Unknown result type (might be due to invalid IL or missing references)
		//IL_032e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0330: Unknown result type (might be due to invalid IL or missing references)
		//IL_033c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0342: Invalid comparison between Unknown and I4
		//IL_023a: Unknown result type (might be due to invalid IL or missing references)
		//IL_024a: Unknown result type (might be due to invalid IL or missing references)
		//IL_024f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0579: Unknown result type (might be due to invalid IL or missing references)
		//IL_059d: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_05db: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_03da: Unknown result type (might be due to invalid IL or missing references)
		//IL_0363: Unknown result type (might be due to invalid IL or missing references)
		//IL_0373: Unknown result type (might be due to invalid IL or missing references)
		//IL_0378: Unknown result type (might be due to invalid IL or missing references)
		//IL_037a: Unknown result type (might be due to invalid IL or missing references)
		//IL_067a: Unknown result type (might be due to invalid IL or missing references)
		//IL_06af: Unknown result type (might be due to invalid IL or missing references)
		//IL_06e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_06e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0516: Unknown result type (might be due to invalid IL or missing references)
		//IL_0539: Unknown result type (might be due to invalid IL or missing references)
		//IL_0560: Unknown result type (might be due to invalid IL or missing references)
		//IL_056f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0724: Unknown result type (might be due to invalid IL or missing references)
		//IL_074f: Unknown result type (might be due to invalid IL or missing references)
		//IL_076e: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_07c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_07f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0818: Unknown result type (might be due to invalid IL or missing references)
		//IL_086c: Unknown result type (might be due to invalid IL or missing references)
		if (e == null || !TryResolveDisplay(e, out var clip, out var coll, out var spriteId, out var frame, out var _))
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("Select an object to preview."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			return;
		}
		if ((Object)(object)coll == (Object)null || coll.spriteDefinitions == null || spriteId < 0 || spriteId >= coll.spriteDefinitions.Length)
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("Preview unavailable — the animator's atlas was unloaded."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			return;
		}
		tk2dSpriteDefinition val = coll.spriteDefinitions[spriteId];
		Material val2 = (((Object)(object)val.materialInst != (Object)null) ? val.materialInst : val.material);
		if ((Object)(object)val2 == (Object)null || (Object)(object)val2.mainTexture == (Object)null)
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("Preview unavailable — material/texture released."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			return;
		}
		Texture mainTexture = val2.mainTexture;
		Vector2[] uvs = val.uvs;
		bool flag = uvs != null && uvs.Length >= 4;
		float num = 0f;
		float num2 = 1f;
		float num3 = 0f;
		float num4 = 1f;
		if (flag)
		{
			num = uvs.Min((Vector2 v) => v.x);
			num2 = uvs.Max((Vector2 v) => v.x);
			num3 = uvs.Min((Vector2 v) => v.y);
			num4 = uvs.Max((Vector2 v) => v.y);
		}
		float num5 = colW - GUIHelper.Scaled(8f);
		Rect rect = GUILayoutUtility.GetRect(num5, num5, (GUILayoutOption[])(object)new GUILayoutOption[2]
		{
			GUILayout.Width(num5),
			GUILayout.Height(num5)
		});
		GUIHelper.DrawPreviewBackdrop(rect);
		GUI.DrawTexture(rect, mainTexture, (ScaleMode)2, true);
		if (flag)
		{
			Rect val3 = ScaleToFitRect(rect, mainTexture.width, mainTexture.height);
			float num6 = ((Rect)(ref val3)).x + num * ((Rect)(ref val3)).width;
			float num7 = ((Rect)(ref val3)).y + (1f - num4) * ((Rect)(ref val3)).height;
			float num8 = (num2 - num) * ((Rect)(ref val3)).width;
			float num9 = (num4 - num3) * ((Rect)(ref val3)).height;
			EnsurePreviewWhite();
			GUI.color = new Color(1f, 1f, 0f, 0.4f);
			GUI.DrawTexture(new Rect(num6, num7, num8, num9), (Texture)(object)_previewWhite);
			GUI.color = Color.white;
		}
		GUI.contentColor = ColStale;
		GUILayout.Label(Loc.T("Atlas"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = Color.white;
		Rect rect2 = GUILayoutUtility.GetRect(num5, num5, (GUILayoutOption[])(object)new GUILayoutOption[2]
		{
			GUILayout.Width(num5),
			GUILayout.Height(num5)
		});
		GUIHelper.DrawPreviewBackdrop(rect2);
		if ((int)Event.current.type == 7 && flag)
		{
			Texture2D uprightSpriteTex = GetUprightSpriteTex(coll, spriteId, val, mainTexture);
			Rect val4;
			if ((Object)(object)uprightSpriteTex != (Object)null)
			{
				val4 = ScaleToFitRect(rect2, ((Texture)uprightSpriteTex).width, ((Texture)uprightSpriteTex).height);
				GUI.DrawTexture(val4, (Texture)(object)uprightSpriteTex);
			}
			else
			{
				int texW = Mathf.Max(1, Mathf.RoundToInt((num2 - num) * (float)mainTexture.width));
				int texH = Mathf.Max(1, Mathf.RoundToInt((num4 - num3) * (float)mainTexture.height));
				val4 = ScaleToFitRect(rect2, texW, texH);
				GUI.DrawTextureWithTexCoords(val4, mainTexture, new Rect(num, num3, num2 - num, num4 - num3), true);
			}
			Vector3[] positions = val.positions;
			if (positions != null && positions.Length >= 4)
			{
				float num10 = positions.Min((Vector3 p) => p.x);
				float num11 = positions.Max((Vector3 p) => p.x);
				float num12 = positions.Min((Vector3 p) => p.y);
				float num13 = positions.Max((Vector3 p) => p.y);
				float num14 = num11 - num10;
				float num15 = num13 - num12;
				if (num14 > 1E-06f && num15 > 1E-06f)
				{
					float num16 = (0f - num10) / num14;
					float num17 = (0f - num12) / num15;
					float num18 = ((Rect)(ref val4)).x + num16 * ((Rect)(ref val4)).width;
					float num19 = ((Rect)(ref val4)).y + (1f - num17) * ((Rect)(ref val4)).height;
					EnsurePreviewWhite();
					GUI.color = new Color(1f, 0.15f, 0.8f, 0.95f);
					GUI.DrawTexture(new Rect(num18 - 6f, num19 - 0.5f, 13f, 1f), (Texture)(object)_previewWhite);
					GUI.DrawTexture(new Rect(num18 - 0.5f, num19 - 6f, 1f, 13f), (Texture)(object)_previewWhite);
					GUI.color = Color.white;
				}
			}
		}
		GUI.contentColor = ColStale;
		GUILayout.Label(Loc.T("Sprite ⊹ = pivot"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = Color.white;
		GUIHelper.DrawBackdropSliderRow();
		GUIHelper.Space(4f);
		GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
		GUI.contentColor = (_previewPlaying ? GUIHelper.ColConfirm : Color.white);
		if (GUILayout.Button(_previewPlaying ? ("▮▮ " + Loc.T("Preview")) : ("▶ " + Loc.T("Preview")), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			if (_previewPlaying)
			{
				StopPreview();
			}
			else if (clip != null && clip.frames != null && clip.frames.Length != 0)
			{
				_previewClip = clip;
				_previewFrame = frame;
				_previewClock = 0f;
				_previewFps = ResolvePreviewFps(e, clip);
				_previewPlaying = true;
			}
		}
		GUI.contentColor = Color.white;
		float num20 = GUIHelper.Scaled(38f);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		if (GUILayout.Button(TransportLabel("|◀", Loc.T("Prev"), Plugin.Config.AnimationControllerPrevFrameKey), TransportStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(num20) }))
		{
			StepFrame(-1);
		}
		GUI.contentColor = (Paused ? GUIHelper.ColWarn : Color.white);
		if (GUILayout.Button(TransportLabel(Paused ? "▶" : "▮▮", Loc.T(Paused ? "Play" : "Pause"), Plugin.Config.AnimationControllerPauseKey), TransportStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(num20) }))
		{
			TogglePause();
		}
		GUI.contentColor = Color.white;
		if (GUILayout.Button(TransportLabel("▶|", Loc.T("Next"), Plugin.Config.AnimationControllerNextFrameKey), TransportStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(num20) }))
		{
			StepFrame(1);
		}
		GUI.contentColor = (Frozen ? Color.cyan : Color.white);
		if (GUILayout.Button(TransportLabel("❄", Loc.T("Freeze"), Plugin.Config.AnimationControllerFreezeKey), TransportStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(num20) }))
		{
			ToggleFreeze();
		}
		GUI.contentColor = Color.white;
		GUILayout.EndHorizontal();
		bool num21 = e.Stale || (Object)(object)e.Live == (Object)null;
		GUI.contentColor = GUIHelper.ColFaint;
		GUILayout.Label(num21 ? Loc.T("Stopped — stepping browses the snapshot.") : ((!Paused) ? Loc.T("Pause to step frames.") : " "), HintStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GUIHelper.Scaled(30f)) });
		GUI.contentColor = Color.white;
		GUILayout.EndVertical();
	}

	private static string TransportLabel(string symbol, string word, KeyCode key)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		return symbol + " " + word + "\n<color=#B78CFF>[" + KeyName(key) + "]</color>";
	}

	internal static void OpenSpriteForEdit(tk2dSpriteCollectionData coll, tk2dSpriteDefinition def)
	{
		if ((Object)(object)coll == (Object)null || def == null || string.IsNullOrEmpty(def.name))
		{
			return;
		}
		Material val = (((Object)(object)def.materialInst != (Object)null) ? def.materialInst : def.material);
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		string text = ((Object)val).name.Split(' ')[0];
		string text2 = SpriteLoader.FindWorkspaceSpriteFile(coll, def) ?? Path.Combine(SpriteLoader.LoadPath, ((Object)coll).name, text, def.name + ".png");
		if (!File.Exists(text2))
		{
			SpriteDumper.DumpSingleSprite(def, coll);
			string text3 = Path.Combine(SpriteDumper.DumpPath, ((Object)coll).name, text, def.name + ".png");
			if (!File.Exists(text3))
			{
				Plugin.Logger.LogError((object)("Failed to dump sprite for editing: " + ((Object)coll).name + "/" + text + "/" + def.name));
				return;
			}
			IOUtil.EnsureDirectoryExists(Path.Combine(SpriteLoader.LoadPath, ((Object)coll).name, text));
			File.Copy(text3, text2, overwrite: true);
		}
		IOUtil.OpenPath(text2);
		_anchorCacheKey = null;
	}

	internal static Texture2D GetUprightSpriteTexShared(tk2dSpriteCollectionData coll, int spriteId)
	{
		if ((Object)(object)coll == (Object)null || coll.spriteDefinitions == null || spriteId < 0 || spriteId >= coll.spriteDefinitions.Length)
		{
			return null;
		}
		tk2dSpriteDefinition val = coll.spriteDefinitions[spriteId];
		Material val2 = (((Object)(object)val.materialInst != (Object)null) ? val.materialInst : val.material);
		Texture val3 = (((Object)(object)val2 != (Object)null) ? val2.mainTexture : null);
		if ((Object)(object)val3 == (Object)null)
		{
			return null;
		}
		return GetUprightSpriteTex(coll, spriteId, val, val3);
	}

	private static Texture2D GetUprightSpriteTex(tk2dSpriteCollectionData coll, int spriteId, tk2dSpriteDefinition def, Texture atlas)
	{
		int instanceID = ((Object)coll).GetInstanceID();
		int fileIndexVersion = SpriteLoader.FileIndexVersion;
		if ((Object)(object)_spritePreviewTex != (Object)null && _spvCollId == instanceID && _spvSpriteId == spriteId && _spvFileVer == fileIndexVersion)
		{
			return _spritePreviewTex;
		}
		Texture2D val = RenderUprightNew(def, atlas, 2048);
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		if ((Object)(object)_spritePreviewTex != (Object)null)
		{
			Object.Destroy((Object)(object)_spritePreviewTex);
		}
		_spritePreviewTex = val;
		_spvCollId = instanceID;
		_spvSpriteId = spriteId;
		_spvFileVer = fileIndexVersion;
		return _spritePreviewTex;
	}

	private static Texture2D RenderUprightNew(tk2dSpriteDefinition def, Texture atlas, int maxSize)
	{
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Invalid comparison between Unknown and I4
		//IL_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0244: Unknown result type (might be due to invalid IL or missing references)
		//IL_0275: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0303: Unknown result type (might be due to invalid IL or missing references)
		//IL_030d: Expected O, but got Unknown
		//IL_031f: Unknown result type (might be due to invalid IL or missing references)
		if (!TexUtil.RotateDrawAvailable)
		{
			return null;
		}
		if ((Object)(object)TexUtil.RotateMaterial == (Object)null || (Object)(object)atlas == (Object)null)
		{
			return null;
		}
		Vector2[] uvs = def.uvs;
		Vector3[] positions = def.positions;
		if (uvs == null || uvs.Length < 4 || positions == null || positions.Length < 4)
		{
			return null;
		}
		float num = uvs[0].x;
		float num2 = num;
		float num3 = uvs[0].y;
		float num4 = num3;
		for (int i = 1; i < 4; i++)
		{
			num = Mathf.Min(num, uvs[i].x);
			num2 = Mathf.Max(num2, uvs[i].x);
			num3 = Mathf.Min(num3, uvs[i].y);
			num4 = Mathf.Max(num4, uvs[i].y);
		}
		int num5 = Mathf.RoundToInt((num2 - num) * (float)atlas.width);
		int num6 = Mathf.RoundToInt((num4 - num3) * (float)atlas.height);
		bool num7 = (int)def.flipped > 0;
		int num8 = Mathf.Clamp(num7 ? num6 : num5, 1, 2048);
		int num9 = Mathf.Clamp(num7 ? num5 : num6, 1, 2048);
		if (Mathf.Max(num8, num9) > maxSize)
		{
			float num10 = (float)maxSize / (float)Mathf.Max(num8, num9);
			num8 = Mathf.Max(1, Mathf.RoundToInt((float)num8 * num10));
			num9 = Mathf.Max(1, Mathf.RoundToInt((float)num9 * num10));
		}
		float num11 = positions[0].x;
		float num12 = num11;
		float num13 = positions[0].y;
		float num14 = num13;
		for (int j = 1; j < 4; j++)
		{
			num11 = Mathf.Min(num11, positions[j].x);
			num12 = Mathf.Max(num12, positions[j].x);
			num13 = Mathf.Min(num13, positions[j].y);
			num14 = Mathf.Max(num14, positions[j].y);
		}
		float num15 = num12 - num11;
		float num16 = num14 - num13;
		if (num15 < 1E-06f || num16 < 1E-06f)
		{
			return null;
		}
		float num17 = (float)num8 / num15;
		float num18 = (float)num9 / num16;
		RenderTexture active = RenderTexture.active;
		RenderTexture temporary = RenderTexture.GetTemporary(num8, num9, 0, (RenderTextureFormat)0, TexUtil.ReadWriteForSource(atlas));
		Texture2D val;
		try
		{
			RenderTexture.active = temporary;
			GL.Clear(true, true, Color.clear);
			GL.PushMatrix();
			GL.LoadPixelMatrix(0f, (float)num8, 0f, (float)num9);
			TexUtil.SetPassTextured(atlas);
			GL.Begin(7);
			GL.Color(Color.white);
			int[] array = new int[4] { 0, 1, 3, 2 };
			foreach (int num19 in array)
			{
				GL.TexCoord(Vector2.op_Implicit(uvs[num19]));
				GL.Vertex3((positions[num19].x - num11) * num17, (positions[num19].y - num13) * num18, 0f);
			}
			GL.End();
			GL.PopMatrix();
			val = new Texture2D(num8, num9, (TextureFormat)4, false)
			{
				hideFlags = (HideFlags)32
			};
			val.ReadPixels(new Rect(0f, 0f, (float)num8, (float)num9), 0, 0);
			val.Apply();
		}
		finally
		{
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
		}
		FlipPreviewHorizontal(val, num8, num9);
		return val;
	}

	internal static void ClearThumbCache()
	{
		foreach (Texture2D value in _thumbCache.Values)
		{
			if ((Object)(object)value != (Object)null)
			{
				Object.Destroy((Object)(object)value);
			}
		}
		_thumbCache.Clear();
	}

	private static Texture2D GetUprightThumb(tk2dSpriteCollectionData coll, int spriteId, tk2dSpriteDefinition def, Texture atlas)
	{
		int fileIndexVersion = SpriteLoader.FileIndexVersion;
		if (fileIndexVersion != _thumbFileVer)
		{
			ClearThumbCache();
			_thumbFileVer = fileIndexVersion;
		}
		(int, int) key = (((Object)coll).GetInstanceID(), spriteId);
		if (_thumbCache.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		if (_thumbCache.Count >= 96)
		{
			ClearThumbCache();
		}
		Texture2D val = RenderUprightNew(def, atlas, 96);
		if ((Object)(object)val != (Object)null)
		{
			_thumbCache[key] = val;
		}
		return val;
	}

	private static void FlipPreviewHorizontal(Texture2D tex, int w, int h)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		Color32[] pixels = tex.GetPixels32();
		Color32[] array = (Color32[])(object)new Color32[pixels.Length];
		for (int i = 0; i < h; i++)
		{
			for (int j = 0; j < w; j++)
			{
				array[i * w + j] = pixels[i * w + (w - 1 - j)];
			}
		}
		tex.SetPixels32(array);
		tex.Apply();
	}

	private static void DrawConsole(AnimEntry e)
	{
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Invalid comparison between Unknown and I4
		//IL_0217: Unknown result type (might be due to invalid IL or missing references)
		//IL_023b: Unknown result type (might be due to invalid IL or missing references)
		//IL_024f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0504: Unknown result type (might be due to invalid IL or missing references)
		//IL_0559: Unknown result type (might be due to invalid IL or missing references)
		//IL_055f: Invalid comparison between Unknown and I4
		//IL_030f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0774: Unknown result type (might be due to invalid IL or missing references)
		//IL_0779: Unknown result type (might be due to invalid IL or missing references)
		//IL_077b: Unknown result type (might be due to invalid IL or missing references)
		//IL_079f: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_097c: Unknown result type (might be due to invalid IL or missing references)
		//IL_09af: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a8a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0aae: Unknown result type (might be due to invalid IL or missing references)
		//IL_09d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a04: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a5a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a7e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0aff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b23: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e4d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e9e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0fa7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0fac: Unknown result type (might be due to invalid IL or missing references)
		if (e == null || !TryResolveDisplay(e, out var clip, out var coll, out var spriteId, out var frame, out var frameCount) || (Object)(object)coll == (Object)null || coll.spriteDefinitions == null || spriteId < 0 || spriteId >= coll.spriteDefinitions.Length)
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("Select an object to see its controls."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			return;
		}
		tk2dSpriteDefinition val = coll.spriteDefinitions[spriteId];
		Material val2 = (((Object)(object)val.materialInst != (Object)null) ? val.materialInst : val.material);
		if ((Object)(object)val2 == (Object)null)
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("Preview unavailable — material/texture released."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			return;
		}
		string text = ((Object)val2).name.Split(' ')[0];
		bool flag = e.Stale || (Object)(object)e.Live == (Object)null;
		bool flag2 = !flag && (Object)(object)e.Live != (Object)null && (Object)(object)((Component)e.Live).gameObject != (Object)null;
		string text2 = ((Object)coll).GetInstanceID() + "/" + spriteId;
		if (_reuseCacheKey != text2 && (int)Event.current.type == 8)
		{
			_reuseCacheKey = text2;
			RecomputeReuse(e, coll, spriteId);
		}
		GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MinHeight(GUIHelper.Scaled(28f)) });
		string text3 = ((clip != null) ? clip.name : (e.ClipName ?? "?"));
		GUILayout.Label(string.Format("{0}   ·   {1} {2}/{3}", text3, Loc.T("Frame"), frame + 1, frameCount) + (flag ? ("   " + Loc.T("(stopped)")) : ""), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		if (Paused && flag2)
		{
			GUI.contentColor = GUIHelper.ColWarn;
			GUILayout.Label(Loc.T("[PAUSED]"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		if (Frozen && flag2)
		{
			GUI.contentColor = Color.cyan;
			GUILayout.Label(Loc.T("[FROZEN]"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		if (_previewPlaying)
		{
			GUI.contentColor = GUIHelper.ColConfirm;
			GUILayout.Label(Loc.T("[PREVIEW]"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		GUILayout.FlexibleSpace();
		if (_reuseFrameCount > 1)
		{
			int num = 0;
			foreach (var reuseSource in _reuseSources)
			{
				if (reuseSource.Clip == clip)
				{
					num = reuseSource.Frames.Count;
					break;
				}
			}
			GUI.contentColor = GUIHelper.ColWarn;
			if (GUILayout.Button(string.Format("{0} ×{1} · ", Loc.T("Reused frames"), _reuseFrameCount) + string.Format(Loc.T("{0} clips@anim", "{0} clips"), _reuseClipCount) + ((num > 1) ? (" " + string.Format(Loc.T("({0} in this clip)"), num)) : ""), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				tk2dSpriteCollectionData lensColl = coll;
				int lensId = spriteId;
				string lensName = val.name;
				_pendingUiAction = delegate
				{
					SetLens(lensColl, lensId, lensName);
				};
			}
			GUI.contentColor = Color.white;
		}
		else
		{
			GUI.contentColor = GUIHelper.ColConfirm;
			GUILayout.Label(Loc.T("Only used here — safe to edit in isolation."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		GUILayout.EndHorizontal();
		string text4 = "";
		if (clip != null && clip.fps > 0f)
		{
			text4 = "  ·  " + string.Format(Loc.T("clip {0:F0} fps"), clip.fps);
			tk2dSpriteAnimator live = e.Live;
			if ((Object)(object)live != (Object)null && live.CurrentClip == clip && live.ClipFps > 0f && Mathf.Abs(live.ClipFps - clip.fps) > 0.05f)
			{
				text4 += string.Format(Loc.T(" → {0:F0} live"), live.ClipFps);
			}
		}
		GUI.contentColor = GUIHelper.ColFaint;
		GUILayout.Label($"{((Object)coll).name}  ·  {text}  ·  {val.name}  ·  id {spriteId}{text4}", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = Color.white;
		string text5 = ((Object)coll).name + "/" + text + "/" + val.name;
		if (_anchorCacheKey != text5 && (int)Event.current.type == 8)
		{
			_anchorCacheKey = text5;
			_anchorReplExists = false;
			_anchorCurrent = null;
			_anchorFilePath = null;
			_anchorPackSource = null;
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				if (FindTaggedOrPlain(Path.Combine(pluginPackPath, "Sprites", ((Object)coll).name, text), val.name) != null)
				{
					string path = pluginPackPath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
					string fileName = Path.GetFileName(path);
					if (string.Equals(fileName, "Stitchwork", StringComparison.OrdinalIgnoreCase) || string.Equals(fileName, "Patchwork", StringComparison.OrdinalIgnoreCase))
					{
						fileName = Path.GetFileName(Path.GetDirectoryName(path));
					}
					_anchorPackSource = fileName;
					break;
				}
			}
			if (_anchorPackSource == null)
			{
				string text6 = FindTaggedOrPlain(Path.Combine(SpriteLoader.LoadPath, ((Object)coll).name, text), val.name);
				if (text6 != null)
				{
					_anchorReplExists = true;
					_anchorFilePath = text6;
					_anchorCurrent = IOUtil.ParseAnchorTag(Path.GetFileNameWithoutExtension(text6)).anchor;
				}
			}
		}
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
		GUILayout.Label(Loc.T("This Sprite"), GUIHelper.SectionHeaderStyle, Array.Empty<GUILayoutOption>());
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		if (GUILayout.Button(Loc.T(File.Exists(Path.Combine(SpriteLoader.LoadPath, ((Object)coll).name, text, val.name + ".png")) ? "Edit (opens your file)" : "Edit (new from vanilla)"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			OpenSpriteForEdit(coll, val);
		}
		if (GUILayout.Button(Loc.T("Folder"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(64f) }))
		{
			IOUtil.OpenDeepestExisting(Path.Combine(SpriteLoader.LoadPath, ((Object)coll).name, text));
		}
		GUILayout.EndHorizontal();
		GUI.enabled = clip != null;
		Color backgroundColor = GUI.backgroundColor;
		GUI.backgroundColor = GUIHelper.ColAccent;
		bool num2 = GUILayout.Button(Loc.T("Detach for This Clip"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>());
		GUI.backgroundColor = backgroundColor;
		if (num2)
		{
			if (clip.name.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
			{
				Plugin.Logger.LogWarning((object)("[AnimCtrl] Detach: clip name '" + clip.name + "' isn't filesystem-safe."));
			}
			else
			{
				string text7 = Path.Combine(SpriteLoader.LoadPath, ((Object)coll).name, "Clips", clip.name);
				string text8 = Path.Combine(text7, val.name + ".png");
				if (!File.Exists(text8))
				{
					string text9 = Path.Combine(SpriteLoader.LoadPath, ((Object)coll).name, text, val.name + ".png");
					string text10 = (File.Exists(text9) ? text9 : null);
					if (text10 == null)
					{
						SpriteDumper.DumpSingleSprite(val, coll);
						string text11 = Path.Combine(SpriteDumper.DumpPath, ((Object)coll).name, text, val.name + ".png");
						if (File.Exists(text11))
						{
							text10 = text11;
						}
					}
					if (text10 == null)
					{
						Plugin.Logger.LogError((object)("[AnimCtrl] Detach: no source for " + ((Object)coll).name + "/" + text + "/" + val.name));
					}
					else
					{
						IOUtil.EnsureDirectoryExists(text7);
						File.Copy(text10, text8, overwrite: true);
						Plugin.Logger.LogInfo((object)("[AnimCtrl] Detached '" + val.name + "' for clip '" + clip.name + "' → " + text8));
					}
				}
				if (File.Exists(text8))
				{
					IOUtil.OpenPath(text8);
				}
			}
		}
		GUI.enabled = true;
		GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
		{
			GUILayout.Height(GUIHelper.Scaled(48f)),
			GUILayout.ExpandWidth(true)
		});
		if (_anchorPackSource != null)
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("Supplied by pack:") + " " + _anchorPackSource, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		else if (_anchorReplExists)
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("Anchor:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(52f) });
			GUI.contentColor = Color.white;
			DrawAnchorButton("↑", "top-center");
			DrawAnchorButton("↓", null);
			DrawAnchorButton("←", "left-center");
			DrawAnchorButton("→", "right-center");
			DrawAnchorButton("◆", "center");
			GUILayout.EndHorizontal();
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("Anchor affects enlarged replacements only."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		else
		{
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("No replacement file yet — Edit creates one."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		GUILayout.FlexibleSpace();
		GUILayout.EndVertical();
		GUILayout.EndVertical();
		GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
		GUILayout.Label(Loc.T("Whole Clip"), GUIHelper.SectionHeaderStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = GUIHelper.ColFaint;
		GUILayout.Label(Loc.T("Animation canvas — whole-clip workflow:"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = Color.white;
		GUI.enabled = clip != null && !AnimCanvasBatch.IsRunning;
		if (GUILayout.Button(Loc.T("Ready All for Edit"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			int num3 = 0;
			for (int num4 = 0; num4 < clip.frames.Length; num4++)
			{
				tk2dSpriteAnimationFrame val3 = clip.frames[num4];
				tk2dSpriteCollectionData spriteCollection = val3.spriteCollection;
				if ((Object)(object)spriteCollection == (Object)null || val3.spriteId < 0 || val3.spriteId >= spriteCollection.spriteDefinitions.Length)
				{
					continue;
				}
				tk2dSpriteDefinition val4 = spriteCollection.spriteDefinitions[val3.spriteId];
				if (string.IsNullOrEmpty(val4.name))
				{
					continue;
				}
				string text12 = ((Object)(((Object)(object)val4.materialInst != (Object)null) ? val4.materialInst : val4.material)).name.Split(' ')[0];
				string text13 = Path.Combine(SpriteLoader.LoadPath, ((Object)spriteCollection).name, text12, val4.name + ".png");
				if (File.Exists(text13))
				{
					num3++;
					continue;
				}
				SpriteDumper.DumpSingleSprite(val4, spriteCollection);
				string text14 = Path.Combine(SpriteDumper.DumpPath, ((Object)spriteCollection).name, text12, val4.name + ".png");
				if (!File.Exists(text14))
				{
					Plugin.Logger.LogError((object)("Failed to dump: " + ((Object)spriteCollection).name + "/" + text12 + "/" + val4.name));
				}
				else
				{
					IOUtil.EnsureDirectoryExists(Path.Combine(SpriteLoader.LoadPath, ((Object)spriteCollection).name, text12));
					File.Copy(text14, text13, overwrite: true);
					num3++;
				}
			}
			Plugin.Logger.LogInfo((object)$"[AnimCtrl] Copied {num3} sprites from '{clip.name}' ({clip.frames.Length} frames) to {SpriteLoader.LoadPath}");
			for (int num5 = 0; num5 < clip.frames.Length; num5++)
			{
				tk2dSpriteAnimationFrame val5 = clip.frames[num5];
				tk2dSpriteCollectionData spriteCollection2 = val5.spriteCollection;
				if ((Object)(object)spriteCollection2 == (Object)null || val5.spriteId < 0 || val5.spriteId >= spriteCollection2.spriteDefinitions.Length)
				{
					continue;
				}
				tk2dSpriteDefinition val6 = spriteCollection2.spriteDefinitions[val5.spriteId];
				if (!string.IsNullOrEmpty(val6.name))
				{
					string path2 = ((Object)(((Object)(object)val6.materialInst != (Object)null) ? val6.materialInst : val6.material)).name.Split(' ')[0];
					string path3 = Path.Combine(SpriteLoader.LoadPath, ((Object)spriteCollection2).name, path2, val6.name + ".png");
					if (File.Exists(path3))
					{
						IOUtil.OpenPath(path3);
					}
				}
			}
			_anchorCacheKey = null;
		}
		string text15 = AnimCanvasAuthoring.WipDirFor(clip);
		if (text15 != null)
		{
			string fileName2 = Path.GetFileName(Path.GetDirectoryName(text15));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("Workspace") + ": " + fileName2 + "/" + Path.GetFileName(text15), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			if (GUILayout.Button(Loc.T("Open"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(52f) }))
			{
				IOUtil.OpenDeepestExisting(text15);
			}
			GUILayout.EndHorizontal();
		}
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		if (GUILayout.Button(Loc.T("Extract Vanilla"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			AnimCanvasAuthoring.ExtractClip(clip);
			string text16 = AnimCanvasAuthoring.WipDirFor(clip);
			if (text16 != null && Directory.Exists(text16))
			{
				IOUtil.OpenPath(text16);
			}
		}
		if (GUILayout.Button(Loc.T("Extract As Rendered"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			AnimCanvasAuthoring.ExtractClip(clip, 0.5f, 0, fromCurrentRender: true);
			string text17 = AnimCanvasAuthoring.WipDirFor(clip);
			if (text17 != null && Directory.Exists(text17))
			{
				IOUtil.OpenPath(text17);
			}
		}
		GUILayout.EndHorizontal();
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		if (GUILayout.Button(Loc.T("Compile Animation from Workspace"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			AnimCanvasCompile.CompileClip(clip);
		}
		Color backgroundColor2 = GUI.backgroundColor;
		GUI.backgroundColor = GUIHelper.ColAccent;
		if (GUILayout.Button(Loc.T("Compile for This Clip"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			AnimCanvasCompile.CompileClip(clip, forClipOnly: true);
		}
		GUI.backgroundColor = backgroundColor2;
		GUILayout.EndHorizontal();
		if (GUILayout.Button(Loc.T("Export GIF"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			int width;
			int height;
			List<Color32[]> list = AnimCanvasAuthoring.RenderClipSequence(clip, fromCurrentRender: true, 0.1f, out width, out height);
			if (list == null)
			{
				Plugin.Logger.LogWarning((object)("[Showcase] '" + clip.name + "': no renderable frames — GIF not written."));
			}
			else
			{
				string text18 = Path.Combine(Plugin.BasePath, "Showcase");
				IOUtil.EnsureDirectoryExists(text18);
				string text19 = Path.Combine(text18, T2DUtil.SanitizeForFilesystem(clip.name) + ".gif");
				int num6 = Mathf.Max(2, Mathf.RoundToInt(100f / Mathf.Max(1f, _previewFps)));
				try
				{
					GifEncoder.Write(text19, width, height, list, num6);
					Plugin.Logger.LogInfo((object)$"[Showcase] GIF: {list.Count} frame(s) {width}×{height} @ {num6} cs/frame → {text19}");
					IOUtil.OpenPath(text19);
				}
				catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
				{
					Plugin.Logger.LogError((object)("[Showcase] GIF write failed: " + ex.Message));
				}
			}
		}
		GUI.enabled = true;
		GUILayout.EndVertical();
		GUILayout.EndHorizontal();
	}

	private unsafe static string KeyName(KeyCode k)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Expected I4, but got Unknown
		if ((int)k != 127)
		{
			return (k - 277) switch
			{
				3 => "PgUp", 
				4 => "PgDn", 
				0 => "Ins", 
				_ => ((object)(*(KeyCode*)(&k))/*cast due to .constrained prefix*/).ToString(), 
			};
		}
		return "Del";
	}

	private static void EnsurePreviewWhite()
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_previewWhite != (Object)null))
		{
			_previewWhite = new Texture2D(1, 1)
			{
				hideFlags = (HideFlags)32
			};
			_previewWhite.SetPixel(0, 0, Color.white);
			_previewWhite.Apply();
		}
	}

	private static Rect ScaleToFitRect(Rect container, int texW, int texH)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		if (texW <= 0 || texH <= 0)
		{
			return container;
		}
		float num = Mathf.Min(((Rect)(ref container)).width / (float)texW, ((Rect)(ref container)).height / (float)texH);
		float num2 = (float)texW * num;
		float num3 = (float)texH * num;
		return new Rect(((Rect)(ref container)).x + (((Rect)(ref container)).width - num2) * 0.5f, ((Rect)(ref container)).y + (((Rect)(ref container)).height - num3) * 0.5f, num2, num3);
	}

	private static void RecomputeReuse(AnimEntry e, tk2dSpriteCollectionData coll, int spriteId)
	{
		_reuseFrameCount = 0;
		_reuseClipCount = 0;
		_reuseSources.Clear();
		tk2dSpriteAnimation val = e?.Library;
		if ((Object)(object)val == (Object)null || val.clips == null || (Object)(object)coll == (Object)null)
		{
			return;
		}
		tk2dSpriteAnimationClip[] clips = val.clips;
		foreach (tk2dSpriteAnimationClip val2 in clips)
		{
			if (val2 == null || val2.frames == null)
			{
				continue;
			}
			List<int> list = null;
			for (int j = 0; j < val2.frames.Length; j++)
			{
				tk2dSpriteAnimationFrame val3 = val2.frames[j];
				if ((Object)(object)val3.spriteCollection == (Object)(object)coll && val3.spriteId == spriteId)
				{
					(list ?? (list = new List<int>())).Add(j);
				}
			}
			if (list != null)
			{
				_reuseFrameCount += list.Count;
				_reuseClipCount++;
				_reuseSources.Add((val2, list));
			}
		}
	}

	private static void DrawAnchorButton(string label, string anchor)
	{
		//IL_0014: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		GUI.contentColor = ((_anchorCurrent == anchor) ? GUIHelper.ColConfirm : Color.white);
		if (GUILayout.Button(label, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(30f) }))
		{
			SetAnchorByRename(anchor);
		}
		GUI.contentColor = Color.white;
	}

	private static string FindTaggedOrPlain(string dir, string spriteName)
	{
		if (!Directory.Exists(dir))
		{
			return null;
		}
		string text = Path.Combine(dir, spriteName + ".png");
		if (File.Exists(text))
		{
			return text;
		}
		string[] array = new string[5] { "@t", "@b", "@l", "@r", "@c" };
		foreach (string text2 in array)
		{
			string text3 = Path.Combine(dir, spriteName + text2 + ".png");
			if (File.Exists(text3))
			{
				return text3;
			}
		}
		return null;
	}

	private static void SetAnchorByRename(string anchor)
	{
		if (_anchorFilePath == null)
		{
			return;
		}
		string directoryName = Path.GetDirectoryName(_anchorFilePath);
		string item = IOUtil.ParseAnchorTag(Path.GetFileNameWithoutExtension(_anchorFilePath)).name;
		string text = Path.Combine(directoryName, item + anchor switch
		{
			"top-center" => "@t", 
			"left-center" => "@l", 
			"right-center" => "@r", 
			"center" => "@c", 
			_ => "", 
		} + ".png");
		if (string.Equals(text, _anchorFilePath, StringComparison.OrdinalIgnoreCase))
		{
			return;
		}
		if (File.Exists(text))
		{
			Plugin.Logger.LogWarning((object)("[Anchor] Can't set anchor: '" + Path.GetFileName(text) + "' already exists - remove the duplicate first (multiple anchor-tagged files for one sprite)."));
			return;
		}
		try
		{
			File.Move(_anchorFilePath, text);
			_anchorFilePath = text;
			_anchorCurrent = anchor;
			_anchorCacheKey = null;
			Plugin.Logger.LogInfo((object)("[Anchor] " + Path.GetFileName(text) + " anchor set to " + (anchor ?? "bottom (default)")));
		}
		catch (Exception ex)
		{
			Plugin.Logger.LogWarning((object)("[Anchor] rename failed: " + ex.Message));
		}
	}
}
public class DialogueHandler
{
	private sealed class StoredCopyBridge
	{
		public Type Type;

		public MethodInfo Refresh;

		public FieldInfo KeyField;
	}

	private static string _cachedLangString;

	private static bool _gameLanguageAlive;

	public static Dictionary<string, Dictionary<string, Dictionary<string, string>>> TextCache = new Dictionary<string, Dictionary<string, Dictionary<string, string>>>();

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

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

	private static bool _staleKeysReported;

	private static bool _dumpInProgress;

	private static FieldInfo _entrySheetsField;

	private static bool _entrySheetsResolved;

	private static object _lastDictInstance;

	private static readonly Dictionary<(string sheet, string key), (bool existed, string value)> _dictOriginals = new Dictionary<(string, string), (bool, string)>();

	private static List<StoredCopyBridge> _storedCopyBridges;

	public static string TextDumpPath => Path.Combine(Plugin.BasePath, "TextDumps");

	public static string TextLoadPath => Path.Combine(Plugin.BasePath, "Text");

	public static string CurrentLangCode => CurrentLangStringCached();

	public static int StaleKeyCount { get; private set; }

	public static int CachedSheetCount
	{
		get
		{
			int num = 0;
			foreach (Dictionary<string, Dictionary<string, string>> value in TextCache.Values)
			{
				num += value.Count;
			}
			return num;
		}
	}

	public static int CachedKeyCount
	{
		get
		{
			int num = 0;
			foreach (Dictionary<string, Dictionary<string, string>> value in TextCache.Values)
			{
				foreach (Dictionary<string, string> value2 in value.Values)
				{
					num += value2.Count;
				}
			}
			return num;
		}
	}

	public static event Action<string, string, string> OnTextAccessed;

	private static string CurrentLangStringCached()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		if (_cachedLangString != null)
		{
			return _cachedLangString;
		}
		if (!_gameLanguageAlive)
		{
			return "EN";
		}
		try
		{
			return _cachedLangString = ((object)Language.CurrentLanguage()/*cast due to .constrained prefix*/).ToString();
		}
		catch (TypeInitializationException)
		{
			return "EN";
		}
	}

	public static void DumpText()
	{
		string text = CurrentLangStringCached();
		_dumpInProgress = true;
		try
		{
			foreach (object value in Enum.GetValues(typeof(SupportedLanguages)))
			{
				string text2 = value.ToString();
				Plugin.Logger.LogDebug((object)("Dumping text for language code " + text2 + "..."));
				Language.SwitchLanguage(text2);
				int num = 0;
				int num2 = 0;
				foreach (string sheet in Language.GetSheets())
				{
					IOUtil.EnsureDirectoryExists(Path.Combine(TextDumpPath, sheet));
					using StreamWriter streamWriter = new StreamWriter(Path.Combine(TextDumpPath, sheet, text2 + ".yml"));
					foreach (string key in Language.GetKeys(sheet))
					{
						string text3 = Language.Get(key, sheet);
						streamWriter.WriteLine(key + ": \"" + text3.Replace("\"", "\\\"") + "\"");
						num++;
					}
					streamWriter.Flush();
					streamWriter.Close();
					num2++;
				}
				Plugin.Logger.LogDebug((object)$"Finished dumping text for language code {text2}. Dumped {num} keys in {num2} sheets.");
			}
			Plugin.Logger.LogInfo((object)("[Stitchwork] Text dump complete (vanilla source) → " + TextDumpPath));
		}
		finally
		{
			_dumpInProgress = false;
			Language.SwitchLanguage(text);
		}
	}

	public static void InvalidateCache(string sheet, string lang)
	{
		if (TextCache.TryGetValue(lang, out var value) && value.Remove(sheet))
		{
			Plugin.Logger.LogDebug((object)("Invalidating text cache for sheet: " + sheet + ", lang: " + lang));
		}
	}

	public static IEnumerable<(string Sheet, string Key, string Value)> SearchCache(string filter, HashSet<string> skipKeys = null)
	{
		if (string.IsNullOrEmpty(filter) || !TextCache.TryGetValue(CurrentLangCode, out var value))
		{
			yield break;
		}
		foreach (KeyValuePair<string, Dictionary<string, string>> item in value)
		{
			string sheet = item.Key;
			bool sheetMatch = sheet.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
			foreach (KeyValuePair<string, string> item2 in item.Value)
			{
				if ((skipKeys == null || !skipKeys.Contains(sheet + "|" + item2.Key)) && (sheetMatch || item2.Key.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0 || item2.Value.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0))
				{
					yield return (Sheet: sheet, Key: item2.Key, Value: item2.Value);
				}
			}
		}
	}

	public static void Reload()
	{
		ConflictTracker.ClearTypes("text");
		TextCache.Clear();
		RequestedOverrideKeys.Clear();
		AllOverrideKeys.Clear();
		StaleKeyCount = 0;
		_staleKeysReported = false;
		Language.SwitchLanguage(CurrentLangStringCached());
		Plugin.Logger.LogDebug((object)"[Stitchwork] Text hot-reload: cleared cache and re-switched language to force refresh.");
	}

	public static void ApplyPatches(Harmony harmony)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Expected O, but got Unknown
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Expected O, but got Unknown
		harmony.Patch((MethodBase)AccessTools.Method(typeof(Language), "Get", new Type[2]
		{
			typeof(string),
			typeof(string)
		}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(DialogueHandler), "GetTextPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		try
		{
			int num = 0;
			MethodInfo[] methods = typeof(Language).GetMethods(BindingFlags.Static | BindingFlags.Public);
			foreach (MethodInfo methodInfo in methods)
			{
				if (!(methodInfo.Name != "SwitchLanguage") && !methodInfo.IsGenericMethod)
				{
					try
					{
						harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(DialogueHandler), "SwitchLanguagePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						num++;
					}
					catch (Exception ex)
					{
						Plugin.Logger.LogWarning((object)("[DialogueHandler] Failed to patch Language.SwitchLanguage overload " + $"({methodInfo}): {ex.Message}"));
					}
				}
			}
			if (num == 0)
			{
				Plugin.Logger.LogWarning((object)"[DialogueHandler] No Language.SwitchLanguage overloads were patched. Language-change cache invalidation will be skipped; stale CurrentLangCode is possible until next scene/reload.");
			}
		}
		catch (Exception ex2)
		{
			Plugin.Logger.LogError((object)("[DialogueHandler] SwitchLanguage enumeration threw: " + ex2.Message + ". Cache invalidation patches skipped; downstream patches continue."));
		}
	}

	private static void SwitchLanguagePostfix()
	{
		_gameLanguageAlive = true;
		_cachedLangString = null;
		Loc.OnGameLanguageChanged();
		SyncGameLanguageDict();
	}

	private static void GetTextPostfix(string key, string sheetTitle, ref string __result)
	{
		if (!_gameLanguageAlive)
		{
			_gameLanguageAlive = true;
			Loc.OnGameLanguageChanged();
		}
		if (_dumpInProgress)
		{
			return;
		}
		long heapBefore = DevProfiler.SnapshotHeapBytes();
		try
		{
			string text = CurrentLangStringCached();
			if (GetOrLoadSheet(text, sheetTitle).TryGetValue(key, out var value))
			{
				__result = value;
				RequestedOverrideKeys.Add(text + "|" + sheetTitle + "|" + key);
			}
			FontHandler.NoteRenderedText(__result);
			DialogueHandler.OnTextAccessed?.Invoke(sheetTitle, key, __result);
		}
		finally
		{
			DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Language.Get", heapBefore);
		}
	}

	private static Dictionary<string, string> GetOrLoadSheet(string lang, string sheetTitle)
	{
		if (!TextCache.TryGetValue(lang, out var value))
		{
			value = new Dictionary<string, Dictionary<string, string>>();
			TextCache[lang] = value;
		}
		if (!value.TryGetValue(sheetTitle, out var value2))
		{
			value2 = (value[sheetTitle] = LoadTextSheet(sheetTitle, lang));
			if (value2.Count > 0)
			{
				FontFileWatcher.ReloadFonts = true;
			}
		}
		return value2;
	}

	private static Dictionary<string, string> LoadTextSheet(string sheetTitle, string lang)
	{
		Dictionary<string, string> dictionary = new Dictionary<string, string>();
		Dictionary<string, string> dictionary2 = new Dictionary<string, string>();
		foreach (string pluginPackPath in Plugin.PluginPackPaths)
		{
			foreach (KeyValuePair<string, string> item in LoadTextSheet(sheetTitle, lang, Path.Combine(pluginPackPath, "Text")))
			{
				if (!dictionary.ContainsKey(item.Key))
				{
					dictionary[item.Key] = item.Value;
					dictionary2[item.Key] = pluginPackPath;
				}
				else if (!string.Equals(dictionary[item.Key], item.Value, StringComparison.Ordinal))
				{
					ConflictTracker.Record("text", sheetTitle + "/" + lang + "/" + item.Key, dictionary2.TryGetValue(item.Key, out var value) ? value : null, pluginPackPath);
				}
			}
		}
		foreach (KeyValuePair<string, string> item2 in LoadTextSheet(sheetTitle, lang, TextLoadPath))
		{
			if (dictionary.ContainsKey(item2.Key) && dictionary2.TryGetValue(item2.Key, out var value2) && !string.Equals(dictionary[item2.Key], item2.Value, StringComparison.Ordinal))
			{
				ConflictTracker.Record("text", sheetTitle + "/" + lang + "/" + item2.Key, null, value2);
			}
			dictionary[item2.Key] = item2.Value;
		}
		foreach (string key in dictionary.Keys)
		{
			AllOverrideKeys.Add(lang + "|" + sheetTitle + "|" + key);
		}
		return dictionary;
	}

	public static void CheckForStaleKeys()
	{
		if (_staleKeysReported)
		{
			return;
		}
		int num = 0;
		string text = CurrentLangStringCached();
		string value = text + "|";
		foreach (string allOverrideKey in AllOverrideKeys)
		{
			if (!RequestedOverrideKeys.Contains(allOverrideKey) && allOverrideKey.StartsWith(value, StringComparison.Ordinal))
			{
				string[] array = allOverrideKey.Split('|', 3);
				string text2 = array[1];
				string text3 = array[2];
				num++;
				Plugin.Logger.LogWarning((object)("[Stitchwork] Text override key \"" + text3 + "\" in sheet \"" + text2 + "\" (" + text + ") was never requested by the game — key may have been renamed by a game update. Consider re-dumping text with DumpText enabled."));
			}
		}
		StaleKeyCount = num;
		_staleKeysReported = true;
		if (num > 0)
		{
			Plugin.Logger.LogWarning((object)$"[Stitchwork] {num} stale text override key(s) detected. These overrides are not being applied.");
		}
	}

	private static Dictionary<string, string> LoadTextSheet(string sheetTitle, string lang, string basePath)
	{
		return ParseSheetFile(Path.Combine(basePath, sheetTitle, lang + ".yml"));
	}

	internal static Dictionary<string, string> ParseSheetFile(string filePath)
	{
		Dictionary<string, string> dictionary = new Dictionary<string, string>();
		if (!File.Exists(filePath))
		{
			return dictionary;
		}
		string[] array = File.ReadAllLines(filePath);
		foreach (string text in array)
		{
			if (!text.StartsWith("#") && !string.IsNullOrWhiteSpace(text))
			{
				int num = text.IndexOf(':');
				if (num != -1)
				{
					string key = text.Substring(0, num).Trim();
					string value = text.Substring(num + 1).Trim().Trim('"')
						.Replace("\\\"", "\"");
					dictionary[key] = value;
				}
			}
		}
		return dictionary;
	}

	private static void SyncGameLanguageDict()
	{
		if (!GameBridge.IsHK1)
		{
			return;
		}
		if (!_entrySheetsResolved)
		{
			_entrySheetsResolved = true;
			_entrySheetsField = AccessTools.Field(typeof(Language), "_currentEntrySheets");
			if (_entrySheetsField == null)
			{
				Plugin.Logger.LogWarning((object)"[DialogueHandler] HK1 dict sync: Language._currentEntrySheets not found — push-model text disabled; stored-string consumers may show vanilla.");
			}
		}
		if (_entrySheetsField == null || !(_entrySheetsField.GetValue(null) is Dictionary<string, Dictionary<string, string>> dictionary))
		{
			return;
		}
		if (dictionary != _lastDictInstance)
		{
			_dictOriginals.Clear();
			_lastDictInstance = dictionary;
		}
		string text = CurrentLangStringCached();
		HashSet<(string sheet, string key)> desired = new HashSet<(string, string)>();
		int num = 0;
		foreach (string item in dictionary.Keys.ToList())
		{
			Dictionary<string, string> orLoadSheet = GetOrLoadSheet(text, item);
			if (orLoadSheet.Count == 0)
			{
				continue;
			}
			Dictionary<string, string> dictionary2 = dictionary[item];
			foreach (KeyValuePair<string, string> item2 in orLoadSheet)
			{
				(string, string) tuple = (item, item2.Key);
				desired.Add(tuple);
				if (!_dictOriginals.ContainsKey(tuple))
				{
					_dictOriginals[tuple] = (dictionary2.TryGetValue(item2.Key, out var value), value);
				}
				dictionary2[item2.Key] = item2.Value;
				num++;
			}
		}
		foreach (var item3 in _dictOriginals.Keys.Where(((string sheet, string key) a) => !desired.Contains(a)).ToList())
		{
			if (dictionary.TryGetValue(item3.sheet, out var value2) && _dictOriginals.TryGetValue(item3, out (bool, string) value3))
			{
				if (value3.Item1)
				{
					value2[item3.key] = value3.Item2;
				}
				else
				{
					value2.Remove(item3.key);
				}
			}
			_dictOriginals.Remove(item3);
		}
		if (num > 0)
		{
			Plugin.Logger.LogDebug((object)$"[DialogueHandler] HK1 dict sync: {num} override(s) written into the game's language dict ({text}).");
		}
		RefreshStoredTextCopies();
	}

	private static void RefreshStoredTextCopies()
	{
		if (_storedCopyBridges == null)
		{
			_storedCopyBridges = new List<StoredCopyBridge>();
			Resolve("SetTextMeshProGameText", "UpdateText", null);
			Resolve("TeamCherry.Localization.LocalizedTextMesh", "LocalizeTextMesh", "keyValue");
		}
		foreach (StoredCopyBridge storedCopyBridge in _storedCopyBridges)
		{
			int num = 0;
			Object[] array = Resources.FindObjectsOfTypeAll(storedCopyBridge.Type);
			foreach (Object val in array)
			{
				if (val == (Object)null)
				{
					continue;
				}
				if (storedCopyBridge.KeyField != null)
				{
					if (!(storedCopyBridge.KeyField.GetValue(val) is string { Length: not 0 } text))
					{
						continue;
					}
					storedCopyBridge.Refresh.Invoke(val, new object[1] { text });
				}
				else
				{
					storedCopyBridge.Refresh.Invoke(val, null);
				}
				num++;
			}
			if (num > 0)
			{
				Plugin.Logger.LogDebug((object)$"[DialogueHandler] HK1 dict sync: refreshed {num} {storedCopyBridge.Type.Name} instance(s).");
			}
		}
		static void Resolve(string typeName, string methodName, string keyFieldName)
		{
			Type type = AccessTools.TypeByName(typeName);
			MethodInfo methodInfo = ((type != null) ? AccessTools.Method(type, methodName, (Type[])null, (Type[])null) : null);
			FieldInfo fieldInfo = ((keyFieldName != null && type != null) ? AccessTools.Field(type, keyFieldName) : null);
			if (methodInfo == null || (keyFieldName != null && fieldInfo == null))
			{
				Plugin.Logger.LogWarning((object)("[DialogueHandler] HK1 dict sync: " + typeName + " bridge unresolved — its stored-copy refresh is disabled."));
			}
			else
			{
				_storedCopyBridges.Add(new StoredCopyBridge
				{
					Type = type,
					Refresh = methodInfo,
					KeyField = fieldInfo
				});
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	internal static class IsExternalInit
	{
	}
}
namespace Stitchwork
{
	[BepInPlugin("Stitchwork", "Stitchwork", "0.8.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static StitchworkConfig Config;

		internal static SpriteFileWatcher SpriteFileWatcher;

		internal static AudioFileWatcher AudioFileWatcher;

		internal static TextFileWatcher TextFileWatcher;

		internal static FontFileWatcher FontFileWatcher;

		private bool _isInert;

		private static bool _inertToastDismissed;

		public static bool ShowPackManager = false;

		public static bool ShowDevHub = false;

		private const float MenuSceneDeferDelay = 1f;

		private static readonly string[] MenuScenePatterns = new string[3] { "menu", "title", "mode_select" };

		private const float DeferredReapplyDelay = 0.1f;

		private static int _conditionPollFrames = 0;

		private const int ConditionPollInterval = 120;

		private int _focusRegainReloadFrame = -1;

		private const int FocusRegainReloadDelayFrames = 3;

		private static GUIStyle _inertTitleStyle;

		private static GUIStyle _inertBodyStyle;

		private static GUIStyle _inertBoxStyle;

		private static string _noticeTitle;

		private static string _noticeBody;

		internal static Harmony HarmonyInstance { get; private set; }

		public static Plugin Instance { get; private set; }

		public static string BasePath => Path.GetDirectoryName(typeof(Plugin).Assembly.Location);

		public static bool CustomizerPluginPresent { get; private set; }

		public static IEnumerable<string> PluginPackPaths => PackManager.ActivePackPaths;

		public static bool ShowStatusOverlay
		{
			get
			{
				return Config?.ShowStatusOverlay ?? true;
			}
			set
			{
				if (Config != null)
				{
					Config.ShowStatusOverlay = value;
				}
			}
		}

		public static int DevHubTab
		{
			get
			{
				return Config?.DevHubTab ?? 0;
			}
			set
			{
				if (Config != null)
				{
					Config.DevHubTab = value;
				}
			}
		}

		private void Awake()
		{
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			if (Chainloader.PluginInfos.ContainsKey("Patchwork"))
			{
				Logger.LogWarning((object)"════════════════════════════════════════════════════════");
				Logger.LogWarning((object)"[Stitchwork] Upstream Patchwork detected.");
				Logger.LogWarning((object)"");
				Logger.LogWarning((object)"  Stitchwork is a fork that supersedes Patchwork. Running");
				Logger.LogWarning((object)"  both at the same time will produce duplicate Harmony");
				Logger.LogWarning((object)"  patches on sprite/texture setters and unpredictable");
				Logger.LogWarning((object)"  asset-swap behaviour.");
				Logger.LogWarning((object)"");
				Logger.LogWarning((object)"  Stitchwork is INERT this session.");
				Logger.LogWarning((object)"  Uninstall Patchwork.dll from BepInEx/plugins/ to enable");
				Logger.LogWarning((object)"  Stitchwork.");
				Logger.LogWarning((object)"════════════════════════════════════════════════════════");
				_isInert = true;
				return;
			}
			Config = new StitchworkConfig(((BaseUnityPlugin)this).Config);
			if (Config.DiagnosticMode)
			{
				Logger.LogWarning((object)"════════════════════════════════════════════════════════");
				Logger.LogWarning((object)"[Stitchwork] DiagnosticMode ACTIVE");
				Logger.LogWarning((object)"  - No Harmony patches applied");
				Logger.LogWarning((object)"  - No packs loaded");
				Logger.LogWarning((object)"  - No replacements will work");
				Logger.LogWarning((object)"  - DevProfiler [Mem] logging continues");
				Logger.LogWarning((object)"  - Use this for vanilla allocation-rate measurement only");
				Logger.LogWarning((object)"  - Toggle DiagnosticMode=false in BepInEx config to restore");
				Logger.LogWarning((object)"════════════════════════════════════════════════════════");
				DevProfiler.Initialize();
				GCUtil.InitBridge();
				return;
			}
			Logger.LogInfo((object)"Stitchwork is loaded! Version: 0.8.6");
			LogInstallRoot();
			Loc.SelfExtractEmbeddedTables();
			Loc.Init();
			int num = ((Config.HeapReserveMB < 0) ? GCUtil.SuggestReserveMB() : Config.HeapReserveMB);
			if (num > 0)
			{
				Logger.LogInfo((object)$"[GC] Pre-warming Mono heap: {num} MB (system RAM: {SystemInfo.systemMemorySize} MB)");
				GCUtil.PrewarmHeap((long)num * 1024L * 1024);
			}
			switch (BootConfigGC.Sync(Config.AutoEnableIncrementalGC))
			{
			case BootConfigGC.Result.KeyWritten:
				QueueNoticeToast(Loc.T("#toast.gc-enable.title", "Stitchwork — one restart to smoother performance"), Loc.T("#toast.gc-enable.body", "Incremental garbage collection has been enabled for Silksong (one line in boot.config; the original is backed up). This removes the game's periodic GC stutter.\n\nIt takes effect on the NEXT game launch — restart when convenient.\nOpt out anytime: AutoEnableIncrementalGC = false in Stitchwork's config."));
				break;
			case BootConfigGC.Result.KeyRemoved:
				QueueNoticeToast(Loc.T("#toast.gc-revert.title", "Stitchwork — restart to finish reverting"), Loc.T("#toast.gc-revert.body", "AutoEnableIncrementalGC is off — the incremental-GC line was removed from boot.config. The game's default GC behaviour returns on the next launch."));
				break;
			}
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				string key = pluginInfo.Key;
				PluginInfo value = pluginInfo.Value;
				object obj;
				if (value == null)
				{
					obj = null;
				}
				else
				{
					BepInPlugin metadata = value.Metadata;
					obj = ((metadata != null) ? metadata.Name : null);
				}
				if (obj == null)
				{
					obj = key;
				}
				string text = (string)obj;
				if (key.IndexOf("Customizer", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Customizer", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					CustomizerPluginPresent = true;
					Logger.LogError((object)("[Stitchwork] Conflicting plugin detected: '" + text + "' (GUID: " + key + "). Both mods patch sprite hooks and will conflict, causing broken sprite loading and enemy AI issues. Remove this plugin — Stitchwork replaces Customizer's functionality."));
				}
			}
			PackManager.Initialize();
			TexUtil.Initialize();
			InitializeFolders();
			AudioFileWatcher = new AudioFileWatcher();
			SpriteFileWatcher = new SpriteFileWatcher();
			TextFileWatcher = new TextFileWatcher();
			FontFileWatcher = new FontFileWatcher();
			FontFileWatcher.ReloadFonts = true;
			DevProfiler.Initialize();
			T2DLoader.PreloadAllTextures();
			FileCache.BeginCycle();
			try
			{
				VideoHandler.Reload();
			}
			finally
			{
				FileCache.EndCycle();
			}
			FileCache.BeginCycle();
			try
			{
				AudioHandler.Reload();
			}
			finally
			{
				FileCache.EndCycle();
			}
			SceneManager.sceneLoaded += OnSceneLoaded;
			SceneManager.sceneUnloaded += OnSceneUnloaded;
			Harmony val = (HarmonyInstance = new Harmony("Stitchwork"));
			val.PatchAll();
			AudioHandler.ApplyPatches(val);
			AnimationController.ApplyPatches(val);
			SpriteLoader.ApplyPatches(val);
			VideoHandler.ApplyPatches(val);
			SlashColourHandler.ApplyPatches(val);
			GUIHelper.InitInputBlocking();
			DialogueHandler.OnTextAccessed += delegate(string sheet, string key2, string text2)
			{
				TextLog.LogText(sheet, key2, text2);
			};
			DialogueHandler.OnTextAccessed += delegate(string sheet, string key2, string text2)
			{
				if (ShowDevHub)
				{
					DialogueEditor.TrackText(sheet, key2, text2);
				}
			};
			AudioHandler.OnAudioPlayed += delegate(AudioClip clip, AudioSource src)
			{
				AudioLog.LogAudio(clip, src);
			};
			T2DLoader.OnT2DTrigger += delegate(string raw, string clean, string sprite)
			{
				T2DLog.LogTrigger(raw, clean, sprite);
			};
			VideoHandler.OnCinematicTriggered += delegate(string name, bool replaced)
			{
				VideoPillar.LogCinematic(name, replaced);
			};
			GCUtil.OnTCGCStutter += delegate
			{
				DevProfiler.RecordSpike("TC GCManager stutter — threshold bumped 10%", 0f);
			};
			RawKeyboardLeakBlocker.ApplyPatches(val);
			((MonoBehaviour)this).StartCoroutine((IEnumerator)AwakeDelayed(val));
		}

		private IEnumerator<object> AwakeDelayed(Harmony harmony)
		{
			yield return null;
			DialogueHandler.ApplyPatches(harmony);
			DialogueFlagTracker.ApplyPatches(harmony);
			GUIHelper.InitCursor();
			if (Config.DumpText)
			{
				DialogueHandler.DumpText();
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			GCUtil.InitBridge();
			GameBridge.InitBridge();
			SpriteAtlasBridge.Init();
			HealthCheck.LogBootSummaryOnce();
			GUIHelper.LogEventSystemInventory(((Scene)(ref scene)).name);
			if (IsMainMenuScene(((Scene)(ref scene)).name))
			{
				GUIUtility.keyboardControl = 0;
				GUIHelper.ForceRestoreGameActions();
			}
			if (SceneTraverser.IsTraversing)
			{
				SceneTraverser.NotifySceneLoaded();
			}
			else if (Config.DumpSprites)
			{
				Logger.LogInfo((object)("Dumping sprites for scene " + ((Scene)(ref scene)).name));
				tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
				for (int i = 0; i < array.Length; i++)
				{
					SpriteDumper.DumpCollection(array[i]);
				}
				T2DDumper.DumpAllT2DSprites();
				SceneTraverser.OnDumpCompleted();
				Logger.LogInfo((object)("Finished dumping sprites for scene " + ((Scene)(ref scene)).name));
			}
			T2DLoader.ApplyReplacementsInScene();
			if (IsMenuScene(((Scene)(ref scene)).name))
			{
				((MonoBehaviour)this).StartCoroutine(DeferredMenuApply());
			}
			((MonoBehaviour)this).StartCoroutine(DelayedReapply());
			FileCache.BeginCycle();
			try
			{
				AudioHandler.PrimeForScene();
			}
			finally
			{
				FileCache.EndCycle();
			}
			RecolourHandler.ApplyToScene();
			SlashColourHandler.ApplyToConfigs();
			AnimationController.ClearAnimators();
			DialogueHandler.CheckForStaleKeys();
			PackManager.OnSceneLoaded(((Scene)(ref scene)).name);
			T2DLoader.OnSceneLoaded();
			T2DLoader.CheckForUninitializedSprites();
		}

		private void OnSceneUnloaded(Scene scene)
		{
			LogGate.Restore("scene unload");
			Logger.LogInfo((object)("[Scene] '" + ((Scene)(ref scene)).name + "' unloading"));
			T2DLoader.PruneStaleOriginals();
			T2DLoader.PruneSceneState();
			T2DLoader.ResetSceneSeed();
			RecolourHandler.OnSceneUnloaded();
			CameraTracker.OnSceneUnloaded();
		}

		private static bool IsMenuScene(string sceneName)
		{
			if (string.IsNullOrEmpty(sceneName))
			{
				return false;
			}
			string[] menuScenePatterns = MenuScenePatterns;
			foreach (string value in menuScenePatterns)
			{
				if (sceneName.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private IEnumerator DeferredMenuApply()
		{
			yield return (object)new WaitForSeconds(1f);
			Logger.LogDebug((object)"[MenuDefer] Running deferred ApplyReplacementsInScene for menu scene.");
			T2DLoader.ApplyReplacementsInScene();
			AppliqueLoader.Apply();
		}

		private IEnumerator DelayedReapply()
		{
			yield return (object)new WaitForSeconds(0.1f);
			Logger.LogDebug((object)"[SceneLoad] Running deferred ApplyReplacementsInScene (100 ms post-load).");
			T2DLoader.ApplyReplacementsInScene();
			RecolourHandler.ApplyToScene();
			SlashColourHandler.ApplyToConfigs();
			AppliqueLoader.Apply();
		}

		public static void ScheduleDeferredApplyPasses()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance == (Object)null))
			{
				((MonoBehaviour)Instance).StartCoroutine(Instance.DelayedReapply());
				Scene activeScene = SceneManager.GetActiveScene();
				if (IsMenuScene(((Scene)(ref activeScene)).name))
				{
					((MonoBehaviour)Instance).StartCoroutine(Instance.DeferredMenuApply());
				}
			}
		}

		private void LogInstallRoot()
		{
			Logger.LogInfo((object)("[Stitchwork] Install root: " + BasePath));
		}

		private void Update()
		{
			if (!_isInert)
			{
				DevProfiler.RecordFrame();
				DevProfiler.BeginUpdateTiming();
				long heapBefore = DevProfiler.SnapshotHeapBytes();
				T2DLoader.AdvanceSetterTracking();
				DevProfiler.StartOp();
				T2DLoader.CheckForUninitializedSprites();
				DevProfiler.RecordUninitMs(DevProfiler.StopOp("UninitCheck"));
				T2DLoader.ScanForLogTriggers();
				if (PackManager.HasHotReloadPacks && ++_conditionPollFrames >= 120)
				{
					_conditionPollFrames = 0;
					PackManager.PollHotReloadConditions();
				}
				GUIHelper.UpdateInputBlocking();
				HotkeyController.Poll();
				ReloadCoordinator.Poll();
				SpriteLoader.TickBindingWatchdog();
				LogGate.Tick();
				RecolourHandler.TickGlobal();
				if (_focusRegainReloadFrame > 0 && Time.frameCount >= _focusRegainReloadFrame)
				{
					_focusRegainReloadFrame = -1;
					Logger.LogDebug((object)"[Plugin] Focus regained; re-running SpriteLoader.Reload + T2D reload to refresh atlas RT contents.");
					SpriteLoader.Reload();
					T2DLoader.ReloadSpritesInScene();
				}
				AnimationController.Update();
				DevProfiler.AddOpPositiveNetHeapDelta("Plugin.Update.Total", heapBefore);
				DevProfiler.EndUpdateTiming();
			}
		}

		private void LateUpdate()
		{
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			if (ShowDevHub || ShowPackManager || CanvasPackManager.IsVisible || WorldPickMode.Active)
			{
				GUIHelper.ShowCursorForWindow();
			}
			CameraTracker.LateUpdate();
			RecolourHandler.EnforceAmbient();
			RecolourHandler.EnforceGlobal();
			DevProfiler.StartOp();
			T2DLoader.EnforceT2DReplacements();
			DevProfiler.RecordEnforceMs(DevProfiler.StopOp("EnforceT2D"));
			string text = Config?.T2DDiagWatchName ?? "";
			if (text.Length > 0)
			{
				T2DLoader.RunWatchedSpriteDiagnostic(text);
			}
			DevProfiler.AddOpPositiveNetHeapDelta("Plugin.LateUpdate.Total", heapBefore);
		}

		private void OnDestroy()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (Config != null)
			{
				Rect windowRect = DevHub.WindowRect;
				if (((Rect)(ref windowRect)).width > 0f)
				{
					Config.DevHubX = ((Rect)(ref windowRect)).x;
					Config.DevHubY = ((Rect)(ref windowRect)).y;
				}
				Rect windowRect2 = PackManagerWindow.WindowRect;
				if (((Rect)(ref windowRect2)).width > 0f)
				{
					Config.PackManagerX = ((Rect)(ref windowRect2)).x;
					Config.PackManagerY = ((Rect)(ref windowRect2)).y;
				}
			}
			GUIHelper.ForceRestoreGameActions();
			if (Config != null && Config.DevMode)
			{
				Loc.DumpKeysReport();
			}
			SpriteFileWatcher?.Dispose();
			AudioFileWatcher?.Dispose();
			TextFileWatcher?.Dispose();
			FontFileWatcher?.Dispose();
			SceneManager.sceneLoaded -= OnSceneLoaded;
			SceneManager.sceneUnloaded -= OnSceneUnloaded;
		}

		private void OnApplicationFocus(bool focus)
		{
			if (!_isInert && focus && Config != null && Config.EagerFocusReload)
			{
				_focusRegainReloadFrame = Time.frameCount + 3;
			}
		}

		private void OnGUI()
		{
			if (_isInert)
			{
				DrawInertToast();
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			GUIHelper.BeginOnGUI();
			CameraTracker.DrawIndicator();
			T2DLoader.IsT2DLogActive = false;
			AudioHandler.IsAudioBrowserActive = false;
			try
			{
				if (ShowStatusOverlay)
				{
					StatusOverlay.Draw();
				}
				DumpProgressOverlay.Draw();
				ReloadToast.Draw();
				if (ShowDevHub)
				{
					DevHub.Draw();
				}
				if (ShowPackManager)
				{
					PackManagerWindow.Draw();
				}
				WorldPickMode.OnGUI();
				if ((ShowDevHub || ShowPackManager || CanvasPackManager.IsVisible) && !Cursor.visible)
				{
					GUIHelper.DrawSoftwareCursor();
				}
				DrawNoticeToast();
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"[Stitchwork] OnGUI exception (will recover next frame): {arg}");
				GUIHelper.ReleaseFocus();
			}
			GUIHelper.EndOnGUI();
			DevProfiler.AddOpPositiveNetHeapDelta("Plugin.OnGUI.Total", heapBefore);
		}

		private static void QueueNoticeToast(string title, string body)
		{
			_noticeTitle = title;
			_noticeBody = body;
		}

		private void DrawNoticeToast()
		{
			//IL_0008: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (_noticeTitle == null)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (IsMainMenuScene(((Scene)(ref activeScene)).name))
			{
				EnsureInertStyles();
				Rect val = default(Rect);
				((Rect)(ref val))..ctor((float)Screen.width - 540f - 16f, (float)Screen.height - 210f - 16f, 540f, 210f);
				Color backgroundColor = GUI.backgroundColor;
				GUI.backgroundColor = new Color(0.08f, 0.08f, 0.1f, 0.94f);
				GUI.Box(val, "", _inertBoxStyle);
				GUI.backgroundColor = backgroundColor;
				GUILayout.BeginArea(new Rect(((Rect)(ref val)).x + 16f, ((Rect)(ref val)).y + 12f, ((Rect)(ref val)).width - 32f, ((Rect)(ref val)).height - 24f));
				GUILayout.Label(_noticeTitle, _inertTitleStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(6f);
				GUILayout.Label(_noticeBody, _inertBodyStyle, Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				if (GUILayout.Button(Loc.T("Got it"), (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(96f),
					GUILayout.Height(30f)
				}))
				{
					_noticeTitle = null;
					_noticeBody = null;
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				GUILayout.EndArea();
			}
		}

		private void DrawInertToast()
		{
			//IL_0008: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (_inertToastDismissed)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (IsMainMenuScene(((Scene)(ref activeScene)).name))
			{
				EnsureInertStyles();
				Rect val = default(Rect);
				((Rect)(ref val))..ctor((float)Screen.width - 540f - 16f, (float)Screen.height - 180f - 16f, 540f, 180f);
				Color backgroundColor = GUI.backgroundColor;
				GUI.backgroundColor = new Color(0.08f, 0.08f, 0.1f, 0.94f);
				GUI.Box(val, "", _inertBoxStyle);
				GUI.backgroundColor = backgroundColor;
				GUILayout.BeginArea(new Rect(((Rect)(ref val)).x + 16f, ((Rect)(ref val)).y + 12f, ((Rect)(ref val)).width - 32f, ((Rect)(ref val)).height - 24f));
				GUILayout.Label("Stitchwork is INACTIVE", _inertTitleStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(6f);
				GUILayout.Label("Upstream Patchwork was detected as also installed. Stitchwork has disabled itself this session to avoid Harmony patch conflicts.\n\nTo enable Stitchwork: remove Patchwork.dll from BepInEx/plugins/.", _inertBodyStyle, Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				if (GUILayout.Button("Got it", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(96f),
					GUILayout.Height(30f)
				}))
				{
					_inertToastDismissed = true;
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				GUILayout.EndArea();
			}
		}

		private static bool IsMainMenuScene(string sceneName)
		{
			if (string.IsNullOrEmpty(sceneName))
			{
				return false;
			}
			if (!(sceneName == "Menu_Title"))
			{
				return sceneName.StartsWith("Menu_", StringComparison.Ordinal);
			}
			return true;
		}

		private static void EnsureInertStyles()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0032: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			if (_inertTitleStyle == null)
			{
				_inertTitleStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 20,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4
				};
				_inertTitleStyle.normal.textColor = new Color(0.95f, 0.5f, 0.25f);
				_inertBodyStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 13,
					wordWrap = true,
					alignment = (TextAnchor)4
				};
				_inertBodyStyle.normal.textColor = new Color(0.92f, 0.92f, 0.92f);
				_inertBoxStyle = new GUIStyle(GUI.skin.box);
			}
		}

		private void InitializeFolders()
		{
			IOUtil.EnsureDirectoryExists(SpriteDumper.DumpPath);
			IOUtil.EnsureDirectoryExists(SpriteLoader.LoadPath);
			IOUtil.EnsureDirectoryExists(SpriteLoader.AtlasLoadPath);
			IOUtil.EnsureDirectoryExists(T2DDumper.DumpPath);
			IOUtil.EnsureDirectoryExists(Path.Combine(SpriteLoader.LoadPath, "T2D"));
			IOUtil.EnsureDirectoryExists(T2DLoader.AtlasLoadPath);
			IOUtil.EnsureDirectoryExists(AudioHandler.SoundFolder);
			IOUtil.EnsureDirectoryExists(VideoHandler.VideoLoadPath);
			IOUtil.EnsureDirectoryExists(DialogueHandler.TextDumpPath);
			IOUtil.EnsureDirectoryExists(DialogueHandler.TextLoadPath);
		}
	}
	public static class StitchworkApi
	{
		public const int ApiVersion = 1;

		private static bool _warnedNotReady;

		public static bool InstanceSkinsReady => false;

		public static int ApplyInstanceSkin(GameObject root, string skinId, Texture2D sheet)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(skinId) || (Object)(object)sheet == (Object)null)
			{
				return 0;
			}
			WarnNotReadyOnce();
			return 0;
		}

		public static int RemoveInstanceSkin(GameObject root)
		{
			_ = (Object)(object)root == (Object)null;
			return 0;
		}

		public static void ClearInstanceSkins()
		{
		}

		private static void WarnNotReadyOnce()
		{
			if (!_warnedNotReady)
			{
				_warnedNotReady = true;
				Plugin.Logger.LogWarning((object)"[StitchworkApi] ApplyInstanceSkin called, but the instance-skin mechanism is not implemented in this build (InstanceSkinsReady == false). The call is a safe no-op. This warning prints once per session.");
			}
		}
	}
	public sealed class StitchworkInstanceSkin : MonoBehaviour
	{
		public string SkinId;

		public Texture2D Sheet;

		public string SheetPath;
	}
	public class StitchworkConfig
	{
		private readonly ConfigEntry<bool> _DumpSprites;

		private readonly ConfigEntry<bool> _ConvertSpritesheets;

		private readonly ConfigEntry<bool> _ConvertOnlyChanged;

		private readonly ConfigEntry<KeyCode> _FullDumpKey;

		private readonly ConfigEntry<bool> _DumpText;

		private readonly ConfigEntry<double> _LogAudioDuration;

		private readonly ConfigEntry<bool> _HideModdedAudioInLog;

		private readonly ConfigEntry<KeyCode> _AnimationControllerPauseKey;

		private readonly ConfigEntry<KeyCode> _AnimationControllerNextFrameKey;

		private readonly ConfigEntry<KeyCode> _AnimationControllerPrevFrameKey;

		private readonly ConfigEntry<KeyCode> _AnimationControllerFreezeKey;

		private readonly ConfigEntry<KeyCode> _ShowPackManager;

		private readonly ConfigEntry<KeyCode> _DevHubDashboardKey;

		private readonly ConfigEntry<KeyCode> _DevHubGraphicsKey;

		private readonly ConfigEntry<KeyCode> _DevHubTextKey;

		private readonly ConfigEntry<KeyCode> _DevHubVideoKey;

		private readonly ConfigEntry<KeyCode> _DevHubAudioKey;

		private readonly ConfigEntry<KeyCode> _DevHubPerformanceKey;

		private readonly ConfigEntry<double> _TextLogDuration;

		private readonly ConfigEntry<int> _TextLogMaxVisible;

		private readonly ConfigEntry<int> _AudioLogMaxVisible;

		private readonly ConfigEntry<int> _GCEveryNScenes;

		private readonly ConfigEntry<int> _AnimCompileAlphaThreshold;

		private readonly ConfigEntry<int> _HeapReserveMB;

		private readonly ConfigEntry<bool> _DisableHeapThresholdBump;

		private readonly ConfigEntry<bool> _DropFileCacheBytesAfterReload;

		private readonly ConfigEntry<int> _HeapCaptureWindowSeconds;

		private readonly ConfigEntry<int> _GcStallCaptureThresholdMs;

		private readonly ConfigEntry<bool> _DisableUninitCheck;

		private readonly ConfigEntry<float> _UninitCheckCacheRefreshSeconds;

		private readonly ConfigEntry<bool> _ThoroughT2DEnrollment;

		private readonly ConfigEntry<bool> _DiagnosticMode;

		private readonly ConfigEntry<bool> _MatchOriginalColorSpace;

		private readonly ConfigEntry<bool> _LogTextureSwaps;

		private readonly ConfigEntry<int> _AudioCompressedInMemoryThresholdKB;

		private readonly ConfigEntry<bool> _SuppressLogDuringCinematics;

		private readonly ConfigEntry<bool> _SlicedSpriteReload;

		private readonly ConfigEntry<bool> _FontFallbackEnabled;

		private readonly ConfigEntry<bool> _VideoSkipFrameOnDrop;

		private readonly ConfigEntry<bool> _VideoSkipColorGrading;

		private readonly ConfigEntry<bool> _VideoAudioDirect;

		private readonly ConfigEntry<string> _GlobalPacksPath;

		private readonly ConfigEntry<float> _FontFallbackScale;

		private readonly ConfigEntry<int> _FontFallbackPointSize;

		private readonly ConfigEntry<bool> _FontFallbackBitmapMode;

		private readonly ConfigEntry<bool> _AutoEnableIncrementalGC;

		private readonly ConfigEntry<int> _IncrementalGCTimeSliceMs;

		private readonly ConfigEntry<bool> _EagerFocusReload;

		private readonly ConfigEntry<bool> _DevMode;

		private readonly ConfigEntry<string> _T2DDiagWatchName;

		private readonly ConfigEntry<bool> _EnableApplique;

		private readonly ConfigEntry<bool> _LogT2DLookupMisses;

		private readonly ConfigEntry<bool> _VerboseLogging;

		private readonly ConfigEntry<float> _PreviewBackdropOpacity;

		private readonly ConfigEntry<bool> _PreviewBackdropWhite;

		private readonly ConfigEntry<bool> _ShowStatusOverlay;

		private readonly ConfigEntry<string> _UILanguage;

		private readonly ConfigEntry<bool> _DisableCopyTextureFastPath;

		private readonly ConfigEntry<string> _TargetPackPath;

		private readonly ConfigEntry<bool> _UseCanvasPackManager;

		private readonly ConfigEntry<float> _DevHubX;

		private readonly ConfigEntry<float> _DevHubY;

		private readonly ConfigEntry<int> _DevHubTab;

		private readonly ConfigEntry<float> _PackManagerX;

		private readonly ConfigEntry<float> _PackManagerY;

		private readonly ConfigEntry<float> _CanvasPMX;

		private readonly ConfigEntry<float> _CanvasPMY;

		public bool DumpSprites
		{
			get
			{
				return _DumpSprites.Value;
			}
			set
			{
				_DumpSprites.Value = value;
			}
		}

		public bool ConvertSpritesheets => _ConvertSpritesheets.Value;

		public bool ConvertOnlyChanged
		{
			get
			{
				return _ConvertOnlyChanged.Value;
			}
			set
			{
				_ConvertOnlyChanged.Value = value;
			}
		}

		public KeyCode FullDumpKey => _FullDumpKey.Value;

		public bool DumpText
		{
			get
			{
				return _DumpText.Value;
			}
			set
			{
				_DumpText.Value = value;
			}
		}

		public double LogAudioDuration => _LogAudioDuration.Value;

		public bool HideModdedAudioInLog => _HideModdedAudioInLog.Value;

		public KeyCode AnimationControllerPauseKey => _AnimationControllerPauseKey.Value;

		public KeyCode AnimationControllerNextFrameKey => _AnimationControllerNextFrameKey.Value;

		public KeyCode AnimationControllerPrevFrameKey => _AnimationControllerPrevFrameKey.Value;

		public KeyCode AnimationControllerFreezeKey => _AnimationControllerFreezeKey.Value;

		public KeyCode ShowPackManagerKey => _ShowPackManager.Value;

		public KeyCode DevHubDashboardKey => _DevHubDashboardKey.Value;

		public KeyCode DevHubGraphicsKey => _DevHubGraphicsKey.Value;

		public KeyCode DevHubTextKey => _DevHubTextKey.Value;

		public KeyCode DevHubVideoKey => _DevHubVideoKey.Value;

		public KeyCode DevHubAudioKey => _DevHubAudioKey.Value;

		public KeyCode DevHubPerformanceKey => _DevHubPerformanceKey.Value;

		public double TextLogDuration => _TextLogDuration.Value;

		public int TextLogMaxVisible => _TextLogMaxVisible.Value;

		public int AudioLogMaxVisible => _AudioLogMaxVisible.Value;

		public int GCEveryNScenes => _GCEveryNScenes.Value;

		public int AnimCompileAlphaThreshold => _AnimCompileAlphaThreshold.Value;

		public int HeapReserveMB => _HeapReserveMB.Value;

		public bool DisableHeapThresholdBump => _DisableHeapThresholdBump.Value;

		public bool DropFileCacheBytesAfterReload => _DropFileCacheBytesAfterReload.Value;

		public int HeapCaptureWindowSeconds => _HeapCaptureWindowSeconds.Value;

		public int GcStallCaptureThresholdMs => _GcStallCaptureThresholdMs.Value;

		public bool DisableUninitCheck
		{
			get
			{
				return _DisableUninitCheck.Value;
			}
			set
			{
				_DisableUninitCheck.Value = value;
			}
		}

		public float UninitCheckCacheRefreshSeconds
		{
			get
			{
				return _UninitCheckCacheRefreshSeconds.Value;
			}
			set
			{
				_UninitCheckCacheRefreshSeconds.Value = value;
			}
		}

		public bool ThoroughT2DEnrollment
		{
			get
			{
				return _ThoroughT2DEnrollment.Value;
			}
			set
			{
				_ThoroughT2DEnrollment.Value = value;
			}
		}

		public bool DiagnosticMode => _DiagnosticMode.Value;

		public bool MatchOriginalColorSpace => _MatchOriginalColorSpace.Value;

		public bool LogTextureSwaps => _LogTextureSwaps.Value;

		public int AudioCompressedInMemoryThresholdKB => _AudioCompressedInMemoryThresholdKB.Value;

		public bool SuppressLogDuringCinematics => _SuppressLogDuringCinematics.Value;

		public bool SlicedSpriteReload => _SlicedSpriteReload.Value;

		public bool FontFallbackEnabled => _FontFallbackEnabled.Value;

		public bool VideoSkipFrameOnDrop => _VideoSkipFrameOnDrop.Value;

		public bool VideoSkipColorGrading => _VideoSkipColorGrading.Value;

		public bool VideoAudioDirect => _VideoAudioDirect.Value;

		public string GlobalPacksPath => _GlobalPacksPath.Value;

		public float FontFallbackScale => Mathf.Clamp(_FontFallbackScale.Value, 0.5f, 1.5f);

		public int FontFallbackPointSize => _FontFallbackPointSize.Value;

		public bool FontFallbackBitmapMode => _FontFallbackBitmapMode.Value;

		public bool AutoEnableIncrementalGC => _AutoEnableIncrementalGC.Value;

		public int IncrementalGCTimeSliceMs => _IncrementalGCTimeSliceMs.Value;

		public bool EagerFocusReload => _EagerFocusReload.Value;

		public bool DevMode => _DevMode.Value;

		public bool EnableApplique => _EnableApplique.Value;

		public string T2DDiagWatchName => _T2DDiagWatchName.Value;

		public bool LogT2DLookupMisses => _LogT2DLookupMisses.Value;

		public bool VerboseLogging => _VerboseLogging.Value;

		public float PreviewBackdropOpacity
		{
			get
			{
				return _PreviewBackdropOpacity.Value;
			}
			set
			{
				_PreviewBackdropOpacity.Value = value;
			}
		}

		public bool PreviewBackdropWhite
		{
			get
			{
				return _PreviewBackdropWhite.Value;
			}
			set
			{
				_PreviewBackdropWhite.Value = value;
			}
		}

		public bool ShowStatusOverlay
		{
			get
			{
				return _ShowStatusOverlay.Value;
			}
			set
			{
				_ShowStatusOverlay.Value = value;
			}
		}

		public string UILanguage
		{
			get
			{
				return _UILanguage.Value;
			}
			set
			{
				_UILanguage.Value = value;
			}
		}

		internal ConfigEntry<string> UILanguageEntry => _UILanguage;

		public bool DisableCopyTextureFastPath => _DisableCopyTextureFastPath.Value;

		public string TargetPackPath => _TargetPackPath.Value;

		internal ConfigEntry<string> TargetPackPathEntry => _TargetPackPath;

		public bool UseCanvasPackManager => _UseCanvasPackManager.Value;

		public float DevHubX
		{
			get
			{
				return _DevHubX.Value;
			}
			set
			{
				_DevHubX.Value = value;
			}
		}

		public float DevHubY
		{
			get
			{
				return _DevHubY.Value;
			}
			set
			{
				_DevHubY.Value = value;
			}
		}

		public int DevHubTab
		{
			get
			{
				return _DevHubTab.Value;
			}
			set
			{
				_DevHubTab.Value = value;
			}
		}

		public float PackManagerX
		{
			get
			{
				return _PackManagerX.Value;
			}
			set
			{
				_PackManagerX.Value = value;
			}
		}

		public float PackManagerY
		{
			get
			{
				return _PackManagerY.Value;
			}
			set
			{
				_PackManagerY.Value = value;
			}
		}

		public float CanvasPMX
		{
			get
			{
				return _CanvasPMX.Value;
			}
			set
			{
				_CanvasPMX.Value = value;
			}
		}

		public float CanvasPMY
		{
			get
			{
				return _CanvasPMY.Value;
			}
			set
			{
				_CanvasPMY.Value = value;
			}
		}

		public StitchworkConfig(ConfigFile config)
		{
			//IL_06bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c5: Expected O, but got Unknown
			_DisableCopyTextureFastPath = config.Bind<bool>("Diagnostics", "DisableCopyTextureFastPath", false, "Diagnostic. Forces atlas composites to use Graphics.DrawTexture instead of Graphics.CopyTexture, even when the GPU supports the fast path. Try this if sprite replacements are not visible (reported on macOS/Metal). Costs a little speed on large reloads; changes nothing visually when both paths work.");
			_TargetPackPath = config.Bind<string>("GUI", "TargetPackPath", "", "Push/Pull target pack folder path (set from the Dev Hub Dashboard; empty = none selected).");
			_LogAudioDuration = config.Bind<double>("GUI", "LogAudioDuration", 5.0, "Duration (in seconds) to keep audio log entries visible.");
			_HideModdedAudioInLog = config.Bind<bool>("GUI", "HideModdedAudioInLog", true, "Hide modded audio clips from the audio log.");
			_TextLogDuration = config.Bind<double>("GUI", "TextLogDuration", 10.0, "Duration (in seconds) for bumped log entries to fade out after leaving the visible slots.");
			_TextLogMaxVisible = config.Bind<int>("GUI", "TextLogMaxVisible", 15, "Number of latest text log entries always visible. Entries beyond this fade out over TextLogDuration seconds. (Range: 5-50)");
			_AudioLogMaxVisible = config.Bind<int>("GUI", "AudioLogMaxVisible", 15, "Number of latest audio log entries always visible. Entries beyond this fade out over LogAudioDuration seconds. (Range: 5-50)");
			_DumpSprites = config.Bind<bool>("Dumping", "DumpSprites", false, "Enable dumping of sprites");
			_AnimCompileAlphaThreshold = config.Bind<int>("Dumping", "AnimCompileAlphaThreshold", 16, "Alpha value (1-255) a canvas pixel must reach for Animation Canvas Compile to count it as art (classification AND crop bounds). The default 16 ignores stray editor residue. Lower it toward 1 when your art carries soft glow / bloom / haze, so the faint fringe survives the cut — and keep the canvas free of accidental faint pixels at low values.");
			_DumpText = config.Bind<bool>("Dumping", "DumpText", false, "Enable dumping of text when the game starts.");
			_ConvertSpritesheets = config.Bind<bool>("Dumping", "ConvertSpritesheets", false, "LEGACY auto mode: convert modded spritesheets to individual PNGs on every load. Prefer the Dev Hub Debug tab's 'Convert Sheets' button — explicit, overwrites stale output, and can skip frames identical to vanilla.");
			_ConvertOnlyChanged = config.Bind<bool>("Dumping", "ConvertOnlyChanged", true, "Sheet conversion (Debug tab button): only write sprites whose pixels differ from vanilla. Turns a full-sheet port into a minimal individual-sprite pack. Off = convert every sprite on the sheet.");
			_FullDumpKey = config.Bind<KeyCode>("Keybinds", "FullDumpKey", (KeyCode)0, "Optional key to start the full dump (loads every scene in the game). Default None — the Dev Hub Debug tab has the button, with a confirm step this key skips. Only fires when DumpSprites is enabled.");
			_ShowPackManager = config.Bind<KeyCode>("Keybinds", "ShowPackManager", (KeyCode)49, "Key to toggle the Pack Manager.");
			_DevHubDashboardKey = config.Bind<KeyCode>("Keybinds", "DevHubDashboard", (KeyCode)50, "Open Dev Hub at Dashboard tab (press again to close).");
			_DevHubGraphicsKey = config.Bind<KeyCode>("Keybinds", "DevHubGraphics", (KeyCode)51, "Open Dev Hub at Graphics tab (press again to close).");
			_DevHubTextKey = config.Bind<KeyCode>("Keybinds", "DevHubText", (KeyCode)52, "Open Dev Hub at Text tab (press again to close).");
			_DevHubVideoKey = config.Bind<KeyCode>("Keybinds", "DevHubVideo", (KeyCode)53, "Open Dev Hub at Video tab (press again to close).");
			_DevHubAudioKey = config.Bind<KeyCode>("Keybinds", "DevHubAudio", (KeyCode)54, "Open Dev Hub at Audio tab (press again to close).");
			_DevHubPerformanceKey = config.Bind<KeyCode>("Keybinds", "DevHubPerformance", (KeyCode)55, "Open Dev Hub at Performance tab (press again to close).");
			_AnimationControllerPauseKey = config.Bind<KeyCode>("Keybinds", "AnimationControllerPauseKey", (KeyCode)278, "Key to pause/unpause the selected animator in the animation controller.");
			_AnimationControllerNextFrameKey = config.Bind<KeyCode>("Keybinds", "AnimationControllerNextFrameKey", (KeyCode)280, "Key to advance one frame in the selected animator in the animation controller when paused.");
			_AnimationControllerPrevFrameKey = config.Bind<KeyCode>("Keybinds", "AnimationControllerPrevFrameKey", (KeyCode)277, "Key to go back one frame in the selected animator in the animation controller when paused.");
			_AnimationControllerFreezeKey = config.Bind<KeyCode>("Keybinds", "AnimationControllerFreezeKey", (KeyCode)279, "Key to freeze/unfreeze the object of the selected animator in the animation controller.");
			_GCEveryNScenes = config.Bind<int>("Dumping", "GCEveryNScenes", 10, "Run garbage collection every N scenes during full dump. Lower = more stable but slower.");
			_HeapReserveMB = config.Bind<int>("Performance", "HeapReserveMB", -1, "Mono heap reserve in MB. Pre-allocates this much memory at startup to raise the GC's high-water mark, reducing mid-gameplay stutter from heap-growth collections when custom asset packs are loaded. -1 = auto (40% of TC's heap threshold, capped at 512 MB). 0 = disabled.");
			_DisableHeapThresholdBump = config.Bind<bool>("Performance", "DisableHeapThresholdBump", false, "EXPERIMENTAL. When true, Stitchwork stops updating the game's GC heap threshold to account for our own retained caches. Collects fire more often but each is smaller and faster. Trade longer infrequent stutters for shorter frequent ones. Default false preserves the current threshold-bumping behaviour. Toggle live via Configuration Manager to compare.");
			_DropFileCacheBytesAfterReload = config.Bind<bool>("Performance", "DropFileCacheBytesAfterReload", false, "DIAGNOSTIC. Retained for heap-floor probe reports. Current main keeps FileCache bytes after reload unless a later build wires this flag into FileCache.EndCycle.");
			_HeapCaptureWindowSeconds = config.Bind<int>("Performance", "HeapCaptureWindowSeconds", 10, "Duration in seconds for the DevProfiler 'Capture Heap Window' diagnostic. The report samples Mono heap, Stitchwork cache buckets, GC events, and instrumented operation aggregates into BepInEx/plugins/Stitchwork/diagnostics.");
			_GcStallCaptureThresholdMs = config.Bind<int>("Performance", "GcStallCaptureThresholdMs", 50, "Frame-time threshold in milliseconds for the DevProfiler 'Arm GC Stall Capture' diagnostic. When armed, the profiler keeps a rolling pre-buffer and writes a gc-stall report after the next gen-max collect frame at or above this threshold.");
			_DisableUninitCheck = config.Bind<bool>("Performance", "DisableUninitCheck", false, "DIAGNOSTIC ABLATION. When true, skips the per-frame T2D uninitialized sprite sweep entirely. This can make late-spawned or pooled T2D sprites miss their replacement until another path catches them. Use only for short GC attribution tests.");
			_UninitCheckCacheRefreshSeconds = config.Bind<float>("Performance", "UninitCheckCacheRefreshSeconds", 0.3f, "DIAGNOSTIC. Real-time seconds between FindObjectsByType refreshes inside the T2D uninitialized sprite sweep. Uses unscaled time so uncapped rendering does not multiply discovery work. Lower values reduce discovery delay but increase allocation. Default 0.30 matches the successful diagnostic cadence.");
			_ThoroughT2DEnrollment = config.Bind<bool>("Performance", "ThoroughT2DEnrollment", false, "OPT-IN FIX for transient T2D sprites that lose their replacement (death cocoon, Warrior/Beast charge-slash, brief VFX). When true, the uninit sweep also scans INACTIVE renderers, so a pooled sprite is enrolled while still in the pool and kept correct from the moment it activates, instead of relying on the sweep catching its short active window. COST: the inactive scan is the heaviest allocation path and the enforced renderer set grows — leave OFF unless you actually hit the transient-revert issue. Pair with a lower UninitCheckCacheRefreshSeconds.");
			_DiagnosticMode = config.Bind<bool>("Experimental", "DiagnosticMode", false, "DIAGNOSTIC ONLY. When true, Stitchwork loads but applies NO Harmony patches and does NOT load any packs. The DevProfiler [Mem] log lines still fire so you can measure vanilla Silksong's baseline allocation rate without our hooks contributing. Compare against a normal session over the same gameplay to quantify Stitchwork's share. NOT for normal use — packs won't apply, replacements won't work, Dev Hub won't appear. Restart the game after toggling.");
			_MatchOriginalColorSpace = config.Bind<bool>("Experimental", "MatchOriginalColorSpace", false, "EXPERIMENTAL. Allocate atlas RenderTextures with sRGB / Linear read-write matching the original Texture2D's graphics format, rather than hard-coded Linear. Fixes washed-out / oversaturated replacements on configurations where the project color space is gamma and the vanilla texture is sRGB-flagged. Off by default until validated; restart after toggling.");
			_LogTextureSwaps = config.Bind<bool>("Experimental", "LogTextureSwaps", false, "DIAGNOSTIC. When true, every successful T2D texture swap is logged at LogInfo (default-visibility) instead of LogDebug, and every name-pattern denylist refusal emits a one-shot trace. Use to debug creator-pack issues. Default false; turn on temporarily when investigating a specific report.");
			_DevMode = config.Bind<bool>("Experimental", "DevMode", false, "Gates research / development tooling surfaces not intended for creators. Currently affects: the Graphics pillar's \"Materials\" sub-tab (material tint diagnostic + neutralizer PoC + ambient probe — research-grade tooling, see docs/material-tint-investigation.md). Default false; flip to true when investigating material tint or other diagnostic surfaces without finished UX.");
			_T2DDiagWatchName = config.Bind<string>("Experimental", "T2DDiagWatchName", "", "DIAGNOSTIC. Substring (case-insensitive) of a sprite/texture name to watch. When non-empty, Stitchwork periodically logs the full replacement state of matching renderers ([T2D-Diag] lines): enrolled-for-enforcement, sprite/texture fake-null, cached-replacement fake-null, and render path (sprite vs material/standalone). Built to pin the transparent death-cocoon failure — set to e.g. 'death_pieces', reproduce, read the log. Empty = off (zero cost).");
			_EnableApplique = config.Bind<bool>("Experimental", "EnableApplique", true, "Appliqué: per-clip sprite overrides via Sprites/<Collection>/Clips/<ClipName>/<Sprite>.png (art-on-rails — same frames/timing, per-clip pixels; docs/frame-decoupling-design.md). Zero cost when no such files exist. Disable to force every clip back to shared art.");
			_SlicedSpriteReload = config.Bind<bool>("Performance", "SlicedSpriteReload", true, "Spread sprite reloads (pack apply, hot reload) across frames with a progress bar, instead of freezing the game for the whole reload. The mixed state is brief: some collections show the new art a few frames before the rest. Turn OFF to restore the old single-frame synchronous reload (freezes, but atomic).");
			_SuppressLogDuringCinematics = config.Bind<bool>("Performance", "SuppressLogDuringCinematics", true, "Stop writing the log file while a cinematic video plays, and resume when it ends. Every log line is a synchronous disk write on the main thread; during video playback that competes with the video stream and starves the audio buffer, which is heard as choppy cinematic audio. Measured on an install whose other mods emit a per-frame shader error: 68% of all log lines in the playback window. Log lines from every mod are paused, not just Stitchwork's — the log records the gap and how many lines it covered. Turn OFF if you need a complete log across a cinematic (e.g. debugging a crash that happens during one).");
			_AudioCompressedInMemoryThresholdKB = config.Bind<int>("Performance", "AudioCompressedInMemoryThresholdKB", 1024, "Replacement audio files at or above this size (in KB) keep their compressed bytes in memory and decode during playback, instead of being fully decompressed to PCM when loaded. Prevents multi-gigabyte memory use (and crashes) with music-heavy sound packs — a 1 GB MP3 pack would otherwise decode to 5-10 GB. Small sound effects below the threshold stay fully decoded for zero-latency playback. 0 = always fully decompress (the pre-0709 behaviour).");
			_FontFallbackEnabled = config.Bind<bool>("Fonts", "FontFallbackEnabled", true, "Inject fallback fonts (from packs' or the root Fonts/_fallback/ folder, .ttf/.otf) into TextMeshPro's global fallback chain. Fixes 'tofu' box characters when replacement text uses characters the game's fonts don't cover (rare Chinese/Japanese characters, etc.). Additive only — the game's own fonts are never replaced, and glyphs they already cover keep their vanilla look.");
			_FontFallbackPointSize = config.Bind<int>("Fonts", "FontFallbackPointSize", 64, "Rasterization point size for baked fallback glyphs (24-128). Larger = crisper at big text sizes but a larger atlas texture.");
			_VideoSkipFrameOnDrop = config.Bind<bool>("Video", "VideoSkipFrameOnDrop", true, "Let cinematics drop video frames to stay in sync when the frame rate dips, instead of slowing playback (the vanilla setting) — slowed playback is heard as chopped audio. Applies to every cinematic, replaced or not. Turn OFF to restore vanilla never-drop behaviour (perfect frame delivery, audio pays for any hitch).");
			_VideoSkipColorGrading = config.Bind<bool>("Video", "VideoSkipColorGrading", true, "Replaced cinematics only: skip the game's colour-grade animation over the video and hold neutral curves, so your video shows as you authored it. Vanilla cinematics keep their grading. Turn OFF to let the game grade replacement videos too.");
			_VideoAudioDirect = config.Bind<bool>("Video", "VideoAudioDirect", false, "Replacement videos only: send the video's audio to Direct output instead of an AudioSource. Try ON if replaced cinematics still chop; some platforms produce no audio in Direct mode, hence default off.");
			_GlobalPacksPath = config.Bind<string>("Packs", "GlobalPacksPath", "", "Folder scanned for packs in addition to BepInEx/plugins. Empty = <GameRoot>/Packs, which every mod-manager profile shares (it hangs off the game install, not the profile). Drop packs there in their distributed shape (PackName/Stitchwork/...). Enable/disable state stays per profile. Set an absolute path to redirect (e.g. the save folder on macOS/Linux).");
			_FontFallbackScale = config.Bind<float>("Fonts", "FontFallbackScale", 1f, "Size multiplier for fallback-font glyphs relative to the game's own text (0.5-1.5). CJK fonts fill their em square edge-to-edge while the game's fonts leave headroom, so fallback glyphs can read slightly LARGE at 1.0 — try 0.9. Per-font override: a trailing @s tag on the font file name, e.g. 'myfont@s0.85.ttf'. Changes apply on the next font reload.");
			_FontFallbackScale.SettingChanged += delegate
			{
				FontFileWatcher.ReloadFonts = true;
			};
			_FontFallbackBitmapMode = config.Bind<bool>("Fonts", "FontFallbackBitmapMode", false, "Bake fallback glyphs as antialiased bitmap instead of SDF (signed distance field). Try this if fallback characters render with artifacts — bitmap is the guaranteed-correct mode, at the cost of slight softness at large text sizes.");
			_AutoEnableIncrementalGC = config.Bind<bool>("Performance", "AutoEnableIncrementalGC", true, "Default ON (FLAG-06). Stitchwork keeps the gc-max-time-slice line in the game's boot.config so Silksong boots with Unity's incremental garbage collector — the game's own GC manager then stands down and the periodic ~150 ms GC stutter disappears. Changes take effect on the NEXT game launch (a menu notice prompts the one-time restart). Survives Steam 'verify integrity' automatically (re-applied on the following launch). Set false to opt out; Stitchwork then removes the line and the game's default GC behaviour returns after a restart.");
			_IncrementalGCTimeSliceMs = config.Bind<int>("Experimental", "IncrementalGCTimeSliceMs", 0, "EXPERIMENTAL (FLAG-06). Override for the incremental GC time slice, in milliseconds, applied at startup when the player is running with incremental GC enabled (via the boot.config gc-max-time-slice key). 0 = leave the boot.config/engine value as-is. Larger slice = more GC progress per frame at higher per-frame cost; smaller = smoother frames but slower collection. If set while incremental GC is NOT active, Stitchwork logs a warning — usual cause: Steam 'verify integrity' restored boot.config and removed the gc-max-time-slice line.");
			_EagerFocusReload = config.Bind<bool>("Experimental", "EagerFocusReload", false, "Opt-in: re-stamp atlas RenderTextures on focus regain (alt-tab back into the game). Guards against GPU-side RT content being zeroed across focus changes on Steam Deck suspend/resume, exclusive-fullscreen alt-tab, fullscreen/resolution mode changes, or driver device-lost recovery. Default false because on Windows borderless fullscreen and modern macOS (the common case) RTs survive focus changes and this reload is a deterministic ~130-170 ms stall for no benefit. Turn on if you actually observe atlas-transparent rendering after a focus event.");
			_LogT2DLookupMisses = config.Bind<bool>("Experimental", "LogT2DLookupMisses", false, "DIAGNOSTIC. When true, dumps all _loadedSprites keys after preload, and logs every T2D sprite lookup that fails to find a replacement. Use to pinpoint discovery-vs-runtime key mismatches when a creator pack's individual sprite replacement isn't applying despite the file being on disk. Significant log noise — keep off in normal use. Restart the game after toggling.");
			_VerboseLogging = config.Bind<bool>("Logging", "VerboseLogging", false, "When true, Stitchwork's periodic-diagnostic chatter (DevProfiler memory/uninit heartbeat, per-GC [Mem-GC] lines under incremental GC, GC threshold bumps, sprite-expansion detail, per-cycle reload notices) is logged at info level. When false (default) it drops to debug level — hidden at BepInEx's default verbosity. One-shot/actionable lines and all warnings/errors are unaffected either way. Honored live (no restart).");
			_ShowStatusOverlay = config.Bind<bool>("GUI", "ShowStatusOverlay", true, "Show the HUD status badge in the bottom-left corner. Can also be toggled from the Pack Manager.");
			_UILanguage = config.Bind<string>("GUI", "UILanguage", "auto", new ConfigDescription("Language for Stitchwork's own UI (Pack Manager, status overlay, notices). 'auto' follows the game's language setting. Explicit codes load Lang/<code>.yml next to Stitchwork.dll — drop a new translation file in and it appears here after restart. Asset names, file paths, and log lines always stay English.", (AcceptableValueBase)(object)new AcceptableValueList<string>(Loc.DiscoverLanguages()), Array.Empty<object>()));
			_UseCanvasPackManager = config.Bind<bool>("GUI", "UseCanvasPackManager", true, "Use the Canvas-based Pack Manager. Default true — the Canvas manager is the primary UI surface as of 0509. Set false to fall back to the legacy IMGUI Pack Manager (kept for diagnostics and compatibility).");
			_PreviewBackdropOpacity = config.Bind<float>("GUI", "PreviewBackdropOpacity", 0.6f, "Opacity of the solid backdrop behind sprite/atlas previews in the Dev Hub (0 = transparent window surface, 1 = fully opaque). Adjustable live via the BG slider under the preview panes.");
			_PreviewBackdropWhite = config.Bind<bool>("GUI", "PreviewBackdropWhite", false, "Preview backdrop surface: false = black (bright art), true = white (dark or glow-heavy art). Toggled live by clicking the BG button next to the slider.");
			_DevHubX = config.Bind<float>("GUI", "DevHubX", 0f, "Dev Hub window X position (saved on exit).");
			_DevHubY = config.Bind<float>("GUI", "DevHubY", 0f, "Dev Hub window Y position (saved on exit).");
			_DevHubTab = config.Bind<int>("GUI", "DevHubTab", 0, "Last active Dev Hub tab index (0=Dashboard … 5=Performance).");
			_PackManagerX = config.Bind<float>("GUI", "PackManagerX", 0f, "Pack Manager window X position (saved on exit).");
			_PackManagerY = config.Bind<float>("GUI", "PackManagerY", 0f, "Pack Manager window Y position (saved on exit).");
			_CanvasPMX = config.Bind<float>("GUI", "CanvasPMX", 0f, "Canvas Pack Manager X position (saved on drag).");
			_CanvasPMY = config.Bind<float>("GUI", "CanvasPMY", 0f, "Canvas Pack Manager Y position (saved on drag).");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Stitchwork";

		public const string PLUGIN_NAME = "Stitchwork";

		public const string PLUGIN_VERSION = "0.8.6";
	}
}
namespace Stitchwork.Watchers
{
	public class AudioFileWatcher : IDisposable
	{
		public FileSystemWatcher AudioWatcher;

		public List<FileSystemWatcher> PackWatchers = new List<FileSystemWatcher>();

		public static volatile bool ReloadAudio;

		public AudioFileWatcher()
		{
			AudioWatcher = CreateWatcher(AudioHandler.SoundFolder);
			RebuildPackWatchers();
		}

		private FileSystemWatcher CreateWatcher(string path)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
			fileSystemWatcher.Path = path;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.Filter = "*.*";
			fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite;
			fileSystemWatcher.InternalBufferSize = 65536;
			fileSystemWatcher.Changed += OnAudioChanged;
			fileSystemWatcher.Created += OnAudioChanged;
			fileSystemWatcher.Deleted += OnAudioChanged;
			fileSystemWatcher.Renamed += OnAudioChanged;
			fileSystemWatcher.Error += delegate(object s, ErrorEventArgs e)
			{
				Plugin.Logger.LogWarning((object)("[AudioFileWatcher] Watcher buffer overflow (" + e.GetException()?.Message + ") — events lost; raising full audio reload."));
				ReloadAudio = true;
			};
			fileSystemWatcher.EnableRaisingEvents = true;
			return fileSystemWatcher;
		}

		public void RebuildPackWatchers()
		{
			foreach (FileSystemWatcher packWatcher in PackWatchers)
			{
				packWatcher.EnableRaisingEvents = false;
				packWatcher.Dispose();
			}
			PackWatchers.Clear();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				string path = Path.Combine(pluginPackPath, "Sounds");
				if (Directory.Exists(path))
				{
					PackWatchers.Add(CreateWatcher(path));
				}
			}
			Plugin.Logger.LogDebug((object)$"[AudioFileWatcher] Rebuilt pack watchers: {PackWatchers.Count} dir(s)");
		}

		public void Dispose()
		{
			AudioWatcher.EnableRaisingEvents = false;
			AudioWatcher.Dispose();
			foreach (FileSystemWatcher packWatcher in PackWatchers)
			{
				packWatcher.EnableRaisingEvents = false;
				packWatcher.Dispose();
			}
			PackWatchers.Clear();
		}

		private void OnAudioChanged(object sender, FileSystemEventArgs e)
		{
			Plugin.Logger.LogDebug((object)$"[FileWatcher] Audio file event: {e.ChangeType} — {e.FullPath}");
			ReloadToast.Record(ReloadToast.Kind.Audio, e.FullPath);
			ReloadAudio = true;
		}
	}
	public class FontFileWatcher : IDisposable
	{
		public FileSystemWatcher RootWatcher;

		public List<FileSystemWatcher> PackWatchers = new List<FileSystemWatcher>();

		public static volatile bool ReloadFonts;

		public FontFileWatcher()
		{
			string path = Path.Combine(Plugin.BasePath, "Fonts");
			Directory.CreateDirectory(path);
			RootWatcher = CreateWatcher(path);
			RebuildPackWatchers();
		}

		private FileSystemWatcher CreateWatcher(string path)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
			fileSystemWatcher.Path = path;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.Filter = "*.*";
			fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite;
			fileSystemWatcher.InternalBufferSize = 65536;
			fileSystemWatcher.Changed += OnFontChanged;
			fileSystemWatcher.Created += OnFontChanged;
			fileSystemWatcher.Deleted += OnFontChanged;
			fileSystemWatcher.Renamed += OnFontChanged;
			fileSystemWatcher.Error += delegate(object s, ErrorEventArgs e)
			{
				Plugin.Logger.LogWarning((object)("[FontFileWatcher] Watcher buffer overflow (" + e.GetException()?.Message + ") — raising font reload."));
				ReloadFonts = true;
			};
			fileSystemWatcher.EnableRaisingEvents = true;
			return fileSystemWatcher;
		}

		public void RebuildPackWatchers()
		{
			foreach (FileSystemWatcher packWatcher in PackWatchers)
			{
				packWatcher.EnableRaisingEvents = false;
				packWatcher.Dispose();
			}
			PackWatchers.Clear();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				string path = Path.Combine(pluginPackPath, "Fonts");
				if (Directory.Exists(path))
				{
					PackWatchers.Add(CreateWatcher(path));
				}
			}
			Plugin.Logger.LogDebug((object)$"[FontFileWatcher] Rebuilt pack watchers: {PackWatchers.Count} dir(s)");
		}

		public void Dispose()
		{
			RootWatcher.EnableRaisingEvents = false;
			RootWatcher.Dispose();
			foreach (FileSystemWatcher packWatcher in PackWatchers)
			{
				packWatcher.EnableRaisingEvents = false;
				packWatcher.Dispose();
			}
			PackWatchers.Clear();
		}

		private void OnFontChanged(object sender, FileSystemEventArgs e)
		{
			if (e.FullPath.EndsWith(".ttf", StringComparison.OrdinalIgnoreCase) || e.FullPath.EndsWith(".otf", StringComparison.OrdinalIgnoreCase))
			{
				Plugin.Logger.LogDebug((object)$"[FileWatcher] Font file event: {e.ChangeType} — {e.FullPath}");
				ReloadToast.Record(ReloadToast.Kind.Font, e.FullPath);
				ReloadFonts = true;
			}
		}
	}
	public class TextFileWatcher : IDisposable
	{
		public FileSystemWatcher TextWatcher;

		public List<FileSystemWatcher> PackWatchers = new List<FileSystemWatcher>();

		public static volatile bool ReloadText;

		public TextFileWatcher()
		{
			TextWatcher = CreateWatcher(DialogueHandler.TextLoadPath);
			RebuildPackWatchers();
		}

		private FileSystemWatcher CreateWatcher(string path)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
			fileSystemWatcher.Path = path;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.Filter = "*.yml";
			fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite;
			fileSystemWatcher.InternalBufferSize = 65536;
			fileSystemWatcher.Changed += OnTextChanged;
			fileSystemWatcher.Created += OnTextChanged;
			fileSystemWatcher.Deleted += OnTextChanged;
			fileSystemWatcher.Renamed += OnTextChanged;
			fileSystemWatcher.Error += delegate(object s, ErrorEventArgs e)
			{
				Plugin.Logger.LogWarning((object)("[TextFileWatcher] Watcher buffer overflow (" + e.GetException()?.Message + ") — events lost; raising full text reload."));
				ReloadText = true;
			};
			fileSystemWatcher.EnableRaisingEvents = true;
			return fileSystemWatcher;
		}

		public void RebuildPackWatchers()
		{
			foreach (FileSystemWatcher packWatcher in PackWatchers)
			{
				packWatcher.EnableRaisingEvents = false;
				packWatcher.Dispose();
			}
			PackWatchers.Clear();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				string path = Path.Combine(pluginPackPath, "Text");
				if (Directory.Exists(path))
				{
					PackWatchers.Add(CreateWatcher(path));
				}
			}
			Plugin.Logger.LogDebug((object)$"[TextFileWatcher] Rebuilt pack watchers: {PackWatchers.Count} dir(s)");
		}

		public void Dispose()
		{
			TextWatcher.EnableRaisingEvents = false;
			TextWatcher.Dispose();
			foreach (FileSystemWatcher packWatcher in PackWatchers)
			{
				packWatcher.EnableRaisingEvents = false;
				packWatcher.Dispose();
			}
			PackWatchers.Clear();
		}

		private void OnTextChanged(object sender, FileSystemEventArgs e)
		{
			Plugin.Logger.LogDebug((object)$"[FileWatcher] Text file event: {e.ChangeType} — {e.FullPath}");
			ReloadToast.Record(ReloadToast.Kind.Text, e.FullPath);
			ReloadText = true;
		}
	}
}
namespace Stitchwork.Util
{
	public static class ArchitectBridge
	{
		private static bool _init;

		private static FieldInfo _fiHasPreloaded;

		private static FieldInfo _fiIsLoading;

		private static bool _inEpisode;

		private static float _episodeStart;

		private static int _suppressedThisEpisode;

		private static bool _stuckReleased;

		private static bool _editProbed;

		private static Func<bool> _isEditing;

		public static bool BridgeAvailable
		{
			get
			{
				if (_fiHasPreloaded != null)
				{
					return _fiIsLoading != null;
				}
				return false;
			}
		}

		public static bool IsEditing
		{
			get
			{
				if (!_editProbed)
				{
					_editProbed = true;
					ResolveEditBridge();
				}
				if (_isEditing != null)
				{
					return _isEditing();
				}
				return false;
			}
		}

		private static void InitBridge()
		{
			if (_init)
			{
				return;
			}
			_init = true;
			Type type = AccessTools.TypeByName("Architect.Content.Preloads.PreloadManager");
			if (!(type == null))
			{
				_fiHasPreloaded = type.GetField("HasPreloaded", BindingFlags.Static | BindingFlags.Public);
				_fiIsLoading = type.GetField("IsLoading", BindingFlags.Static | BindingFlags.Public);
				if (BridgeAvailable)
				{
					Plugin.Logger.LogInfo((object)"[ArchitectBridge] Architect detected — LoadCollection will hold during its preload (mirror of Architect's own PatchworkFix, applied on our side).");
				}
				else
				{
					Plugin.Logger.LogWarning((object)"[ArchitectBridge] Architect detected but PreloadManager.HasPreloaded/IsLoading did not resolve (their internals moved?) — preload guard inactive. Vanilla captures during Architect preload are unguarded this session; see docs/architect-reference.md.");
				}
			}
		}

		public static bool ShouldSuppressLoadCollection()
		{
			if (!_init)
			{
				InitBridge();
			}
			if (!BridgeAvailable || _stuckReleased)
			{
				return false;
			}
			bool flag;
			try
			{
				flag = !(bool)_fiHasPreloaded.GetValue(null) || (bool)_fiIsLoading.GetValue(null);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[ArchitectBridge] PreloadManager read failed (" + ex.Message + ") — guard disabled for session."));
				_stuckReleased = true;
				return false;
			}
			if (flag)
			{
				if (!_inEpisode)
				{
					_inEpisode = true;
					_episodeStart = Time.realtimeSinceStartup;
					_suppressedThisEpisode = 0;
					Plugin.Logger.LogDebug((object)"[ArchitectBridge] Architect preloading — holding LoadCollection.");
				}
				else if (Time.realtimeSinceStartup - _episodeStart > 90f)
				{
					_stuckReleased = true;
					Plugin.Logger.LogWarning((object)"[ArchitectBridge] Architect has reported 'preloading' for >90 s — releasing the guard for this session so skins aren't suppressed indefinitely. If Architect's preload genuinely runs this long on this machine, report it to us.");
					return false;
				}
				_suppressedThisEpisode++;
				return true;
			}
			if (_inEpisode)
			{
				_inEpisode = false;
				if (_suppressedThisEpisode > 0)
				{
					Plugin.Logger.LogInfo((object)($"[ArchitectBridge] Architect preload finished — {_suppressedThisEpisode} suppressed " + "LoadCollection call(s); raising full tk2d reload to apply skins to them."));
					SpriteFileWatcher.ReloadSprites = true;
				}
			}
			return false;
		}

		private static void ResolveEditBridge()
		{
			Type type = AccessTools.TypeByName("Architect.Editor.EditManager");
			if (type == null)
			{
				return;
			}
			FieldInfo f = type.GetField("IsEditing", BindingFlags.Static | BindingFlags.Public);
			if (f == null || f.FieldType != typeof(bool))
			{
				Plugin.Logger.LogWarning((object)"[ArchitectBridge] Architect present but EditManager.IsEditing did not resolve — hotkey yield disabled.");
				return;
			}
			try
			{
				_isEditing = Expression.Lambda<Func<bool>>(Expression.Field(null, f), Array.Empty<ParameterExpression>()).Compile();
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[ArchitectBridge] EditManager accessor compile failed (" + ex.Message + "); using reflection fallback."));
				_isEditing = () => (bool)f.GetValue(null);
			}
			Plugin.Logger.LogInfo((object)"[ArchitectBridge] Architect detected — Stitchwork hotkeys yield while its editor is in edit mode.");
		}
	}
	public static class BootConfigGC
	{
		public enum Result
		{
			NoAction,
			KeyWritten,
			KeyRemoved,
			KeyIgnoredByPlayer,
			Unavailable
		}

		private const string Key = "gc-max-time-slice";

		private const string Line = "gc-max-time-slice=3";

		private static readonly string[] _bootConfigCandidates = new string[3]
		{
			"boot.config",
			Path.Combine("Resources", "Data", "boot.config"),
			Path.Combine("Data", "boot.config")
		};

		public static Result LastResult { get; private set; } = Result.NoAction;

		private static string BootConfigPath
		{
			get
			{
				string[] bootConfigCandidates = _bootConfigCandidates;
				foreach (string path in bootConfigCandidates)
				{
					string text = Path.Combine(Application.dataPath, path);
					if (File.Exists(text))
					{
						return text;
					}
				}
				return Path.Combine(Application.dataPath, _bootConfigCandidates[0]);
			}
		}

		private static string BootConfigCandidatesJoined => string.Join(", ", Array.ConvertAll(_bootConfigCandidates, (string rel) => Path.Combine(Application.dataPath, rel)));

		public static Result Sync(bool autoEnable)
		{
			LastResult = SyncInternal(autoEnable);
			return LastResult;
		}

		private static Result SyncInternal(bool autoEnable)
		{
			string bootConfigPath = BootConfigPath;
			bool isIncremental = GarbageCollector.isIncremental;
			try
			{
				if (!File.Exists(bootConfigPath))
				{
					if (autoEnable && !isIncremental)
					{
						Plugin.Logger.LogWarning((object)("[BootConfigGC] boot.config not found — cannot auto-enable incremental GC. Probed: " + BootConfigCandidatesJoined + ". See docs/architecture-review-2026-06.md FLAG-06."));
					}
					return Result.Unavailable;
				}
				List<string> list = new List<string>(File.ReadAllLines(bootConfigPath));
				bool flag = list.RemoveAll((string l) => l.TrimStart().StartsWith("gc-max-time-slice", StringComparison.Ordinal)) > 0;
				if (autoEnable)
				{
					if (isIncremental)
					{
						return Result.NoAction;
					}
					if (flag)
					{
						Plugin.Logger.LogWarning((object)"[BootConfigGC] gc-max-time-slice is present in boot.config but the player booted WITHOUT incremental GC — this build appears to ignore the key. No restart prompt will be shown; running under the TC-managed GC regime.");
						return Result.KeyIgnoredByPlayer;
					}
					string text = bootConfigPath + ".stitchwork-bak";
					if (!File.Exists(text))
					{
						File.Copy(bootConfigPath, text);
					}
					list.Add("gc-max-time-slice=3");
					File.WriteAllLines(bootConfigPath, list);
					Plugin.Logger.LogInfo((object)("[BootConfigGC] Appended 'gc-max-time-slice=3' to boot.config (backup: " + Path.GetFileName(text) + "). Incremental GC engages on the next game launch."));
					return Result.KeyWritten;
				}
				if (!flag)
				{
					return Result.NoAction;
				}
				File.WriteAllLines(bootConfigPath, list);
				Plugin.Logger.LogInfo((object)"[BootConfigGC] AutoEnableIncrementalGC=false — removed gc-max-time-slice from boot.config. Default GC behaviour returns on the next game launch.");
				return Result.KeyRemoved;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[BootConfigGC] Could not reconcile boot.config: " + ex.Message + ". Manual setup: add the line 'gc-max-time-slice=3' to boot.config next to the game data."));
				return Result.Unavailable;
			}
		}
	}
	public static class ConflictTracker
	{
		public struct Entry
		{
			public string Type;

			public string Key;

			public string WinnerPack;

			public string LoserPack;

			public string WinnerFile;

			public string LoserFile;

			public Entry(string type, string key, string winnerPack, string loserPack, string winnerFile = null, string loserFile = null)
			{
				Type = type;
				Key = key;
				WinnerPack = winnerPack;
				LoserPack = loserPack;
				WinnerFile = winnerFile;
				LoserFile = loserFile;
			}
		}

		private static readonly List<Entry> _entries = new List<Entry>();

		public static IReadOnlyList<Entry> All => _entries;

		public static int Total => _entries.Count;

		public static void Clear()
		{
			_entries.Clear();
		}

		public static void ClearTypes(params string[] types)
		{
			_entries.RemoveAll((Entry e) => Array.IndexOf(types, e.Type) >= 0);
		}

		public static void Record(string type, string key, string winnerPack, string loserPack, string sameSourceDetail = null, string winnerFile = null, string loserFile = null)
		{
			if (sameSourceDetail != null && string.Equals(winnerPack, loserPack, StringComparison.OrdinalIgnoreCase))
			{
				key = key + "  (" + sameSourceDetail + ")";
			}
			_entries.Add(new Entry(type, key, winnerPack, loserPack, winnerFile, loserFile));
		}

		public static int ShadowedCount(string packPath)
		{
			return _entries.Count((Entry e) => string.Equals(e.LoserPack, packPath, StringComparison.OrdinalIgnoreCase));
		}
	}
	public static class FileCache
	{
		private static readonly Dictionary<string, (DateTime ModTime, byte[] Data)> _cache = new Dictionary<string, (DateTime, byte[])>(StringComparer.OrdinalIgnoreCase);

		private static bool _inCycle;

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

		public static int Count => _cache.Count;

		public static long TotalBytes
		{
			get
			{
				long num = 0L;
				foreach (KeyValuePair<string, (DateTime, byte[])> item in _cache)
				{
					if (item.Value.Item2 != null)
					{
						num += item.Value.Item2.Length;
					}
				}
				return num;
			}
		}

		public static void BeginCycle()
		{
			_readThisCycle.Clear();
			_inCycle = true;
		}

		public static void EndCycle()
		{
			_inCycle = false;
		}

		public static byte[] ReadBytes(string path)
		{
			try
			{
				if (_inCycle && _readThisCycle.Contains(path) && _cache.TryGetValue(path, out (DateTime, byte[]) value))
				{
					return value.Item2;
				}
				DateTime lastWriteTimeUtc = File.GetLastWriteTimeUtc(path);
				if (_cache.TryGetValue(path, out (DateTime, byte[]) value2) && value2.Item1 == lastWriteTimeUtc)
				{
					if (_inCycle)
					{
						_readThisCycle.Add(path);
					}
					return value2.Item2;
				}
				byte[] array = File.ReadAllBytes(IOUtil.LongSafe(path));
				_cache[path] = (lastWriteTimeUtc, array);
				if (_inCycle)
				{
					_readThisCycle.Add(path);
				}
				return array;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[FileCache] Could not read '" + path + "': " + ex.Message));
				return null;
			}
		}

		public static void Clear()
		{
			_cache.Clear();
			_readThisCycle.Clear();
		}
	}
	public static class GameBridge
	{
		public static readonly bool IsHK1 = string.Equals(Paths.ProcessName, "hollow_knight", StringComparison.OrdinalIgnoreCase);

		private static bool _bridgeInit;

		private static Type _gmType;

		private static PropertyInfo _gmInstanceProp;

		private static MethodInfo _gmBeginSceneTransition;

		private static MethodInfo _gmGetSceneNameString;

		private static FieldInfo _gmEntryGateNameField;

		private static MethodInfo _gmIsGamePaused;

		private static MethodInfo _gmPauseGameToggle;

		private static MethodInfo _gmReturnToMenuNoSave;

		private static MethodInfo _gmDoEmergencyQuit;

		private static MethodInfo _gmReturnToMenuCoroutine;

		private static Type _gmRtmSaveModesType;

		private static Type _sliType;

		private static FieldInfo _sliSceneName;

		private static FieldInfo _sliEntryGateName;

		private static FieldInfo _sliIsFirstLevel;

		private static FieldInfo _sliAlwaysUnloadUnusedAssets;

		private static Type _hcType;

		private static PropertyInfo _hcInstanceProp;

		private static MethodInfo _hcHazardRespawn;

		private static FieldInfo _hcIsInvincible;

		private static Type _coreLoopType;

		private static MethodInfo _clInvokeNext;

		private static MethodInfo _clInvokeOnGameThread;

		private static readonly string[] MenuSceneTokens = new string[3] { "menu", "title", "mode_select" };

		public static bool CanReloadScene
		{
			get
			{
				if (_gmInstanceProp != null && _gmBeginSceneTransition != null)
				{
					return _sliType != null;
				}
				return false;
			}
		}

		public static bool IsGameManagerLive
		{
			get
			{
				if (_gmInstanceProp == null)
				{
					return false;
				}
				try
				{
					return _gmInstanceProp.GetValue(null) != null;
				}
				catch
				{
					return false;
				}
			}
		}

		public static bool IsInMenuScene
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (string.IsNullOrEmpty(name))
				{
					return false;
				}
				string[] menuSceneTokens = MenuSceneTokens;
				foreach (string value in menuSceneTokens)
				{
					if (name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
				return false;
			}
		}

		public static bool IsInGameScene
		{
			get
			{
				if (IsGameManagerLive)
				{
					return !IsInMenuScene;
				}
				return false;
			}
		}

		public static bool CanHazardRespawn
		{
			get
			{
				if (_hcInstanceProp != null)
				{
					return _hcHazardRespawn != null;
				}
				return false;
			}
		}

		public static bool CanInvokeNext
		{
			get
			{
				if (_clInvokeNext != null)
				{
					return _clInvokeOnGameThread != null;
				}
				return false;
			}
		}

		public static void InitBridge()
		{
			if (_bridgeInit)
			{
				return;
			}
			_bridgeInit = true;
			_gmType = Type.GetType("GameManager, Assembly-CSharp");
			if (_gmType != null)
			{
				_gmInstanceProp = _gmType.GetProperty("instance", BindingFlags.Static | BindingFlags.Public);
				_gmBeginSceneTransition = _gmType.GetMethod("BeginSceneTransition", BindingFlags.Instance | BindingFlags.Public);
				_gmGetSceneNameString = _gmType.GetMethod("GetSceneNameString", BindingFlags.Instance | BindingFlags.Public);
				_gmEntryGateNameField = _gmType.GetField("entryGateName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_gmIsGamePaused = _gmType.GetMethod("IsGamePaused", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
				_gmPauseGameToggle = _gmType.GetMethod("PauseGameToggle", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(bool) }, null);
				_gmReturnToMenuNoSave = _gmType.GetMethod("ReturnToMainMenuNoSave", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
				_gmDoEmergencyQuit = _gmType.GetMethod("DoEmergencyQuit", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
				_gmRtmSaveModesType = _gmType.GetNestedType("ReturnToMainMenuSaveModes", BindingFlags.Public);
				if (_gmRtmSaveModesType != null)
				{
					_gmReturnToMenuCoroutine = _gmType.GetMethod("ReturnToMainMenu", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
					{
						_gmRtmSaveModesType,
						typeof(Action<bool>)
					}, null);
				}
			}
			_sliType = _gmType?.GetNestedType("SceneLoadInfo", BindingFlags.Public);
			if (_sliType != null)
			{
				_sliSceneName = _sliType.GetField("SceneName");
				_sliEntryGateName = _sliType.GetField("EntryGateName");
				_sliIsFirstLevel = _sliType.GetField("IsFirstLevelForPlayer");
				_sliAlwaysUnloadUnusedAssets = _sliType.GetField("AlwaysUnloadUnusedAssets");
			}
			_hcType = Type.GetType("HeroController, Assembly-CSharp");
			if (_hcType != null)
			{
				_hcInstanceProp = _hcType.GetProperty("instance", BindingFlags.Static | BindingFlags.Public);
				_hcHazardRespawn = _hcType.GetMethod("HazardRespawn", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
				_hcIsInvincible = _hcType.GetField("isInvincible", BindingFlags.Instance | BindingFlags.Public);
			}
			_coreLoopType = Type.GetType("CoreLoop, Assembly-CSharp");
			if (_coreLoopType != null)
			{
				_clInvokeNext = _coreLoopType.GetMethod("InvokeNext", BindingFlags.Static | BindingFlags.Public);
				_clInvokeOnGameThread = _coreLoopType.GetMethod("InvokeOnGameThread", BindingFlags.Static | BindingFlags.Public);
			}
			if (!CanReloadScene)
			{
				Plugin.Logger.LogWarning((object)("[GameBridge] Scene-reload handles did not fully resolve. " + $"gmType={_gmType != null}, instance={_gmInstanceProp != null}, " + $"begin={_gmBeginSceneTransition != null}, sli={_sliType != null}"));
			}
			if (!CanHazardRespawn)
			{
				Plugin.Logger.LogWarning((object)("[GameBridge] HazardRespawn handles did not fully resolve. " + $"hcType={_hcType != null}, instance={_hcInstanceProp != null}, " + $"hazard={_hcHazardRespawn != null}"));
			}
			if (!CanInvokeNext)
			{
				Plugin.Logger.LogWarning((object)("[GameBridge] CoreLoop handles did not fully resolve. " + $"clType={_coreLoopType != null}, invokeNext={_clInvokeNext != null}, " + $"invokeOnGameThread={_clInvokeOnGameThread != null}. " + "InvokeNext / InvokeOnGameThread will fall back to inline execution."));
			}
		}

		public static bool ReturnToMainMenuNoSave()
		{
			object obj = _gmInstanceProp?.GetValue(null);
			if (obj == null)
			{
				Plugin.Logger.LogWarning((object)"[GameBridge] ReturnToMainMenuNoSave: GameManager.instance is null.");
				return false;
			}
			if (_gmReturnToMenuNoSave != null)
			{
				_gmReturnToMenuNoSave.Invoke(obj, null);
				Plugin.Logger.LogInfo((object)"[GameBridge] ReturnToMainMenuNoSave dispatched.");
				return true;
			}
			if (_gmDoEmergencyQuit != null)
			{
				_gmDoEmergencyQuit.Invoke(obj, null);
				Plugin.Logger.LogWarning((object)"[GameBridge] ReturnToMainMenuNoSave handle missing — dispatched DoEmergencyQuit instead.");
				return true;
			}
			if (_gmReturnToMenuCoroutine != null && _gmRtmSaveModesType != null)
			{
				MonoBehaviour val = (MonoBehaviour)((obj is MonoBehaviour) ? obj : null);
				if (val != null && Array.IndexOf(Enum.GetNames(_gmRtmSaveModesType), "DontSave") >= 0)
				{
					object obj2 = Enum.Parse(_gmRtmSaveModesType, "DontSave");
					if (_gmReturnToMenuCoroutine.Invoke(obj, new object[2] { obj2, null }) is IEnumerator enumerator)
					{
						val.StartCoroutine(enumerator);
						Plugin.Logger.LogInfo((object)"[GameBridge] ReturnToMainMenu(DontSave) coroutine dispatched (HK1 shape).");
						return true;
					}
				}
			}
			Plugin.Logger.LogWarning((object)"[GameBridge] No main-menu return handle resolved.");
			return false;
		}

		public static bool SetHeroInvincible(bool on)
		{
			if (_hcIsInvincible == null || _hcInstanceProp == null)
			{
				return false;
			}
			object value = _hcInstanceProp.GetValue(null);
			if (value == null)
			{
				return false;
			}
			_hcIsInvincible.SetValue(value, on);
			return true;
		}

		public static bool TriggerSceneReloadCurrent()
		{
			if (!CanReloadScene)
			{
				Plugin.Logger.LogWarning((object)"[GameBridge] TriggerSceneReloadCurrent: bridge unavailable, skipping.");
				return false;
			}
			object value = _gmInstanceProp.GetValue(null);
			if (value == null)
			{
				Plugin.Logger.LogWarning((object)"[GameBridge] TriggerSceneReloadCurrent: GameManager.instance is null.");
				return false;
			}
			if (_gmIsGamePaused != null)
			{
				bool flag = false;
				try
				{
					flag = (bool)_gmIsGamePaused.Invoke(value, null);
				}
				catch (Exception)
				{
				}
				if (flag)
				{
					Time.timeScale = 1f;
					Plugin.Logger.LogInfo((object)"[GameBridge] Game was paused — forced Time.timeScale = 1 so the scene-transition coroutine can tick. Dispatching PauseGameToggle(false) for UI/hero/audio cleanup.");
					if (_gmPauseGameToggle != null)
					{
						MonoBehaviour val = (MonoBehaviour)((value is MonoBehaviour) ? value : null);
						if (val != null)
						{
							try
							{
								IEnumerator enumerator = (IEnumerator)_gmPauseGameToggle.Invoke(value, new object[1] { false });
								if (enumerator != null)
								{
									val.StartCoroutine(enumerator);
								}
							}
							catch (Exception ex2)
							{
								Plugin.Logger.LogWarning((object)($"[GameBridge] PauseGameToggle(false) threw: {(ex2 as TargetInvocationException)?.InnerException ?? ex2}. " + "Proceeding with timeScale override only — scene reload will clean up residual pause UI."));
							}
						}
					}
				}
			}
			string text = ((_gmGetSceneNameString != null) ? ((string)_gmGetSceneNameString.Invoke(value, null)) : null);
			string text2 = ((_gmEntryGateNameField != null) ? ((string)_gmEntryGateNameField.GetValue(value)) : null);
			if (string.IsNullOrEmpty(text))
			{
				Plugin.Logger.LogWarning((object)"[GameBridge] TriggerSceneReloadCurrent: scene name is empty, aborting.");
				return false;
			}
			object obj;
			try
			{
				obj = Activator.CreateInstance(_sliType);
			}
			catch (Exception ex3)
			{
				Plugin.Logger.LogWarning((object)$"[GameBridge] Could not construct SceneLoadInfo: {(ex3 as TargetInvocationException)?.InnerException ?? ex3}");
				return false;
			}
			_sliSceneName?.SetValue(obj, text);
			_sliEntryGateName?.SetValue(obj, text2 ?? "");
			_sliIsFirstLevel?.SetValue(obj, false);
			_sliAlwaysUnloadUnusedAssets?.SetValue(obj, true);
			try
			{
				_gmBeginSceneTransition.Invoke(value, new object[1] { obj });
				Plugin.Logger.LogInfo((object)("[GameBridge] Scene reload dispatched: '" + text + "' via gate '" + (text2 ?? string.Empty) + "'"));
				return true;
			}
			catch (Exception ex4)
			{
				Plugin.Logger.LogWarning((object)$"[GameBridge] BeginSceneTransition threw: {(ex4 as TargetInvocationException)?.InnerException ?? ex4}");
				return false;
			}
		}

		public static void InvokeNext(Action action)
		{
			if (action == null)
			{
				return;
			}
			if (_clInvokeNext == null)
			{
				action();
				return;
			}
			try
			{
				_clInvokeNext.Invoke(null, new object[1] { action });
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)$"[GameBridge] CoreLoop.InvokeNext threw: {(ex as TargetInvocationException)?.InnerException ?? ex}. Running inline.");
				action();
			}
		}

		public static void InvokeOnGameThread(Action action)
		{
			if (action == null)
			{
				return;
			}
			if (_clInvokeOnGameThread == null)
			{
				action();
				return;
			}
			try
			{
				_clInvokeOnGameThread.Invoke(null, new object[1] { action });
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)$"[GameBridge] CoreLoop.InvokeOnGameThread threw: {(ex as TargetInvocationException)?.InnerException ?? ex}. Running inline.");
				action();
			}
		}

		public static bool TryTriggerHazardRespawn()
		{
			if (!CanHazardRespawn)
			{
				Plugin.Logger.LogWarning((object)"[GameBridge] TryTriggerHazardRespawn: bridge unavailable.");
				return false;
			}
			object value = _hcInstanceProp.GetValue(null);
			MonoBehaviour val = (MonoBehaviour)((value is MonoBehaviour) ? value : null);
			if (val == null)
			{
				Plugin.Logger.LogWarning((object)"[GameBridge] HeroController.instance is null or not a MonoBehaviour.");
				return false;
			}
			IEnumerator enumerator;
			try
			{
				enumerator = (IEnumerator)_hcHazardRespawn.Invoke(value, null);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)$"[GameBridge] HazardRespawn threw: {(ex as TargetInvocationException)?.InnerException ?? ex}");
				return false;
			}
			if (enumerator == null)
			{
				return false;
			}
			val.StartCoroutine(enumerator);
			return true;
		}
	}
	public static class GCUtil
	{
		private static bool _bridgeInit;

		private static MethodInfo _miMonoUsed;

		private static MethodInfo _miMonoTotal;

		private static MethodInfo _miMemUsed;

		private static MethodInfo _miMemTotal;

		private static PropertyInfo _piThreshold;

		private static MethodInfo _piThresholdSetter;

		private static MethodInfo _miGmCollect;

		private static MethodInfo _miGmForceCollect;

		private static MethodInfo _miAmpIncrease;

		private static MethodInfo _miAmpDecrease;

		private static MethodInfo _miAmpClear;

		private static PropertyInfo _piAmpAllocated;

		private static PropertyInfo _piAmpFreeBytes;

		private static double _lastBumpMB;

		public static long TCMonoHeapUsed
		{
			get
			{
				if (!(_miMonoUsed != null))
				{
					return GC.GetTotalMemory(forceFullCollection: false);
				}
				return InvokeLong(_miMonoUsed);
			}
		}

		public static long TCMonoHeapTotal => InvokeLong(_miMonoTotal);

		public static long TCMemUsed => InvokeLong(_miMemUsed);

		public static long TCMemTotal => InvokeLong(_miMemTotal);

		public static double TCHeapThresholdMB
		{
			get
			{
				if (!(_piThreshold != null))
				{
					return 0.0;
				}
				return (double)_piThreshold.GetValue(null);
			}
		}

		public static bool BridgeAvailable => _miMonoUsed != null;

		public static bool IsIncrementalMode => GarbageCollector.isIncremental;

		public static double HeapPressure
		{
			get
			{
				double tCHeapThresholdMB = TCHeapThresholdMB;
				if (tCHeapThresholdMB <= 0.0)
				{
					return 0.0;
				}
				return (double)TCMonoHeapUsed / 1048576.0 / tCHeapThresholdMB;
			}
		}

		public static bool AmpBridgeAvailable => _miAmpIncrease != null;

		public static long AmpAllocatedBytes
		{
			get
			{
				if (!(_piAmpAllocated != null))
				{
					return 0L;
				}
				return (long)_piAmpAllocated.GetValue(null);
			}
		}

		public static long AmpFreeBytes
		{
			get
			{
				if (!(_piAmpFreeBytes != null))
				{
					return 0L;
				}
				return (long)_piAmpFreeBytes.GetValue(null);
			}
		}

		public static event Action OnTCGCStutter;

		public static void InitBridge()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (_bridgeInit)
			{
				return;
			}
			_bridgeInit = true;
			Type type = Type.GetType("GCManager, Assembly-CSharp");
			Plugin.Logger.LogInfo((object)("[GCUtil] GC fingerprint: " + $"isIncremental={GarbageCollector.isIncremental}, " + $"GCMode={GarbageCollector.GCMode}" + (GarbageCollector.isIncremental ? $", timeSliceNs={GarbageCollector.incrementalTimeSliceNanoseconds}" : "") + $", gcManagerInstances={((type != null) ? Resources.FindObjectsOfTypeAll(type).Length : (-1))}"));
			int num = Plugin.Config?.IncrementalGCTimeSliceMs ?? 0;
			if (num > 0)
			{
				if (GarbageCollector.isIncremental)
				{
					GarbageCollector.incrementalTimeSliceNanoseconds = (ulong)num * 1000000uL;
					Plugin.Logger.LogInfo((object)$"[GCUtil] Incremental GC time slice set to {num} ms (config override)");
				}
				else if (BootConfigGC.LastResult != BootConfigGC.Result.KeyWritten)
				{
					Plugin.Logger.LogWarning((object)"[GCUtil] IncrementalGCTimeSliceMs is set but incremental GC is NOT active. boot.config has likely lost its gc-max-time-slice line (Steam verify-files restores boot.config). Re-add the line — or leave AutoEnableIncrementalGC on and it self-heals next launch.");
				}
			}
			if (type == null)
			{
				return;
			}
			_miMonoUsed = type.GetMethod("GetMonoHeapUsage", BindingFlags.Static | BindingFlags.Public);
			_miMonoTotal = type.GetMethod("GetMonoHeapTotal", BindingFlags.Static | BindingFlags.Public);
			_miMemUsed = type.GetMethod("GetMemoryUsage", BindingFlags.Static | BindingFlags.Public);
			_miMemTotal = type.GetMethod("GetMemoryTotal", BindingFlags.Static | BindingFlags.Public);
			_piThreshold = type.GetProperty("HeapUsageThreshold", BindingFlags.Static | BindingFlags.Public);
			_miGmCollect = type.GetMethod("Collect", BindingFlags.Static | BindingFlags.Public, null, Type.EmptyTypes, null);
			_miGmForceCollect = type.GetMethod("ForceCollect", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
			{
				typeof(bool),
				typeof(bool)
			}, null);
			FieldInfo field = type.GetField("OnGCStutter", BindingFlags.Static | BindingFlags.NonPublic);
			if (field != null)
			{
				Action b = delegate
				{
					GCUtil.OnTCGCStutter?.Invoke();
				};
				Action a = (Action)field.GetValue(null);
				field.SetValue(null, Delegate.Combine(a, b));
			}
			_piThresholdSetter = _piThreshold?.GetSetMethod(nonPublic: true);
			Type type2 = Type.GetType("GCArtificialMemoryPressure, Assembly-CSharp");
			if (type2 != null)
			{
				_miAmpIncrease = type2.GetMethod("IncreaseGCPressure", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(float) }, null);
				_miAmpDecrease = type2.GetMethod("DecreaseGCPressure", BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(float) }, null);
				_miAmpClear = type2.GetMethod("ClearAllocatedMemory", BindingFlags.Static | BindingFlags.Public);
				_piAmpAllocated = type2.GetProperty("AllocatedBytes", BindingFlags.Static | BindingFlags.Public);
				_piAmpFreeBytes = type2.GetProperty("FreeBytesCount", BindingFlags.Static | BindingFlags.Public);
			}
			BumpThresholdForStitchwork();
		}

		public static void BumpThresholdForStitchwork()
		{
			if (_piThresholdSetter == null || IsIncrementalMode)
			{
				return;
			}
			StitchworkConfig config = Plugin.Config;
			if (config != null && config.DisableHeapThresholdBump)
			{
				if (_lastBumpMB != 0.0)
				{
					double tCHeapThresholdMB = TCHeapThresholdMB;
					double num = tCHeapThresholdMB - _lastBumpMB;
					_piThresholdSetter.Invoke(null, new object[1] { num });
					Log.Verbose("[GCUtil] DisableHeapThresholdBump=true — reverting our bump: " + $"{tCHeapThresholdMB:F0}MB → {num:F0}MB");
					_lastBumpMB = 0.0;
				}
				return;
			}
			double num2 = (double)(T2DLoader.OriginalTextureDataBytes + FileCache.TotalBytes) / 1048576.0;
			double num3 = num2 - _lastBumpMB;
			if (!(Math.Abs(num3) < 1.0))
			{
				double tCHeapThresholdMB2 = TCHeapThresholdMB;
				double num4 = tCHeapThresholdMB2 + num3;
				_piThresholdSetter.Invoke(null, new object[1] { num4 });
				Log.Verbose("[GCUtil] TC heap threshold " + ((num3 > 0.0) ? "raised" : "lowered") + " " + $"{tCHeapThresholdMB2:F0}MB → {num4:F0}MB  (Stitchwork caches: {num2:F0}MB)");
				_lastBumpMB = num2;
			}
		}

		private static long InvokeLong(MethodInfo mi)
		{
			if (!(mi != null))
			{
				return -1L;
			}
			return (long)mi.Invoke(null, null);
		}

		public static void PrewarmHeap(long bytes)
		{
			if (bytes > 0)
			{
				long num = bytes;
				while (num > 0)
				{
					int num2 = (int)Math.Min(num, 536870912L);
					GC.KeepAlive(new byte[num2]);
					num -= num2;
				}
				ForceCollect();
			}
		}

		public static int SuggestReserveMB()
		{
			int systemMemorySize = SystemInfo.systemMemorySize;
			return (int)Math.Clamp(Math.Clamp(0.12102111566341002 * (double)systemMemorySize, 384.0, 1024.0) * 0.4, 64.0, 512.0);
		}

		public static void ForceCollect()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (_miGmCollect != null)
			{
				_miGmCollect.Invoke(null, null);
				return;
			}
			Mode gCMode = GarbageCollector.GCMode;
			GarbageCollector.GCMode = (Mode)1;
			GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, blocking: true);
			GC.WaitForPendingFinalizers();
			GarbageCollector.GCMode = gCMode;
		}

		public static void IncreasePressure(float t)
		{
			if (!(_miAmpIncrease == null))
			{
				_miAmpIncrease.Invoke(null, new object[1] { Mathf.Clamp01(t) });
			}
		}

		public static void DecreasePressure(float t)
		{
			if (!(_miAmpDecrease == null))
			{
				_miAmpDecrease.Invoke(null, new object[1] { Mathf.Clamp01(t) });
			}
		}

		public static void ClearPressure()
		{
			if (!(_miAmpClear == null))
			{
				_miAmpClear.Invoke(null, null);
			}
		}
	}
	internal static class GifEncoder
	{
		private const int TransparentIndex = 255;

		private const int PaletteSize = 255;

		public static void Write(string path, int width, int height, List<Color32[]> frames, int delayCs)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			if (frames == null || frames.Count == 0)
			{
				throw new ArgumentException("no frames");
			}
			List<Color32> list = BuildPalette(frames);
			Dictionary<int, byte> cache = new Dictionary<int, byte>();
			using FileStream output = new FileStream(IOUtil.LongSafe(path), FileMode.Create, FileAccess.Write);
			using BinaryWriter binaryWriter = new BinaryWriter(output);
			binaryWriter.Write(Encoding.ASCII.GetBytes("GIF89a"));
			binaryWriter.Write((ushort)width);
			binaryWriter.Write((ushort)height);
			binaryWriter.Write((byte)247);
			binaryWriter.Write(byte.MaxValue);
			binaryWriter.Write((byte)0);
			for (int i = 0; i < 256; i++)
			{
				Color32 val = (Color32)((i < list.Count) ? list[i] : new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue));
				binaryWriter.Write(val.r);
				binaryWriter.Write(val.g);
				binaryWriter.Write(val.b);
			}
			binaryWriter.Write(new byte[3] { 33, 255, 11 });
			binaryWriter.Write(Encoding.ASCII.GetBytes("NETSCAPE2.0"));
			binaryWriter.Write(new byte[5] { 3, 1, 0, 0, 0 });
			byte[] array = new byte[width * height];
			foreach (Color32[] frame in frames)
			{
				binaryWriter.Write(new byte[4] { 33, 249, 4, 9 });
				binaryWriter.Write((ushort)Mathf.Max(2, delayCs));
				binaryWriter.Write(byte.MaxValue);
				binaryWriter.Write((byte)0);
				binaryWriter.Write((byte)44);
				binaryWriter.Write((ushort)0);
				binaryWriter.Write((ushort)0);
				binaryWriter.Write((ushort)width);
				binaryWriter.Write((ushort)height);
				binaryWriter.Write((byte)0);
				int num = 0;
				for (int num2 = height - 1; num2 >= 0; num2--)
				{
					int num3 = num2 * width;
					for (int j = 0; j < width; j++)
					{
						Color32 val2 = frame[num3 + j];
						array[num++] = ((val2.a < 128) ? byte.MaxValue : Nearest(val2, list, cache));
					}
				}
				binaryWriter.Write((byte)8);
				LzwEncode(array, binaryWriter);
				binaryWriter.Write((byte)0);
			}
			binaryWriter.Write((byte)59);
		}

		private static List<Color32> BuildPalette(List<Color32[]> frames)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			foreach (Color32[] frame in frames)
			{
				foreach (Color32 val in frame)
				{
					if (val.a >= 128)
					{
						int key = (val.r >> 2 << 12) | (val.g >> 2 << 6) | (val.b >> 2);
						dictionary.TryGetValue(key, out var value);
						dictionary[key] = value + 1;
					}
				}
			}
			List<(int, int, int, int)> list = new List<(int, int, int, int)>(dictionary.Count);
			foreach (KeyValuePair<int, int> item in dictionary)
			{
				list.Add((((item.Key >> 12) & 0x3F) << 2, ((item.Key >> 6) & 0x3F) << 2, (item.Key & 0x3F) << 2, item.Value));
			}
			if (list.Count == 0)
			{
				return new List<Color32>
				{
					new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue)
				};
			}
			List<List<(int, int, int, int)>> list2 = new List<List<(int, int, int, int)>> { list };
			while (list2.Count < 255)
			{
				int num = -1;
				int num2 = 0;
				int bestCh = 0;
				for (int j = 0; j < list2.Count; j++)
				{
					List<(int, int, int, int)> list3 = list2[j];
					if (list3.Count < 2)
					{
						continue;
					}
					int num3 = 255;
					int num4 = 0;
					int num5 = 255;
					int num6 = 0;
					int num7 = 255;
					int num8 = 0;
					foreach (var item2 in list3)
					{
						if (item2.Item1 < num3)
						{
							(num3, _, _, _) = item2;
						}
						if (item2.Item1 > num4)
						{
							(num4, _, _, _) = item2;
						}
						if (item2.Item2 < num5)
						{
							num5 = item2.Item2;
						}
						if (item2.Item2 > num6)
						{
							num6 = item2.Item2;
						}
						if (item2.Item3 < num7)
						{
							num7 = item2.Item3;
						}
						if (item2.Item3 > num8)
						{
							num8 = item2.Item3;
						}
					}
					int num9 = num4 - num3;
					int num10 = num6 - num5;
					int val2 = num8 - num7;
					int num11 = Math.Max(num9, Math.Max(num10, val2));
					if (num11 > num2)
					{
						num2 = num11;
						num = j;
						bestCh = ((num11 != num9) ? ((num11 == num10) ? 1 : 2) : 0);
					}
				}
				if (num < 0)
				{
					break;
				}
				List<(int, int, int, int)> list4 = list2[num];
				list4.Sort(((int r, int g, int b, int n) a, (int r, int g, int b, int n) c) => (bestCh != 0) ? ((bestCh != 1) ? a.b.CompareTo(c.b) : a.g.CompareTo(c.g)) : a.r.CompareTo(c.r));
				long num12 = 0L;
				foreach (var item3 in list4)
				{
					num12 += item3.Item4;
				}
				long num13 = 0L;
				int num14;
				for (num14 = 0; num14 < list4.Count - 1; num14++)
				{
					num13 += list4[num14].Item4;
					if (num13 * 2 >= num12)
					{
						num14++;
						break;
					}
				}
				if (num14 <= 0 || num14 >= list4.Count)
				{
					num14 = list4.Count / 2;
				}
				list2[num] = list4.GetRange(0, num14);
				list2.Add(list4.GetRange(num14, list4.Count - num14));
			}
			List<Color32> list5 = new List<Color32>(list2.Count);
			foreach (List<(int, int, int, int)> item4 in list2)
			{
				long num15 = 0L;
				long num16 = 0L;
				long num17 = 0L;
				long num18 = 0L;
				foreach (var item5 in item4)
				{
					num15 += (long)item5.Item1 * (long)item5.Item4;
					num16 += (long)item5.Item2 * (long)item5.Item4;
					num17 += (long)item5.Item3 * (long)item5.Item4;
					num18 += item5.Item4;
				}
				if (num18 != 0L)
				{
					list5.Add(new Color32((byte)(num15 / num18), (byte)(num16 / num18), (byte)(num17 / num18), byte.MaxValue));
				}
			}
			return list5;
		}

		private static byte Nearest(Color32 c, List<Color32> palette, Dictionary<int, byte> cache)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			int key = (c.r >> 2 << 12) | (c.g >> 2 << 6) | (c.b >> 2);
			if (cache.TryGetValue(key, out var value))
			{
				return value;
			}
			int num = 0;
			int num2 = int.MaxValue;
			for (int i = 0; i < palette.Count; i++)
			{
				int num3 = palette[i].r - c.r;
				int num4 = palette[i].g - c.g;
				int num5 = palette[i].b - c.b;
				int num6 = num3 * num3 + num4 * num4 + num5 * num5;
				if (num6 < num2)
				{
					num2 = num6;
					num = i;
				}
			}
			cache[key] = (byte)num;
			return (byte)num;
		}

		private static void LzwEncode(byte[] data, BinaryWriter w)
		{
			List<byte> block = new List<byte>(4096);
			int bitBuf = 0;
			int bitCnt = 0;
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			int num = 258;
			int num2 = 9;
			Emit(256, num2);
			int num3 = ((data.Length != 0) ? data[0] : 0);
			for (int i = 1; i < data.Length; i++)
			{
				int num4 = data[i];
				int key = (num3 << 8) | num4;
				if (dictionary.TryGetValue(key, out var value))
				{
					num3 = value;
					continue;
				}
				Emit(num3, num2);
				if (num < 4096)
				{
					dictionary[key] = num++;
					if (num - 1 == 1 << num2 && num2 < 12)
					{
						num2++;
					}
				}
				else
				{
					Emit(256, num2);
					dictionary.Clear();
					num = 258;
					num2 = 9;
				}
				num3 = num4;
			}
			Emit(num3, num2);
			Emit(257, num2);
			if (bitCnt > 0)
			{
				block.Add((byte)(bitBuf & 0xFF));
			}
			if (block.Count > 0)
			{
				w.Write((byte)block.Count);
				w.Write(block.ToArray());
			}
			void Emit(int code, int size)
			{
				bitBuf |= code << bitCnt;
				bitCnt += size;
				while (bitCnt >= 8)
				{
					block.Add((byte)(bitBuf & 0xFF));
					bitBuf >>= 8;
					bitCnt -= 8;
					if (block.Count == 255)
					{
						w.Write(byte.MaxValue);
						w.Write(block.ToArray());
						block.Clear();
					}
				}
			}
		}
	}
	public static class HealthCheck
	{
		public enum Status
		{
			Ok,
			Warn,
			Info
		}

		public readonly struct Item
		{
			public readonly string Name;

			public readonly Status Status;

			public readonly string Detail;

			public Item(string name, Status status, string detail)
			{
				Name = name;
				Status = status;
				Detail = detail;
			}
		}

		private static bool _bootLogged;

		public static string CompiledAgainstGameVersion { get; } = ReadPinSuffix();

		private static string ReadPinSuffix()
		{
			foreach (AssemblyMetadataAttribute customAttribute in typeof(HealthCheck).Assembly.GetCustomAttributes<AssemblyMetadataAttribute>())
			{
				if (!(customAttribute.Key != "GameLibsPin") && !string.IsNullOrEmpty(customAttribute.Value))
				{
					int num = customAttribute.Value.IndexOf("silksong", StringComparison.OrdinalIgnoreCase);
					return (num >= 0) ? customAttribute.Value.Substring(num + "silksong".Length) : customAttribute.Value;
				}
			}
			return null;
		}

		public static List<Item> Run()
		{
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			List<Item> list = new List<Item>();
			string compiledAgainstGameVersion = CompiledAgainstGameVersion;
			string version = Application.version;
			if (string.IsNullOrEmpty(compiledAgainstGameVersion))
			{
				list.Add(new Item("GameLibs pin", Status.Info, "pin metadata absent from this build"));
			}
			else if (string.IsNullOrEmpty(version))
			{
				list.Add(new Item("GameLibs pin", Status.Info, "built vs " + compiledAgainstGameVersion + "; game version unreadable"));
			}
			else
			{
				version = version.Trim();
				compiledAgainstGameVersion = compiledAgainstGameVersion.Trim();
				if (string.Equals(version, compiledAgainstGameVersion, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(new Item("GameLibs pin", Status.Ok, "built vs " + compiledAgainstGameVersion + " = game " + version));
				}
				else
				{
					int[] array = SplitNumeric(version);
					int[] array2 = SplitNumeric(compiledAgainstGameVersion);
					if (array == null || array2 == null)
					{
						list.Add(new Item("GameLibs pin", Status.Info, "built vs " + compiledAgainstGameVersion + "; game reports '" + version + "' — formats differ, compare manually"));
					}
					else
					{
						int num = Math.Min(array.Length, array2.Length);
						bool flag = true;
						for (int i = 0; i < num; i++)
						{
							if (array[i] != array2[i])
							{
								flag = false;
								break;
							}
						}
						list.Add(flag ? new Item("GameLibs pin", Status.Ok, $"built vs {compiledAgainstGameVersion}, game {version} (matches to {num} segment(s))") : new Item("GameLibs pin", Status.Warn, "built vs " + compiledAgainstGameVersion + ", game is " + version + " — API drift possible; a newer Stitchwork build may exist"));
					}
				}
			}
			Harmony harmonyInstance = Plugin.HarmonyInstance;
			if (harmonyInstance == null)
			{
				list.Add(new Item("Harmony patches", Status.Warn, "no Harmony instance recorded — Awake did not complete"));
			}
			else
			{
				int num2 = harmonyInstance.GetPatchedMethods().Count();
				list.Add((num2 >= 10) ? new Item("Harmony patches", Status.Ok, $"{num2} methods patched") : new Item("Harmony patches", Status.Warn, $"only {num2} methods patched — boot likely aborted early (check the log for exceptions)"));
			}
			list.Add(GCUtil.BridgeAvailable ? new Item("TC GCManager bridge", Status.Ok, "resolved") : new Item("TC GCManager bridge", Status.Warn, "unresolved — heap-threshold bump inactive; heavy packs may trigger TC collect stutter"));
			list.Add(GameBridge.CanReloadScene ? new Item("GameBridge (scene reload)", Status.Ok, "resolved") : new Item("GameBridge (scene reload)", Status.Warn, "unresolved — pack Apply falls back to in-place reload (no scene refresh)"));
			list.Add(GUIHelper.InputBlockingAvailable ? new Item("InputSystem blocking", Status.Ok, "resolved") : new Item("InputSystem blocking", Status.Warn, "unresolved — typing in Stitchwork text fields may leak game hotkeys"));
			if (!TexUtil.RotateDrawAvailable)
			{
				list.Add(new Item("Rotate draw", Status.Warn, "no opaque blit shader resolvable (Hidden/BlitCopy AND Sprites/Default missing) — rotated composites inactive. This should not be possible; please report."));
			}
			else if (TexUtil.RotateShaderUnsupported)
			{
				list.Add(new Item("Rotate draw", Status.Ok, $"GL path active. (Legacy bundle shader unsupported on {SystemInfo.graphicsDeviceType} — " + "no longer needed; Probe C runs without its comparator here.)"));
			}
			else
			{
				list.Add(new Item("Rotate draw", Status.Ok, TexUtil.RotateShaderAvailable ? "GL path active; legacy shader loaded as the self-test comparator." : "GL path active; legacy bundle shader absent (comparator-only role)."));
			}
			int num3 = 0;
			try
			{
				if (Directory.Exists(Loc.LangDir))
				{
					num3 = Directory.GetFiles(Loc.LangDir, "*.yml").Length;
				}
			}
			catch
			{
			}
			list.Add((num3 > 0) ? new Item("Lang tables", Status.Ok, $"{num3} file(s)") : new Item("Lang tables", Status.Info, "Lang/ missing or empty — UI localization unavailable (English only)"));
			try
			{
				string path = Plugin.BasePath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
				string directoryName = Path.GetDirectoryName(path);
				string text = (string.IsNullOrEmpty(directoryName) ? null : Path.Combine(directoryName, "Patchwork"));
				if (text != null && string.Equals(Path.GetFullPath(text), Path.GetFullPath(path), StringComparison.OrdinalIgnoreCase))
				{
					text = null;
				}
				if (text != null && Directory.Exists(text) && !File.Exists(Path.Combine(text, "Patchwork.dll")))
				{
					int num4 = 0;
					string[] contentRoots = PackLayout.ContentRoots;
					foreach (string path2 in contentRoots)
					{
						if (Directory.Exists(Path.Combine(text, path2)))
						{
							num4++;
						}
					}
					if (num4 > 0)
					{
						list.Add(new Item("Patchwork leftovers", Status.Warn, $"{num4} content folder(s) in plugins/Patchwork/ (upstream's old working " + "folder) — Stitchwork does NOT read that location. Move them into the Stitchwork/ folder next to Stitchwork.dll."));
					}
				}
			}
			catch
			{
			}
			int length = Plugin.BasePath.Length;
			if (Path.DirectorySeparatorChar != '\\')
			{
				list.Add(new Item("Install path depth", Status.Ok, $"{length} chars — no MAX_PATH limit on this platform"));
			}
			else if (length + 110 > 260)
			{
				list.Add(new Item("Install path depth", Status.Warn, $"install root is {length} chars deep — the longest asset paths will exceed " + "Windows' 260-char limit. Stitchwork shims its own file access (long-path prefix), but image editors and Explorer may still fail on workspace files. Remedy: remove extra folder layers inside the plugin folder, or enable Windows long paths (LongPathsEnabled)."));
			}
			else
			{
				list.Add(new Item("Install path depth", Status.Ok, $"{length} chars — headroom OK"));
			}
			return list;
		}

		private static int[] SplitNumeric(string v)
		{
			string[] array = v.Split('.');
			int[] array2 = new int[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				if (!int.TryParse(array[i], out array2[i]))
				{
					return null;
				}
			}
			return array2;
		}

		public static void LogBootSummaryOnce()
		{
			if (_bootLogged)
			{
				return;
			}
			_bootLogged = true;
			List<Item> source = Run();
			int num = source.Count((Item i) => i.Status == Status.Ok);
			int num2 = source.Count((Item i) => i.Status == Status.Info);
			List<Item> list = source.Where((Item i) => i.Status == Status.Warn).ToList();
			if (list.Count == 0)
			{
				Plugin.Logger.LogInfo((object)string.Format("[Health] {0} OK{1} — all checks green.", num, (num2 > 0) ? $", {num2} info" : ""));
				return;
			}
			Plugin.Logger.LogWarning((object)$"[Health] {num} OK, {list.Count} WARN:");
			foreach (Item item in list)
			{
				Plugin.Logger.LogWarning((object)("[Health]   " + item.Name + ": " + item.Detail));
			}
		}
	}
	public static class IOUtil
	{
		private static bool _longPathLogged;

		public static string LongSafe(string path)
		{
			if (string.IsNullOrEmpty(path) || path.Length < 240)
			{
				return path;
			}
			if (Path.DirectorySeparatorChar != '\\')
			{
				return path;
			}
			if (path.StartsWith("\\\\?\\", StringComparison.Ordinal))
			{
				return path;
			}
			string fullPath = Path.GetFullPath(path);
			if (fullPath.Length < 248)
			{
				return fullPath;
			}
			if (!_longPathLogged)
			{
				_longPathLogged = true;
				Plugin.Logger.LogInfo((object)($"[IO] Long-path shim engaged ({fullPath.Length} chars, Windows MAX_PATH is 260) — using \\\\?\\ form. " + "If file operations still fail, the install is nested too deep (mod-manager profile paths): see the Health strip / wiki troubleshooting."));
			}
			return "\\\\?\\" + fullPath;
		}

		public static void EnsureDirectoryExists(string path)
		{
			path = LongSafe(path);
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
			}
		}

		public static void OpenPath(string path)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if (string.IsNullOrEmpty(path))
			{
				return;
			}
			try
			{
				RuntimePlatform platform = Application.platform;
				if ((int)platform > 1)
				{
					if ((int)platform == 13 || (int)platform == 16)
					{
						Process.Start("xdg-open", "\"" + path + "\"");
					}
					else
					{
						Process.Start(path);
					}
				}
				else
				{
					Process.Start("open", "\"" + path + "\"");
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[IO] Could not open '" + path + "': " + ex.Message));
			}
		}

		public static void RevealPath(string filePath)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if (string.IsNullOrEmpty(filePath))
			{
				return;
			}
			try
			{
				RuntimePlatform platform = Application.platform;
				if ((int)platform > 1)
				{
					if ((int)platform == 13 || (int)platform == 16)
					{
						OpenPath(Path.GetDirectoryName(filePath));
					}
					else
					{
						Process.Start("explorer.exe", "/select,\"" + filePath + "\"");
					}
				}
				else
				{
					Process.Start("open", "-R \"" + filePath + "\"");
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[IO] Could not reveal '" + filePath + "': " + ex.Message));
			}
		}

		public static void OpenDeepestExisting(string path)
		{
			string text = path;
			while (!string.IsNullOrEmpty(text) && !Directory.Exists(text))
			{
				text = Path.GetDirectoryName(text);
			}
			if (!string.IsNullOrEmpty(text))
			{
				OpenPath(text);
			}
		}

		public static (int width, int height) ReadPngDimensions(string path)
		{
			try
			{
				using FileStream fileStream = File.OpenRead(path);
				if (fileStream.Length < 24)
				{
					return (width: 0, height: 0);
				}
				fileStream.Seek(16L, SeekOrigin.Begin);
				byte[] array = new byte[8];
				if (fileStream.Read(array, 0, 8) < 8)
				{
					return (width: 0, height: 0);
				}
				int item = (array[0] << 24) | (array[1] << 16) | (array[2] << 8) | array[3];
				int item2 = (array[4] << 24) | (array[5] << 16) | (array[6] << 8) | array[7];
				return (width: item, height: item2);
			}
			catch (Exception)
			{
				return (width: 0, height: 0);
			}
		}

		public static bool TryReadPngDimensions(byte[] data, out int width, out int height)
		{
			width = (height = 0);
			if (data == null || data.Length < 24)
			{
				return false;
			}
			if (data[0] != 137 || data[1] != 80 || data[2] != 78 || data[3] != 71 || data[4] != 13 || data[5] != 10 || data[6] != 26 || data[7] != 10)
			{
				return false;
			}
			width = (data[16] << 24) | (data[17] << 16) | (data[18] << 8) | data[19];
			height = (data[20] << 24) | (data[21] << 16) | (data[22] << 8) | data[23];
			if (width > 0)
			{
				return height > 0;
			}
			return false;
		}

		public static (string name, string anchor) ParseAnchorTag(string baseName)
		{
			if (string.IsNullOrEmpty(baseName))
			{
				return (name: baseName, anchor: null);
			}
			int num = baseName.LastIndexOf('@');
			if (num < 0 || num == baseName.Length - 1)
			{
				return (name: baseName, anchor: null);
			}
			string text = baseName.Substring(num + 1);
			if (text.Length == 1)
			{
				string text2 = char.ToLowerInvariant(text[0]) switch
				{
					't' => "top-center", 
					'b' => "bottom-center", 
					'l' => "left-center", 
					'r' => "right-center", 
					'c' => "center", 
					_ => null, 
				};
				if (text2 == null)
				{
					return (name: baseName, anchor: null);
				}
				return (name: baseName.Substring(0, num), anchor: text2);
			}
			if (text[0] == 'p' || text[0] == 'P')
			{
				int num2 = text.IndexOf('_');
				if (num2 > 1 && num2 < text.Length - 1 && int.TryParse(text.Substring(1, num2 - 1), out var result) && int.TryParse(text.Substring(num2 + 1), out var result2))
				{
					return (name: baseName.Substring(0, num), anchor: $"pivot:{result}:{result2}");
				}
			}
			return (name: baseName, anchor: null);
		}

		public static bool TryParsePivotAnchor(string anchor, out int px, out int py)
		{
			px = (py = 0);
			if (string.IsNullOrEmpty(anchor) || !anchor.StartsWith("pivot:", StringComparison.Ordinal))
			{
				return false;
			}
			string[] array = anchor.Split(':');
			if (array.Length == 3 && int.TryParse(array[1], out px))
			{
				return int.TryParse(array[2], out py);
			}
			return false;
		}

		public static bool BenignDuplicate(string a, string b)
		{
			if (string.IsNullOrEmpty(a) || string.IsNullOrEmpty(b))
			{
				return false;
			}
			if (!string.Equals(Path.GetFileName(a), Path.GetFileName(b), StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			try
			{
				FileInfo fileInfo = new FileInfo(LongSafe(a));
				FileInfo fileInfo2 = new FileInfo(LongSafe(b));
				if (!fileInfo.Exists || !fileInfo2.Exists || fileInfo.Length != fileInfo2.Length)
				{
					return false;
				}
			}
			catch (IOException)
			{
				return false;
			}
			catch (UnauthorizedAccessException)
			{
				return false;
			}
			catch (ArgumentException)
			{
				return false;
			}
			catch (NotSupportedException)
			{
				return false;
			}
			byte[] array = FileCache.ReadBytes(a);
			byte[] array2 = FileCache.ReadBytes(b);
			if (array != null && array2 != null)
			{
				return array.AsSpan().SequenceEqual(array2);
			}
			return false;
		}

		public static bool FileMatchesBytes(string path, byte[] bytes)
		{
			if (string.IsNullOrEmpty(path) || bytes == null)
			{
				return false;
			}
			try
			{
				FileInfo fileInfo = new FileInfo(LongSafe(path));
				if (!fileInfo.Exists || fileInfo.Length != bytes.Length)
				{
					return false;
				}
			}
			catch (IOException)
			{
				return false;
			}
			catch (UnauthorizedAccessException)
			{
				return false;
			}
			catch (ArgumentException)
			{
				return false;
			}
			catch (NotSupportedException)
			{
				return false;
			}
			return FileCache.ReadBytes(path)?.AsSpan().SequenceEqual(bytes) ?? false;
		}
	}
	public static class Loc
	{
		private static Dictionary<string, string> _table;

		private static string _activeCode = "en";

		private static bool _init;

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

		private static readonly List<KeyValuePair<string, string>> _glossary = new List<KeyValuePair<string, string>>();

		public static int Generation { get; private set; }

		public static string ActiveCode => _activeCode;

		public static string LangDir => Path.Combine(Plugin.BasePath, "Lang");

		public static IReadOnlyList<KeyValuePair<string, string>> Glossary => _glossary;

		public static void SelfExtractEmbeddedTables()
		{
			Assembly assembly = typeof(Loc).Assembly;
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.StartsWith("Stitchwork.Lang.", StringComparison.Ordinal))
				{
					continue;
				}
				string text2 = text.Substring("Stitchwork.Lang.".Length);
				string path = Path.Combine(LangDir, text2);
				if (File.Exists(path))
				{
					continue;
				}
				try
				{
					IOUtil.EnsureDirectoryExists(LangDir);
					using Stream stream = assembly.GetManifestResourceStream(text);
					using FileStream destination = File.Create(path);
					stream.CopyTo(destination);
					Plugin.Logger.LogInfo((object)("[Loc] Extracted embedded " + text2 + " → Lang/ (was missing)."));
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogWarning((object)("[Loc] Could not extract embedded " + text2 + ": " + ex.Message));
				}
			}
		}

		public static string[] DiscoverLanguages()
		{
			List<string> list = new List<string> { "auto", "en" };
			try
			{
				if (Directory.Exists(LangDir))
				{
					string[] files = Directory.GetFiles(LangDir, "*.yml");
					for (int i = 0; i < files.Length; i++)
					{
						string text = Path.GetFileNameWithoutExtension(files[i]).ToLowerInvariant();
						if (!text.EndsWith("-glossary", StringComparison.Ordinal) && !list.Contains(text))
						{
							list.Add(text);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[Loc] Language discovery failed: " + ex.Message));
			}
			return list.ToArray();
		}

		public static string NativeName(string code)
		{
			return code switch
			{
				"auto" => T("Auto"), 
				"en" => "English", 
				"zh" => "中文", 
				_ => code, 
			};
		}

		public static void Init()
		{
			if (_init)
			{
				return;
			}
			_init = true;
			Reload();
			ConfigEntry<string> val = Plugin.Config?.UILanguageEntry;
			if (val != null)
			{
				val.SettingChanged += delegate
				{
					Reload();
				};
			}
		}

		private static string ResolveAutoCode()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			string currentLangCode = DialogueHandler.CurrentLangCode;
			if (!string.IsNullOrEmpty(currentLangCode) && currentLangCode != "EN")
			{
				return currentLangCode.ToLowerInvariant();
			}
			SystemLanguage systemLanguage = Application.systemLanguage;
			if ((int)systemLanguage <= 15)
			{
				if ((int)systemLanguage == 6)
				{
					return "zh";
				}
				if ((int)systemLanguage == 15)
				{
					return "de";
				}
			}
			else
			{
				if ((int)systemLanguage == 40)
				{
					return "zh";
				}
				if ((int)systemLanguage == 41)
				{
					return "zh";
				}
			}
			return (currentLangCode ?? "EN").ToLowerInvariant();
		}

		public static void OnGameLanguageChanged()
		{
			if (_init && string.Equals(Plugin.Config?.UILanguage, "auto", StringComparison.OrdinalIgnoreCase))
			{
				Reload();
			}
		}

		public static void CycleLanguage()
		{
			string[] array = DiscoverLanguages();
			string cur = Plugin.Config?.UILanguage ?? "auto";
			int num = Array.FindIndex(array, (string l) => string.Equals(l, cur, StringComparison.OrdinalIgnoreCase));
			string uILanguage = array[(num + 1 + array.Length) % array.Length];
			if (Plugin.Config != null)
			{
				Plugin.Config.UILanguage = uILanguage;
			}
		}

		private static void Reload()
		{
			string text = Plugin.Config?.UILanguage ?? "auto";
			string text2 = (string.Equals(text, "auto", StringComparison.OrdinalIgnoreCase) ? ResolveAutoCode() : text.ToLowerInvariant());
			Dictionary<string, string> dictionary = null;
			if (text2 != "en")
			{
				string path = Path.Combine(LangDir, text2 + ".yml");
				if (File.Exists(path))
				{
					dictionary = ParseFile(path);
				}
			}
			_table = dictionary;
			_activeCode = ((dictionary != null) ? text2 : "en");
			_glossary.Clear();
			if (_activeCode != "en")
			{
				string path2 = Path.Combine(LangDir, _activeCode + "-glossary.yml");
				if (File.Exists(path2))
				{
					foreach (KeyValuePair<string, string> item in ParseFileEntries(path2))
					{
						_glossary.Add(item);
					}
				}
			}
			Generation++;
			Plugin.Logger.LogInfo((object)("[Loc] UI language: " + _activeCode + ((dictionary != null) ? $" ({dictionary.Count} strings)" : " (built-in English)") + ((_glossary.Count > 0) ? $", glossary: {_glossary.Count} terms" : "") + " — setting='" + text + "'"));
		}

		public static string T(string key, string englishDefault = null)
		{
			if (Plugin.Config != null && Plugin.Config.DevMode)
			{
				_seenKeys.Add(key);
			}
			Dictionary<string, string> table = _table;
			if (table != null && table.TryGetValue(key, out var value))
			{
				return value;
			}
			return englishDefault ?? key;
		}

		public static void DumpKeysReport()
		{
			if (_seenKeys.Count == 0)
			{
				return;
			}
			try
			{
				IOUtil.EnsureDirectoryExists(LangDir);
				string text = Path.Combine(LangDir, "_keys-seen.txt");
				List<string> list = new List<string>(_seenKeys);
				list.Sort(StringComparer.Ordinal);
				File.WriteAllLines(text, list);
				Plugin.Logger.LogInfo((object)$"[Loc] Key report: {list.Count} key(s) → {text}");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[Loc] Key report failed: " + ex.Message));
			}
		}

		private static Dictionary<string, string> ParseFile(string path)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, string> item in ParseFileEntries(path))
			{
				dictionary[item.Key] = item.Value;
			}
			return dictionary;
		}

		private static List<KeyValuePair<string, string>> ParseFileEntries(string path)
		{
			List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();
			int num = 0;
			string[] array = File.ReadAllLines(path);
			foreach (string obj in array)
			{
				num++;
				string text = obj.Trim();
				if (text.Length == 0 || text[0] == '#')
				{
					continue;
				}
				if (!TryReadQuoted(text, 0, out var result, out var end))
				{
					Warn(path, num, "expected quoted key");
					continue;
				}
				int j;
				for (j = end; j < text.Length && text[j] == ' '; j++)
				{
				}
				if (j >= text.Length || text[j] != '=')
				{
					Warn(path, num, "expected '=' after key");
					continue;
				}
				for (j++; j < text.Length && text[j] == ' '; j++)
				{
				}
				if (!TryReadQuoted(text, j, out var result2, out var _))
				{
					Warn(path, num, "expected quoted value");
				}
				else
				{
					list.Add(new KeyValuePair<string, string>(result, result2));
				}
			}
			return list;
		}

		private static void Warn(string path, int line, string what)
		{
			Plugin.Logger.LogWarning((object)$"[Loc] {Path.GetFileName(path)}:{line} — {what}; line skipped");
		}

		private static bool TryReadQuoted(string line, int start, out string result, out int end)
		{
			result = null;
			end = start;
			if (start >= line.Length || line[start] != '"')
			{
				return false;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = start + 1; i < line.Length; i++)
			{
				char c = line[i];
				if (c == '\\' && i + 1 < line.Length)
				{
					char c2 = line[++i];
					StringBuilder stringBuilder2 = stringBuilder;
					stringBuilder2.Append(c2 switch
					{
						'n' => '\n', 
						't' => '\t', 
						'"' => '"', 
						'\\' => '\\', 
						_ => c2, 
					});
				}
				else
				{
					if (c == '"')
					{
						result = stringBuilder.ToString();
						end = i + 1;
						return true;
					}
					stringBuilder.Append(c);
				}
			}
			return false;
		}
	}
	public static class Log
	{
		public static void Verbose(string message)
		{
			StitchworkConfig config = Plugin.Config;
			if (config != null && config.VerboseLogging)
			{
				Plugin.Logger.LogInfo((object)message);
			}
			else
			{
				Plugin.Logger.LogDebug((object)message);
			}
		}

		public static void Info(string message)
		{
			Plugin.Logger.LogInfo((object)message);
		}

		public static void Warn(string message)
		{
			Plugin.Logger.LogWarning((object)message);
		}

		public static void Error(string message)
		{
			Plugin.Logger.LogError((object)message);
		}
	}
	internal static class LogGate
	{
		private sealed class CountingListener : ILogListener, IDisposable
		{
			internal int Count;

			public void LogEvent(object sender, LogEventArgs eventArgs)
			{
				Count++;
			}

			public void Dispose()
			{
			}
		}

		private const float HardDeadlineSec = 300f;

		private const float PrepareGraceSec = 0.5f;

		private const float NeverStartedSec = 5f;

		private static readonly List<ILogListener> _detached = new List<ILogListener>();

		private static CountingListener _counter;

		private static VideoPlayer _watching;

		private static string _what;

		private static bool _sawPlaying;

		private static float _openedAt;

		private static float _deadline;

		internal static bool IsSuppressed => _detached.Count > 0;

		internal static void SuppressForCinematic(VideoPlayer player, string what)
		{
			if (Plugin.Config == null || !Plugin.Config.SuppressLogDuringCinematics)
			{
				return;
			}
			_watching = player;
			_what = (string.IsNullOrEmpty(what) ? "(unnamed)" : what);
			_sawPlaying = false;
			_deadline = Time.realtimeSinceStartup + 300f;
			if (IsSuppressed)
			{
				return;
			}
			Plugin.Logger.LogInfo((object)("[LogGate] Cinematic '" + _what + "' starting — pausing log file writes (SuppressLogDuringCinematics). Log resumes when playback ends."));
			foreach (ILogListener item in new List<ILogListener>(Logger.Listeners))
			{
				if (item != null && ((object)item).GetType().Name.Contains("Disk"))
				{
					Logger.Listeners.Remove(item);
					_detached.Add(item);
				}
			}
			if (_detached.Count == 0)
			{
				Plugin.Logger.LogInfo((object)"[LogGate] No disk log listener found — nothing to pause.");
				return;
			}
			_counter = new CountingListener();
			Logger.Listeners.Add((ILogListener)(object)_counter);
			_openedAt = Time.realtimeSinceStartup;
		}

		internal static void Tick()
		{
			if (!IsSuppressed)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= _deadline)
			{
				Restore("deadline elapsed");
			}
			else if (!(realtimeSinceStartup - _openedAt < 0.5f))
			{
				if ((Object)(object)_watching == (Object)null)
				{
					Restore("video player gone");
				}
				else if (_watching.isPlaying)
				{
					_sawPlaying = true;
				}
				else if (_sawPlaying)
				{
					Restore("playback ended");
				}
				else if (realtimeSinceStartup - _openedAt > 5f)
				{
					Restore("playback never started");
				}
			}
		}

		internal static void Restore(string reason)
		{
			if (!IsSuppressed)
			{
				return;
			}
			int num = ((_counter != null) ? _counter.Count : 0);
			float num2 = Time.realtimeSinceStartup - _openedAt;
			if (_counter != null)
			{
				Logger.Listeners.Remove((ILogListener)(object)_counter);
				_counter = null;
			}
			foreach (ILogListener item in _detached)
			{
				Logger.Listeners.Add(item);
			}
			_detached.Clear();
			_watching = null;
			_sawPlaying = false;
			string arg = ((num2 > 0.01f) ? $", ≈{(float)num / num2:F0}/s" : "");
			Plugin.Logger.LogInfo((object)($"[LogGate] Cinematic '{_what}' done ({reason}) — log resumed after {num2:F1} s; " + $"{num} line(s) not written{arg}."));
			_what = null;
		}
	}
	internal static class PipelineSelfTest
	{
		public static string LastSummary { get; private set; } = "";

		public static void Run()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource logger = Plugin.Logger;
			StringBuilder stringBuilder = new StringBuilder();
			logger.LogInfo((object)($"[SelfTest] project colorspace={QualitySettings.activeColorSpace}, " + $"MatchOriginalColorSpace={Plugin.Config.MatchOriginalColorSpace}"));
			Texture2D val = FindProbeTexture();
			if ((Object)(object)val == (Object)null)
			{
				logger.LogWarning((object)"[SelfTest] A: no probe texture found (no tk2d material / Sprite loaded?)");
				stringBuilder.Append("A: no probe · ");
			}
			else
			{
				int num = Mathf.Min(1024, Mathf.Max(((Texture)val).width, ((Texture)val).height));
				Color32[] a = ReadVia((Texture)(object)val, num, null);
				Color32[] b = ReadVia((Texture)(object)val, num, (RenderTextureReadWrite)1);
				Color32[] b2 = ReadVia((Texture)(object)val, num, (RenderTextureReadWrite)2);
				(int, double, int) tuple = Diff(a, b);
				(int, double, int) tuple2 = Diff(a, b2);
				logger.LogInfo((object)($"[SelfTest] A: probe '{((Object)val).name}' {((Texture)val).width}x{((Texture)val).height} " + $"(format {((Texture)val).graphicsFormat}), sampled at {num}²"));
				logger.LogInfo((object)$"[SelfTest] A: Linear intermediate: maxΔ={tuple.Item1} meanΔ={tuple.Item2:F3} diffPx={tuple.Item3}");
				logger.LogInfo((object)$"[SelfTest] A: sRGB intermediate:   maxΔ={tuple2.Item1} meanΔ={tuple2.Item2:F3} diffPx={tuple2.Item3}");
				string text = ((tuple.Item1 <= 1 && tuple2.Item1 <= 1) ? "both RT modes appearance-preserving — RT class exonerated for the hue report" : ((tuple.Item1 <= 1) ? "Linear (current default) preserves; sRGB alters — current default CORRECT" : ((tuple2.Item1 <= 1) ? "Linear (current default) ALTERS appearance; sRGB preserves — hue-shift root cause; MatchOriginalColorSpace=true is the mitigation" : "NEITHER mode lossless — deeper format issue, report these numbers")));
				logger.LogInfo((object)("[SelfTest] A verdict: " + text));
				stringBuilder.Append($"A: lin Δ{tuple.Item1} srgb Δ{tuple2.Item1} · ");
			}
			List<(string, string, RenderTexture, RenderTexture)> compositePairsForDiagnostics = SpriteLoader.GetCompositePairsForDiagnostics();
			if (compositePairsForDiagnostics.Count == 0)
			{
				logger.LogInfo((object)"[SelfTest] B: no composited atlases live (nothing to compare).");
				stringBuilder.Append("B: no composites");
			}
			else
			{
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				for (int i = 0; i < compositePairsForDiagnostics.Count && i < 16; i++)
				{
					(string, string, RenderTexture, RenderTexture) tuple3 = compositePairsForDiagnostics[i];
					string item = tuple3.Item1;
					string item2 = tuple3.Item2;
					RenderTexture item3 = tuple3.Item3;
					RenderTexture item4 = tuple3.Item4;
					int num5 = ((i == 0) ? Mathf.Min(1024, Mathf.Max(((Texture)item3).width, ((Texture)item3).height)) : 256);
					Color32[] array = ReadVia((Texture)(object)item3, num5, null);
					Color32[] b3 = ReadVia((Texture)(object)item4, num5, null);
					(int, double, int) tuple4 = Diff(array, b3);
					num4++;
					if (tuple4.Item1 <= 1)
					{
						num2++;
						continue;
					}
					num3++;
					logger.LogInfo((object)("[SelfTest] B: '" + item + "/" + item2 + "' differs from vanilla backup: " + $"maxΔ={tuple4.Item1} meanΔ={tuple4.Item2:F3} diffPx={tuple4.Item3}/{array.Length} @{num5}² " + "(expected IF replacements are active on it; damage if none are)"));
				}
				logger.LogInfo((object)($"[SelfTest] B: {compositePairsForDiagnostics.Count} composited atlas(es), {num4} compared " + $"({num2} identical to vanilla, {num3} differing" + ((compositePairsForDiagnostics.Count > 16) ? $", {compositePairsForDiagnostics.Count - 16} skipped for memory" : "") + ")."));
				logger.LogInfo((object)"[SelfTest] B: to make this an assertion, run with all packs/workspace files disabled (any differing atlas = pipeline damage) or with one pristine-dump null replacement (differences must be confined to it).");
				stringBuilder.Append($"B: {num2}/{num4} identical, {num3} differ");
			}
			stringBuilder.Append(" · ");
			stringBuilder.Append(RotateParityProbe(logger));
			stringBuilder.Append(" · ");
			stringBuilder.Append(RoundTripProbe(logger));
			LastSummary = stringBuilder.ToString();
			logger.LogInfo((object)"[SelfTest] done.");
		}

		private static int RoundTrip(Color32[] regionPx, int w, int h, FlipMode flip)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(w, h, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			val.SetPixels32(regionPx);
			val.Apply(false, false);
			Texture2D val2 = null;
			Texture2D val3 = null;
			RenderTexture temporary = RenderTexture.GetTemporary(w, h, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			RenderTexture active = RenderTexture.active;
			bool flag = false;
			try
			{
				val2 = SpriteDumper.RotateToScreen(val, flip);
				RenderTexture.active = temporary;
				GL.Clear(true, true, Color.clear);
				GL.PushMatrix();
				flag = true;
				GL.LoadPixelMatrix(0f, (float)w, (float)h, 0f);
				var (uB, vB) = SpriteUtil.CompositeBasisFor(flip);
				TexUtil.DrawRotated(new Rect(0f, 0f, (float)w, (float)h), (Texture)(object)val2, uB, vB);
				GL.PopMatrix();
				flag = false;
				val3 = new Texture2D(w, h, (TextureFormat)4, false);
				val3.ReadPixels(new Rect(0f, 0f, (float)w, (float)h), 0, 0);
				val3.Apply(false, false);
				Color32[] pixels = val3.GetPixels32();
				int num = 0;
				for (int i = 0; i < pixels.Length; i++)
				{
					if (pixels[i].r != regionPx[i].r || pixels[i].g != regionPx[i].g || pixels[i].b != regionPx[i].b || pixels[i].a != regionPx[i].a)
					{
						num++;
					}
				}
				return num;
			}
			finally
			{
				if (flag)
				{
					GL.PopMatrix();
				}
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
				Object.Destroy((Object)(object)val);
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Destroy((Object)(object)val2);
				}
				if ((Object)(object)val3 != (Object)null)
				{
					Object.Destroy((Object)(object)val3);
				}
			}
		}

		private static string RoundTripProbe(ManualLogSource log)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Expected O, but got Unknown
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			if (!TexUtil.RotateDrawAvailable)
			{
				return "D: NO BLIT MAT";
			}
			FlipMode[] array = (FlipMode[])(object)new FlipMode[3]
			{
				default(FlipMode),
				(FlipMode)1,
				(FlipMode)2
			};
			Color32[] array2 = (Color32[])(object)new Color32[24];
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i] = new Color32((byte)(i * 5 + 7), (byte)(251 - i * 9), (byte)(i * 11 + 2), byte.MaxValue);
			}
			StringBuilder stringBuilder = new StringBuilder("D:");
			FlipMode[] array3 = array;
			foreach (FlipMode val in array3)
			{
				int num = RoundTrip(array2, 6, 4, val);
				bool flag = num == 0;
				log.LogInfo((object)($"[SelfTest] D {ModeTag(val)} synthetic {6}x{4}: " + (flag ? "PASS" : "FAIL") + (flag ? "" : $" ({num}px differ)")));
				stringBuilder.Append(" " + ModeTag(val) + " " + (flag ? "✓" : "✗"));
			}
			Dictionary<FlipMode, (tk2dSpriteCollectionData, tk2dSpriteDefinition)> dictionary = new Dictionary<FlipMode, (tk2dSpriteCollectionData, tk2dSpriteDefinition)>();
			tk2dSpriteCollectionData[] array4 = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val2 in array4)
			{
				if (dictionary.Count == array.Length)
				{
					break;
				}
				if ((Object)(object)val2 == (Object)null || val2.spriteDefinitions == null || (((Object)val2).name != null && ((Object)val2).name.StartsWith("Stitchwork_Shadow")))
				{
					continue;
				}
				tk2dSpriteDefinition[] spriteDefinitions = val2.spriteDefinitions;
				foreach (tk2dSpriteDefinition val3 in spriteDefinitions)
				{
					if (!string.IsNullOrEmpty(val3.name) && !dictionary.ContainsKey(val3.flipped) && val3.uvs != null && val3.uvs.Length >= 4)
					{
						dictionary[val3.flipped] = (val2, val3);
						if (dictionary.Count == array.Length)
						{
							break;
						}
					}
				}
			}
			array3 = array;
			foreach (FlipMode val4 in array3)
			{
				if (!dictionary.TryGetValue(val4, out var value))
				{
					log.LogInfo((object)("[SelfTest] D " + ModeTag(val4) + " live: no def loaded (run in a scene that has one)"));
					continue;
				}
				if (!SpriteLoader.TryGetVanilla(value.Item1, value.Item2, out var atlas, out var uvs, out var _))
				{
					Material[] materials = value.Item1.materials;
					Material val5 = ((materials != null && value.Item2.materialId >= 0 && value.Item2.materialId < materials.Length) ? materials[value.Item2.materialId] : null);
					atlas = (((Object)(object)val5 != (Object)null) ? val5.mainTexture : null);
				}
				if ((Object)(object)atlas == (Object)null)
				{
					log.LogInfo((object)("[SelfTest] D " + ModeTag(val4) + " live: def '" + value.Item2.name + "' has no atlas — skipped"));
					continue;
				}
				Rect spriteRect = SpriteUtil.GetSpriteRect(uvs, atlas);
				int num2 = (int)((Rect)(ref spriteRect)).width;
				int num3 = (int)((Rect)(ref spriteRect)).height;
				if (num2 <= 0 || num3 <= 0)
				{
					log.LogInfo((object)("[SelfTest] D " + ModeTag(val4) + " live: def '" + value.Item2.name + "' zero rect — skipped"));
					continue;
				}
				RenderTexture active = RenderTexture.active;
				RenderTexture val6 = null;
				Texture2D val7 = new Texture2D(num2, num3, (TextureFormat)4, false);
				Color32[] pixels;
				try
				{
					RenderTexture val8 = (RenderTexture)(object)((atlas is RenderTexture) ? atlas : null);
					if ((Object)(object)val8 == (Object)null)
					{
						val6 = TexUtil.GetReadable(atlas);
						val8 = val6;
					}
					RenderTexture.active = val8;
					val7.ReadPixels(spriteRect, 0, 0);
					val7.Apply(false, false);
					pixels = val7.GetPixels32();
				}
				finally
				{
					RenderTexture.active = active;
					Object.Destroy((Object)(object)val7);
					if ((Object)(object)val6 != (Object)null)
					{
						RenderTexture.ReleaseTemporary(val6);
					}
				}
				int num4 = RoundTrip(pixels, num2, num3, val4);
				bool flag2 = num4 == 0;
				log.LogInfo((object)($"[SelfTest] D {ModeTag(val4)} live '{((Object)value.Item1).name}/{value.Item2.name}' {num2}x{num3}: " + (flag2 ? "PASS" : "FAIL") + (flag2 ? "" : $" ({num4}px differ)")));
				stringBuilder.Append(" " + ModeTag(val4) + "(live) " + (flag2 ? "✓" : "✗"));
			}
			return stringBuilder.ToString();
		}

		private static string ModeTag(FlipMode m)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)m != 1)
			{
				if ((int)m == 2)
				{
					return "tpk";
				}
				return "id";
			}
			return "tk2d";
		}

		private static string RotateParityProbe(ManualLogSource log)
		{
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			if (!TexUtil.RotateDrawAvailable)
			{
				return "C: NO BLIT MAT";
			}
			Texture2D src = new Texture2D(4, 4, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			Color32[] array = (Color32[])(object)new Color32[16];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Color32((byte)(i * 16 + 8), (byte)(255 - i * 16), (byte)(i * 7 + 3), byte.MaxValue);
			}
			src.SetPixels32(array);
			src.Apply(false, false);
			(string, Vector2, Vector2, bool)[] obj = new(string, Vector2, Vector2, bool)[3]
			{
				("id", Vector2.right, Vector2.up, false),
				("tk2d", Vector2.up, Vector2.left, true),
				("tpk", Vector2.down, Vector2.right, true)
			};
			StringBuilder stringBuilder = new StringBuilder("C:");
			(string, Vector2, Vector2, bool)[] array2 = obj;
			for (int j = 0; j < array2.Length; j++)
			{
				(string, Vector2, Vector2, bool) tuple = array2[j];
				string item = tuple.Item1;
				Vector2 uB = tuple.Item2;
				Vector2 vB = tuple.Item3;
				int outW = 4;
				int outH = 4;
				Color32[] array3 = Draw(viaShader: false);
				bool flag;
				string text;
				if (TexUtil.RotateShaderAvailable)
				{
					Color32[] array4 = Draw(viaShader: true);
					int num = 0;
					for (int k = 0; k < array3.Length; k++)
					{
						if (array3[k].r != array4[k].r || array3[k].g != array4[k].g || array3[k].b != array4[k].b || array3[k].a != array4[k].a)
						{
							num++;
						}
					}
					flag = num == 0;
					text = (flag ? "==shader" : $"{num}px≠shader");
				}
				else if (item == "id")
				{
					int num2 = 0;
					for (int l = 0; l < array3.Length; l++)
					{
						if (array3[l].r != array[l].r || array3[l].g != array[l].g || array3[l].b != array[l].b)
						{
							num2++;
						}
					}
					flag = num2 == 0;
					text = (flag ? "==src" : $"{num2}px≠src");
				}
				else
				{
					flag = true;
					text = "no comparator";
				}
				log.LogInfo((object)("[SelfTest] C " + item + ": " + (flag ? "PASS" : "FAIL") + " (" + text + ")"));
				stringBuilder.Append(" " + item + " " + (flag ? "✓" : "✗"));
				Color32[] Draw(bool viaShader)
				{
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Expected O, but got Unknown
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					//IL_010a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0116: Unknown result type (might be due to invalid IL or missing references)
					//IL_011c: Unknown result type (might be due to invalid IL or missing references)
					//IL_009f: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
					//IL_0144: Unknown result type (might be due to invalid IL or missing references)
					RenderTexture temporary = RenderTexture.GetTemporary(outW, outH, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
					RenderTexture active = RenderTexture.active;
					Texture2D val = new Texture2D(outW, outH, (TextureFormat)4, false);
					try
					{
						RenderTexture.active = temporary;
						GL.Clear(true, true, Color.clear);
						GL.PushMatrix();
						GL.LoadPixelMatrix(0f, (float)((Texture)temporary).height, (float)((Texture)temporary).width, 0f);
						if (viaShader)
						{
							TexUtil.RotateMaterial.SetVector("_Basis", new Vector4(uB.x, uB.y, vB.x, vB.y));
							Graphics.DrawTexture(new Rect(0f, 0f, 4f, 4f), (Texture)(object)src, new Rect(0f, 0f, 1f, 1f), 0, 0, 0, 0, Color.white, TexUtil.RotateMaterial);
						}
						else
						{
							TexUtil.DrawRotated(new Rect(0f, 0f, 4f, 4f), (Texture)(object)src, uB, vB);
						}
						GL.PopMatrix();
						val.ReadPixels(new Rect(0f, 0f, (float)outW, (float)outH), 0, 0);
						val.Apply(false, false);
						return val.GetPixels32();
					}
					finally
					{
						RenderTexture.active = active;
						Object.Destroy((Object)(object)val);
						RenderTexture.ReleaseTemporary(temporary);
					}
				}
			}
			Object.Destroy((Object)(object)src);
			return stringBuilder.ToString();
		}

		private static Color32[] ReadVia(Texture src, int outSize, RenderTextureReadWrite? intermediate)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			RenderTexture val = null;
			Texture val2 = src;
			if (intermediate.HasValue)
			{
				val = RenderTexture.GetTemporary(src.width, src.height, 0, (RenderTextureFormat)0, intermediate.Value);
				Graphics.Blit(src, val);
				val2 = (Texture)(object)val;
			}
			RenderTexture temporary = RenderTexture.GetTemporary(outSize, outSize, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			Graphics.Blit(val2, temporary);
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary;
			Texture2D val3 = new Texture2D(outSize, outSize, (TextureFormat)4, false);
			val3.ReadPixels(new Rect(0f, 0f, (float)outSize, (float)outSize), 0, 0);
			val3.Apply(false);
			Color32[] pixels = val3.GetPixels32();
			RenderTexture.active = active;
			Object.Destroy((Object)val3);
			RenderTexture.ReleaseTemporary(temporary);
			if ((Object)(object)val != (Object)null)
			{
				RenderTexture.ReleaseTemporary(val);
			}
			return pixels;
		}

		private static (int Max, double Mean, int DiffPx) Diff(Color32[] a, Color32[] b)
		{
			int num = Mathf.Min(a.Length, b.Length);
			int num2 = 0;
			int num3 = 0;
			long num4 = 0L;
			for (int i = 0; i < num; i++)
			{
				int num5 = Mathf.Max(Mathf.Max(Mathf.Abs(a[i].r - b[i].r), Mathf.Abs(a[i].g - b[i].g)), Mathf.Max(Mathf.Abs(a[i].b - b[i].b), Mathf.Abs(a[i].a - b[i].a)));
				if (num5 > 0)
				{
					num3++;
					num4 += num5;
					if (num5 > num2)
					{
						num2 = num5;
					}
				}
			}
			return (Max: num2, Mean: (num > 0) ? ((double)num4 / (double)num) : 0.0, DiffPx: num3);
		}

		private static Texture2D FindProbeTexture()
		{
			tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val in array)
			{
				if ((Object)(object)val == (Object)null || val.materials == null)
				{
					continue;
				}
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						Texture mainTexture = val2.mainTexture;
						Texture2D val3 = (Texture2D)(object)((mainTexture is Texture2D) ? mainTexture : null);
						if (val3 != null && ((Texture)val3).width >= 64)
						{
							return val3;
						}
					}
				}
			}
			Sprite[] array2 = Resources.FindObjectsOfTypeAll<Sprite>();
			foreach (Sprite val4 in array2)
			{
				if ((Object)(object)val4 != (Object)null && (Object)(object)val4.texture != (Object)null && ((Texture)val4.texture).width >= 64)
				{
					return val4.texture;
				}
			}
			return null;
		}
	}
	public static class PlayerDataCatalog
	{
		public readonly struct Entry
		{
			public readonly string Name;

			public readonly Type FieldType;

			public readonly string TypeLabel;

			public Entry(string name, Type type)
			{
				Name = name;
				FieldType = type;
				TypeLabel = ((type == typeof(bool)) ? "bool" : ((type == typeof(int)) ? "int" : ((type == typeof(float)) ? "float" : ((type == typeof(string)) ? "str" : type.Name))));
			}
		}

		private static List<Entry> _catalog;

		private static readonly Dictionary<string, Func<PlayerData, object>> _accessorCache = new Dictionary<string, Func<PlayerData, object>>(StringComparer.Ordinal);

		public static IReadOnlyList<Entry> All
		{
			get
			{
				EnsureBuilt();
				return _catalog;
			}
		}

		public static int Count
		{
			get
			{
				EnsureBuilt();
				return _catalog.Count;
			}
		}

		public static IEnumerable<Entry> Search(string query)
		{
			EnsureBuilt();
			if (string.IsNullOrEmpty(query))
			{
				return _catalog;
			}
			return SearchFiltered(query);
		}

		private static IEnumerable<Entry> SearchFiltered(string query)
		{
			foreach (Entry item in _catalog)
			{
				if (item.Name.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					yield return item;
				}
			}
		}

		public static object GetValue(PlayerData pd, string name)
		{
			if (pd == null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (!_accessorCache.TryGetValue(name, out var value))
			{
				value = BuildAccessor(name);
				_accessorCache[name] = value;
			}
			return value?.Invoke(pd);
		}

		private static Func<PlayerData, object> BuildAccessor(string name)
		{
			Type typeFromHandle = typeof(PlayerData);
			MemberInfo member = (MemberInfo)(((object)typeFromHandle.GetField(name, BindingFlags.Instance | BindingFlags.Public)) ?? ((object)typeFromHandle.GetProperty(name, BindingFlags.Instance | BindingFlags.Public)));
			if (member == null)
			{
				return null;
			}
			try
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(PlayerData), "pd");
				return Expression.Lambda<Func<PlayerData, object>>(Expression.Convert((member is FieldInfo field) ? Expression.Field(parameterExpression, field) : Expression.Property(parameterExpression, (PropertyInfo)member), typeof(object)), new ParameterExpression[1] { parameterExpression }).Compile();
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[PlayerDataCatalog] Expression compile failed for '" + name + "': " + ex.Message + "; falling back to reflection."));
				FieldInfo fi2 = member as FieldInfo;
				return ((object)fi2 != null) ? ((Func<PlayerData, object>)((PlayerData pd) => fi2.GetValue(pd))) : ((Func<PlayerData, object>)((PlayerData pd) => ((PropertyInfo)member).GetValue(pd)));
			}
		}

		private static void EnsureBuilt()
		{
			if (_catalog == null)
			{
				_catalog = Build();
			}
		}

		private static List<Entry> Build()
		{
			List<Entry> list = new List<Entry>(512);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			Type typeFromHandle = typeof(PlayerData);
			HashSet<Type> hashSet2 = new HashSet<Type>
			{
				typeof(bool),
				typeof(int),
				typeof(float),
				typeof(string)
			};
			FieldInfo[] fields = typeFromHandle.GetFields(BindingFlags.Instance | BindingFlags.Public);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (hashSet2.Contains(fieldInfo.FieldType) && hashSet.Add(fieldInfo.Name))
				{
					list.Add(new Entry(fieldInfo.Name, fieldInfo.FieldType));
				}
			}
			PropertyInfo[] properties = typeFromHandle.GetProperties(BindingFlags.Instance | BindingFlags.Public);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.CanRead && hashSet2.Contains(propertyInfo.PropertyType) && hashSet.Add(propertyInfo.Name))
				{
					list.Add(new Entry(propertyInfo.Name, propertyInfo.PropertyType));
				}
			}
			list.Sort((Entry a, Entry b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
			return list;
		}
	}
	internal static class RawKeyboardLeakBlocker
	{
		private static bool _patched;

		public static void ApplyPatches(Harmony harmony)
		{
			if (_patched)
			{
				return;
			}
			try
			{
				Type typeFromHandle = typeof(ButtonControl);
				PatchPropertyGetter(harmony, typeFromHandle, "isPressed", "BlockBoolPrefix");
				PatchPropertyGetter(harmony, typeFromHandle, "wasPressedThisFrame", "BlockBoolPrefix");
				PatchPropertyGetter(harmony, typeFromHandle, "wasReleasedThisFrame", "BlockBoolPrefix");
				PatchMethod(harmony, typeFromHandle, "ReadValue", Type.EmptyTypes, "BlockFloatPrefix");
				_patched = true;
				Plugin.Logger.LogInfo((object)"[RawKeyboardLeakBlocker] ButtonControl polling patches applied.");
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogWarning((object)$"[RawKeyboardLeakBlocker] Failed to apply patches: {arg}");
			}
		}

		private static void PatchPropertyGetter(Harmony harmony, Type targetType, string propertyName, string prefixName)
		{
			MethodInfo target = AccessTools.PropertyGetter(targetType, propertyName);
			PatchWithPrefix(harmony, target, prefixName, targetType.Name + "." + propertyName);
		}

		private static void PatchMethod(Harmony harmony, Type targetType, string methodName, Type[] args, string prefixName)
		{
			MethodInfo target = AccessTools.Method(targetType, methodName, args, (Type[])null);
			PatchWithPrefix(harmony, target, prefixName, targetType.Name + "." + methodName + "()");
		}

		private static void PatchWithPrefix(Harmony harmony, MethodInfo target, string prefixName, string label)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			if (target == null)
			{
				Plugin.Logger.LogWarning((object)("[RawKeyboardLeakBlocker] Target not found: " + label));
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(RawKeyboardLeakBlocker), prefixName, (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Logger.LogWarning((object)("[RawKeyboardLeakBlocker] Prefix not found: " + prefixName));
				return;
			}
			harmony.Patch((MethodBase)target, new HarmonyMethod(methodInfo), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.Logger.LogInfo((object)("[RawKeyboardLeakBlocker] Patched " + label));
		}

		private static bool ShouldBlock(ButtonControl __instance)
		{
			if (!GUIHelper.IsTextFieldFocused)
			{
				return false;
			}
			if (__instance == null)
			{
				return false;
			}
			return ((InputControl)__instance).device is Keyboard;
		}

		private static bool BlockBoolPrefix(ButtonControl __instance, ref bool __result)
		{
			if (!ShouldBlock(__instance))
			{
				return true;
			}
			__result = false;
			return false;
		}

		private static bool BlockFloatPrefix(ButtonControl __instance, ref float __result)
		{
			if (!ShouldBlock(__instance))
			{
				return true;
			}
			__result = 0f;
			return false;
		}
	}
	public static class SpriteUtil
	{
		public static Rect GetSpriteRect(tk2dSpriteDefinition def, Texture tex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return GetSpriteRect(def.uvs, tex);
		}

		public static Rect GetSpriteRect(Vector2[] uvs, Texture tex)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			float x = uvs[0].x;
			float x2 = uvs[0].x;
			float y = uvs[0].y;
			float y2 = uvs[0].y;
			for (int i = 1; i < uvs.Length; i++)
			{
				Vector2 val = uvs[i];
				if (val.x < x)
				{
					x = val.x;
				}
				if (val.x > x2)
				{
					x2 = val.x;
				}
				if (val.y < y)
				{
					y = val.y;
				}
				if (val.y > y2)
				{
					y2 = val.y;
				}
			}
			int num = Mathf.FloorToInt(x * (float)tex.width + 0.25f);
			int num2 = Mathf.CeilToInt(x2 * (float)tex.width - 0.25f);
			int num3 = Mathf.FloorToInt(y * (float)tex.height + 0.25f);
			int num4 = Mathf.CeilToInt(y2 * (float)tex.height - 0.25f);
			int num5 = Mathf.Min(num2 - num, tex.width);
			int num6 = Mathf.Min(num4 - num3, tex.height);
			return new Rect((float)num, (float)num3, (float)num5, (float)num6);
		}

		public static (Vector2 uBasis, Vector2 vBasis) DumpBasisFor(FlipMode flip)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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 ((int)flip != 1)
			{
				if ((int)flip == 2)
				{
					return (uBasis: Vector2.down, vBasis: Vector2.right);
				}
				return (uBasis: Vector2.right, vBasis: Vector2.up);
			}
			return (uBasis: Vector2.up, vBasis: Vector2.left);
		}

		public static (Vector2 uBasis, Vector2 vBasis) CompositeBasisFor(FlipMode flip)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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 ((int)flip != 1)
			{
				if ((int)flip == 2)
				{
					return (uBasis: Vector2.up, vBasis: Vector2.left);
				}
				return (uBasis: Vector2.right, vBasis: Vector2.up);
			}
			return (uBasis: Vector2.down, vBasis: Vector2.right);
		}
	}
	public sealed class T2DSceneEntry
	{
		public readonly string CleanName;

		public readonly string RawName;

		public readonly Texture NativeTexture;

		public readonly int Width;

		public readonly int Height;

		public readonly bool IsT2D;

		public readonly List<string> SpriteNames;

		public readonly bool HasSpritesheetOverride;

		public readonly int LoadedIndividualCount;

		public readonly int AtlasIndex;

		public readonly string DisplayName;

		public T2DSceneEntry(string cleanName, string rawName, Texture tex, bool isT2D, List<string> spriteNames, bool hasOverride, int loadedCount, int atlasIndex, string displayName)
		{
			CleanName = cleanName;
			RawName = rawName;
			NativeTexture = tex;
			Width = (((Object)(object)tex != (Object)null) ? tex.width : 0);
			Height = (((Object)(object)tex != (Object)null) ? tex.height : 0);
			IsT2D = isT2D;
			SpriteNames = spriteNames ?? new List<string>();
			HasSpritesheetOverride = hasOverride;
			LoadedIndividualCount = loadedCount;
			AtlasIndex = atlasIndex;
			DisplayName = displayName ?? cleanName;
		}
	}
	public static class T2DUtil
	{
		private static readonly Dictionary<string, string> _cleanNameCache = new Dictionary<string, string>();

		public static bool IsT2DTexture(string textureName)
		{
			if (!textureName.Contains("-BC7-"))
			{
				return textureName.Contains("DXT5|BC3-");
			}
			return true;
		}

		public static string SpriteKey(string cleanTexName, string spriteName)
		{
			return cleanTexName + "/" + spriteName;
		}

		public static string SanitizeForFilesystem(string textureName)
		{
			return textureName.Replace("|", "_").Replace("/", "_").Replace("\\", "_")
				.Replace(":", "_");
		}

		public static string CleanTextureName(string textureName)
		{
			if (_cleanNameCache.TryGetValue(textureName, out var value))
			{
				return value;
			}
			string text = CleanTextureNameUncached(textureName);
			_cleanNameCache[textureName] = text;
			return text;
		}

		internal static void ClearCleanNameCache()
		{
			_cleanNameCache.Clear();
		}

		public static int AtlasIndexFromRaw(string rawName)
		{
			if (string.IsNullOrEmpty(rawName))
			{
				return -1;
			}
			if (!rawName.StartsWith("sactx-", StringComparison.Ordinal))
			{
				return -1;
			}
			int num = rawName.IndexOf('-');
			if (num < 0 || num == rawName.Length - 1)
			{
				return -1;
			}
			int num2 = rawName.IndexOf('-', num + 1);
			if (num2 < 0)
			{
				return -1;
			}
			if (!int.TryParse(rawName.Substring(num + 1, num2 - num - 1), out var result))
			{
				return -1;
			}
			return result;
		}

		private static string CleanTextureNameUncached(string textureName)
		{
			string text = null;
			if (textureName.Contains("-BC7-"))
			{
				text = "-BC7-";
			}
			else if (textureName.Contains("DXT5|BC3-"))
			{
				text = "DXT5|BC3-";
			}
			else if (textureName.Contains("DXT5_BC3-"))
			{
				text = "DXT5_BC3-";
			}
			if (text == null)
			{
				return textureName;
			}
			string text2 = textureName.Split(new string[1] { text }, StringSplitOptions.None)[1];
			int num = text2.LastIndexOf('-');
			if (num <= 0)
			{
				return text2;
			}
			return text2.Substring(0, num);
		}
	}
	public static class TexUtil
	{
		public static Material RotateMaterial;

		private static Material _rotateDrawMat;

		private static bool _rotateDrawResolved;

		public static bool RotateShaderAvailable => (Object)(object)RotateMaterial != (Object)null;

		public static bool RotateShaderUnsupported { get; private set; }

		public static bool RotateDrawAvailable
		{
			get
			{
				EnsureRotateDrawMat();
				return (Object)(object)_rotateDrawMat != (Object)null;
			}
		}

		public static void Initialize()
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = null;
			try
			{
				using Stream stream = typeof(TexUtil).Assembly.GetManifestResourceStream("Stitchwork.stitchwork.assetbundle");
				if (stream != null)
				{
					array = new byte[stream.Length];
					int i;
					int num;
					for (i = 0; i < array.Length; i += num)
					{
						num = stream.Read(array, i, array.Length - i);
						if (num <= 0)
						{
							break;
						}
					}
					if (i != array.Length)
					{
						Plugin.Logger.LogWarning((object)$"[TexUtil] Embedded assetbundle short read: {i}/{array.Length} bytes.");
						array = null;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[TexUtil] Embedded assetbundle read failed: " + ex.Message));
			}
			string text = Path.Combine(Plugin.BasePath, "stitchwork.assetbundle");
			AssetBundle val = null;
			if (File.Exists(text))
			{
				val = AssetBundle.LoadFromFile(text);
			}
			if ((Object)(object)val == (Object)null && array != null)
			{
				val = AssetBundle.LoadFromMemory(array);
			}
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogError((object)"[TexUtil] stitchwork.assetbundle could not be loaded (missing/corrupt file and no embedded copy). Stitchwork stays functional; rotated-sprite features are degraded (upright previews fall back to raw crops, animation-canvas extract unavailable).");
				return;
			}
			Shader val2 = val.LoadAsset<Shader>("Assets/Patchwork/Rotate.shader");
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.Logger.LogError((object)"[TexUtil] Rotate.shader missing from the assetbundle — rotated-sprite features degraded.");
			}
			else if (!val2.isSupported)
			{
				RotateShaderUnsupported = true;
				Plugin.Logger.LogError((object)("[TexUtil] Rotate.shader loaded but is NOT SUPPORTED on this GPU / graphics API " + $"(device: {SystemInfo.graphicsDeviceType}). The assetbundle is platform-specific and was " + "built for a different target. Sprite replacement falls back to a plain textured draw: unrotated sprites are pixel-identical, ROTATED atlas sprites are skipped (they need the shader's basis transform). Rotated-sprite dev tools are unavailable this session."));
			}
			else
			{
				RotateMaterial = new Material(val2);
			}
		}

		private static void EnsureRotateDrawMat()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			if (_rotateDrawResolved)
			{
				return;
			}
			_rotateDrawResolved = true;
			Shader val = Shader.Find("Hidden/BlitCopy");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Sprites/Default");
				if ((Object)(object)val != (Object)null)
				{
					Plugin.Logger.LogWarning((object)"[TexUtil] Hidden/BlitCopy not found — rotate draws fall back to Sprites/Default (alpha-blended, not opaque copy). Report this configuration.");
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogError((object)"[TexUtil] No blit shader resolvable — rotate draws unavailable.");
				return;
			}
			_rotateDrawMat = new Material(val)
			{
				hideFlags = (HideFlags)32
			};
		}

		public static void DrawRotated(Rect dest, Texture tex, Vector2 uB, Vector2 vB)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			EnsureRotateDrawMat();
			float uOff;
			float vOff;
			if (!((Object)(object)_rotateDrawMat == (Object)null))
			{
				_rotateDrawMat.mainTexture = tex;
				_rotateDrawMat.SetPass(0);
				uOff = ((uB.x + uB.y < 0f) ? 1f : 0f);
				vOff = ((vB.x + vB.y < 0f) ? 1f : 0f);
				GL.Begin(7);
				Corner(((Rect)(ref dest)).xMin, ((Rect)(ref dest)).yMin, 0f, 1f);
				Corner(((Rect)(ref dest)).xMax, ((Rect)(ref dest)).yMin, 1f, 1f);
				Corner(((Rect)(ref dest)).xMax, ((Rect)(ref dest)).yMax, 1f, 0f);
				Corner(((Rect)(ref dest)).xMin, ((Rect)(ref dest)).yMax, 0f, 0f);
				GL.End();
			}
			void Corner(float dx, float dy, float u, float v)
			{
				GL.TexCoord2(uB.x * u + uB.y * v + uOff, vB.x * u + vB.y * v + vOff);
				GL.Vertex3(dx, dy, 0f);
			}
		}

		public static bool SetPassTextured(Texture tex)
		{
			EnsureRotateDrawMat();
			if ((Object)(object)_rotateDrawMat == (Object)null)
			{
				return false;
			}
			_rotateDrawMat.mainTexture = tex;
			_rotateDrawMat.SetPass(0);
			return true;
		}

		public static RenderTexture GetReadable(Texture tex)
		{
			RenderTexture temporary = RenderTexture.GetTemporary(tex.width, tex.height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			Graphics.Blit(tex, temporary);
			return temporary;
		}

		public static RenderTextureReadWrite ReadWriteForSource(Texture source)
		{
			if (Plugin.Config.MatchOriginalColorSpace)
			{
				if (IsSRGBSource(source))
				{
					return (RenderTextureReadWrite)2;
				}
				return (RenderTextureReadWrite)1;
			}
			return (RenderTextureReadWrite)1;
		}

		public static bool IsSRGBSource(Texture source)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null)
			{
				return false;
			}
			RenderTexture val = (RenderTexture)(object)((source is RenderTexture) ? source : null);
			if (val != null)
			{
				return val.sRGB;
			}
			Texture2D val2 = (Texture2D)(object)((source is Texture2D) ? source : null);
			if (val2 != null)
			{
				return ((object)((Texture)val2).graphicsFormat/*cast due to .constrained prefix*/).ToString().EndsWith("_SRGB", StringComparison.Ordinal);
			}
			return false;
		}

		public static Texture2D LoadFromPNG(string path)
		{
			byte[] array = FileCache.ReadBytes(path);
			if (array == null)
			{
				return null;
			}
			Texture2D obj = CreateTextureFromBytes(array);
			if ((Object)(object)obj == (Object)null)
			{
				Plugin.Logger.LogWarning((object)("LoadFromPNG: Failed to decode image data from '" + path + "'"));
			}
			return obj;
		}

		public static Texture2D CreateTextureFromBytes(byte[] pngData, bool markNonReadable = true)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2);
			if (!ImageConversion.LoadImage(val, pngData))
			{
				Plugin.Logger.LogWarning((object)"CreateTextureFromBytes: Failed to load image data");
				Object.Destroy((Object)(object)val);
				return null;
			}
			((Texture)val).wrapMode = (TextureWrapMode)1;
			val.Apply(false, markNonReadable);
			((Object)val).hideFlags = (HideFlags)32;
			return val;
		}
	}
}
namespace Stitchwork.Packs
{
	public enum ConditionType
	{
		Scene,
		SceneContains,
		PackActive,
		CrestEquipped,
		NailUpgrade,
		PlayerData
	}
	public enum LogicJoin
	{
		Or,
		And
	}
	public enum ReloadTrigger
	{
		OnSceneTransition,
		HotReload
	}
	public class PackCondition
	{
		public static readonly (string Id, string DisplayName)[] KnownCrests = new(string, string)[9]
		{
			("Hunter", "Hunter"),
			("Reaper", "Reaper"),
			("Wanderer", "Wanderer"),
			("Spell", "Shaman"),
			("Toolmaster", "Architect"),
			("Warrior", "Beast"),
			("Witch", "Witch"),
			("Cursed", "Cursed"),
			("Cloakless", "Cloakless")
		};

		public static readonly (string Value, string DisplayName)[] KnownNailLevels = new(string, string)[9]
		{
			("pale", "Pale Steel Needle"),
			("hivesteel", "Hivesteel Needle"),
			("shining", "Shining Needle"),
			("sharpened", "Sharpened Needle"),
			("needle", "Needle"),
			(">=pale", "≥ Pale Steel Needle"),
			(">=hivesteel", "≥ Hivesteel Needle"),
			(">=shining", "≥ Shining Needle"),
			(">=sharpened", "≥ Sharpened Needle")
		};

		public ConditionType Type { get; set; }

		public string Value { get; set; } = "";

		public bool Negate { get; set; }

		public LogicJoin JoinNext { get; set; }

		public string TypeLabel => LabelFor(Type);

		public bool Evaluate(string sceneName, IReadOnlyList<PackInfo> allPacks)
		{
			HeroController instance = HeroController.instance;
			PlayerData val = (((Object)(object)instance == (Object)null) ? null : instance.playerData);
			bool flag = Type switch
			{
				ConditionType.Scene => string.Equals(sceneName, Value, StringComparison.OrdinalIgnoreCase), 
				ConditionType.SceneContains => sceneName.IndexOf(Value, StringComparison.OrdinalIgnoreCase) >= 0, 
				ConditionType.PackActive => allPacks.Any((PackInfo p) => p.IsEnabled && string.Equals(p.Name, Value, StringComparison.OrdinalIgnoreCase)), 
				ConditionType.CrestEquipped => CrestMatches(val?.CurrentCrestID, Value), 
				ConditionType.NailUpgrade => NailUpgradeMatches(val?.nailUpgrades ?? 0, Value), 
				ConditionType.PlayerData => EvaluatePlayerData(val, Value), 
				_ => true, 
			};
			if (!Negate)
			{
				return flag;
			}
			return !flag;
		}

		private static bool NailUpgradeMatches(int actual, string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			string text = value.Trim();
			string text2 = "==";
			if (text.StartsWith(">="))
			{
				text2 = ">=";
				text = text.Substring(2);
			}
			else if (text.StartsWith("<="))
			{
				text2 = "<=";
				text = text.Substring(2);
			}
			else if (text.StartsWith(">"))
			{
				text2 = ">";
				text = text.Substring(1);
			}
			else if (text.StartsWith("<"))
			{
				text2 = "<";
				text = text.Substring(1);
			}
			else if (text.StartsWith("=="))
			{
				text2 = "==";
				text = text.Substring(2);
			}
			int num = ParseNailLevel(text.Trim());
			if (num < 0)
			{
				return false;
			}
			return text2 switch
			{
				">=" => actual >= num, 
				"<=" => actual <= num, 
				">" => actual > num, 
				"<" => actual < num, 
				_ => actual == num, 
			};
		}

		private static bool EvaluatePlayerData(PlayerData pd, string expr)
		{
			if (pd == null || string.IsNullOrEmpty(expr))
			{
				return false;
			}
			if (!TryParseFieldExpr(expr, out var fieldName, out var op, out var target))
			{
				return false;
			}
			object value = PlayerDataCatalog.GetValue(pd, fieldName);
			if (value == null)
			{
				return false;
			}
			if (op == null)
			{
				if (value is bool)
				{
					return (bool)value;
				}
				if (value is int num)
				{
					return num != 0;
				}
				if (value is float num2)
				{
					return num2 != 0f;
				}
				if (value is string value2)
				{
					return !string.IsNullOrEmpty(value2);
				}
				return false;
			}
			return CompareValue(value, op, target);
		}

		private static bool TryParseFieldExpr(string expr, out string fieldName, out string op, out string target)
		{
			fieldName = expr.Trim();
			op = null;
			target = null;
			string[] array = new string[6] { ">=", "<=", "!=", ">", "<", "==" };
			foreach (string text in array)
			{
				int num = expr.IndexOf(text, StringComparison.Ordinal);
				if (num >= 0)
				{
					fieldName = expr.Substring(0, num).Trim();
					op = text;
					target = expr.Substring(num + text.Length).Trim();
					return true;
				}
			}
			return false;
		}

		private static bool CompareValue(object val, string op, string target)
		{
			if (val is bool flag)
			{
				bool flag2 = target.Equals("true", StringComparison.OrdinalIgnoreCase) || target == "1";
				if (!(op == "=="))
				{
					if (op == "!=")
					{
						return flag != flag2;
					}
					return flag == flag2;
				}
				return flag == flag2;
			}
			if (val is int num)
			{
				if (!int.TryParse(target, out var result))
				{
					return false;
				}
				return op switch
				{
					">=" => num >= result, 
					"<=" => num <= result, 
					"!=" => num != result, 
					">" => num > result, 
					"<" => num < result, 
					_ => num == result, 
				};
			}
			if (val is float num2)
			{
				if (!float.TryParse(target, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
				{
					return false;
				}
				return op switch
				{
					">=" => num2 >= result2, 
					"<=" => num2 <= result2, 
					"!=" => num2 != result2, 
					">" => num2 > result2, 
					"<" => num2 < result2, 
					_ => num2 == result2, 
				};
			}
			if (val is string strA)
			{
				int num3 = string.Compare(strA, target, StringComparison.OrdinalIgnoreCase);
				return op switch
				{
					">=" => num3 >= 0, 
					"<=" => num3 <= 0, 
					"!=" => num3 != 0, 
					">" => num3 > 0, 
					"<" => num3 < 0, 
					_ => num3 == 0, 
				};
			}
			return false;
		}

		private static int ParseNailLevel(string s)
		{
			switch (s.ToLowerInvariant())
			{
			case "0":
			case "needle":
				return 0;
			case "1":
			case "sharpened":
				return 1;
			case "2":
			case "shining":
				return 2;
			case "3":
			case "hivesteel":
				return 3;
			case "4":
			case "pale":
				return 4;
			default:
			{
				int result;
				return (int.TryParse(s, out result) && result >= 0) ? result : (-1);
			}
			}
		}

		private static bool CrestMatches(string currentID, string value)
		{
			if (currentID == null || string.IsNullOrEmpty(value))
			{
				return false;
			}
			if (string.Equals(currentID, value, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return currentID.StartsWith(value + "_", StringComparison.OrdinalIgnoreCase);
		}

		public PackCondition Clone()
		{
			return new PackCondition
			{
				Type = Type,
				Value = Value,
				Negate = Negate,
				JoinNext = JoinNext
			};
		}

		public static string CrestDisplayName(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return "—";
			}
			(string, string)[] knownCrests = KnownCrests;
			for (int i = 0; i < knownCrests.Length; i++)
			{
				var (a, result) = knownCrests[i];
				if (string.Equals(a, id, StringComparison.OrdinalIgnoreCase))
				{
					return result;
				}
			}
			return id;
		}

		public static string NailDisplayValue(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "—";
			}
			(string, string)[] knownNailLevels = KnownNailLevels;
			for (int i = 0; i < knownNailLevels.Length; i++)
			{
				var (a, result) = knownNailLevels[i];
				if (string.Equals(a, value, StringComparison.OrdinalIgnoreCase))
				{
					return result;
				}
			}
			return value;
		}

		public static string LabelFor(ConditionType type)
		{
			return type switch
			{
				ConditionType.Scene => "scene", 
				ConditionType.SceneContains => "scene~", 
				ConditionType.PackActive => "pack", 
				ConditionType.CrestEquipped => "crest", 
				ConditionType.NailUpgrade => "nail", 
				ConditionType.PlayerData => "pd", 
				_ => type.ToString(), 
			};
		}

		public static bool IsMidSceneType(ConditionType type)
		{
			if (type != ConditionType.CrestEquipped && type != ConditionType.NailUpgrade)
			{
				return type == ConditionType.PlayerData;
			}
			return true;
		}

		public string Serialize()
		{
			string text = ((JoinNext == LogicJoin.And) ? "and" : "or");
			return $"{TypeLabel}|{(Negate ? 1 : 0)}|{text}|{Value}";
		}

		public static PackCondition TryDeserialize(string token)
		{
			string[] array = token.Split('|');
			if (array.Length < 3)
			{
				return null;
			}
			ConditionType type = array[0] switch
			{
				"scene~" => ConditionType.SceneContains, 
				"pack" => ConditionType.PackActive, 
				"crest" => ConditionType.CrestEquipped, 
				"nail" => ConditionType.NailUpgrade, 
				"pd" => ConditionType.PlayerData, 
				_ => ConditionType.Scene, 
			};
			bool negate = array[1] == "1";
			LogicJoin joinNext = LogicJoin.Or;
			string value;
			if (array.Length >= 4 && (array[2] == "or" || array[2] == "and"))
			{
				joinNext = ((array[2] == "and") ? LogicJoin.And : LogicJoin.Or);
				value = string.Join("|", array, 3, array.Length - 3);
			}
			else
			{
				value = string.Join("|", array, 2, array.Length - 2);
			}
			return new PackCondition
			{
				Type = type,
				Negate = negate,
				JoinNext = joinNext,
				Value = value
			};
		}
	}
	public static class PackDoctor
	{
		public enum Severity
		{
			Error,
			Warn,
			Info
		}

		public readonly struct Finding
		{
			public readonly Severity Severity;

			public readonly string Rule;

			public readonly string RelPath;

			public readonly string Message;

			public Finding(Severity sev, string rule, string relPath, string message)
			{
				Severity = sev;
				Rule = rule;
				RelPath = relPath;
				Message = message;
			}
		}

		private const int MaxPerRule = 12;

		private static string[] ContentRoots => PackLayout.ContentRoots;

		public static string ScanAndReport(PackInfo pack)
		{
			if (pack == null || !Directory.Exists(pack.Path))
			{
				Plugin.Logger.LogWarning((object)("[PackDoctor] Pack folder missing: " + pack?.Path));
				return null;
			}
			List<Finding> list = Scan(pack.Path);
			string text = WriteReport(pack, list);
			Plugin.Logger.LogInfo((object)($"[PackDoctor] '{pack.Name}': {Count(list, Severity.Error)} error(s), " + $"{Count(list, Severity.Warn)} warning(s), {Count(list, Severity.Info)} note(s) → {text}"));
			return text;
		}

		private static int Count(List<Finding> f, Severity s)
		{
			return f.Count((Finding x) => x.Severity == s);
		}

		public static List<Finding> Scan(string packPath)
		{
			List<Finding> list = new List<Finding>();
			packPath = packPath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			if (PackLayout.IsCustomizerPack(packPath))
			{
				list.Add(new Finding(Severity.Info, "customizer-format", "", "Customizer-format skin (auto-adopted; read in place, never modified). Sheet-based art breaks when a game update repacks atlases — and the Dev Hub's Convert Sheets can only cut a sheet correctly WHILE it still matches the current game's layout. Convert EARLY, not later: the conversion window closes at the next atlas repack, after which the art needs manual re-authoring."));
				return list;
			}
			CheckRootsAndNesting(packPath, list);
			CheckManifest(packPath, list);
			CheckDebris(packPath, list);
			string text = FindRoot(packPath, "Sprites");
			if (text != null)
			{
				CheckSpriteTiers(packPath, text, list);
				CheckAnchorTags(packPath, text, list);
				CheckDumpsCrossReference(packPath, text, list);
			}
			string text2 = FindRoot(packPath, "Spritesheets");
			if (text2 != null)
			{
				CheckSheetTiers(packPath, text2, list);
			}
			string text3 = FindRoot(packPath, "Sounds");
			if (text3 != null)
			{
				CheckExtensions(packPath, text3, AudioHandler.SupportedExtensions, "audio", list);
			}
			string text4 = FindRoot(packPath, "Videos");
			if (text4 != null)
			{
				CheckExtensions(packPath, text4, VideoHandler.SupportedExtensions, "video", list);
			}
			string text5 = FindRoot(packPath, "Text");
			if (text5 != null)
			{
				CheckTextTree(packPath, text5, list);
			}
			string text6 = FindRoot(packPath, "Fonts");
			if (text6 != null)
			{
				CheckFontsTree(packPath, text6, list);
			}
			return list;
		}

		private static void CheckFontsTree(string packPath, string fontsRoot, List<Finding> f)
		{
			string[] files = Directory.GetFiles(fontsRoot, "*", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				bool flag = text.EndsWith(".ttf", StringComparison.OrdinalIgnoreCase) || text.EndsWith(".otf", StringComparison.OrdinalIgnoreCase);
				bool flag2 = string.Equals(Path.GetFileName(Path.GetDirectoryName(text)), "_fallback", StringComparison.OrdinalIgnoreCase);
				if (flag && !flag2)
				{
					f.Add(new Finding(Severity.Warn, "font-location", Rel(packPath, text), "Font file outside Fonts/_fallback/ — it will NOT be loaded. Move it to Fonts/_fallback/."));
				}
				else if (!flag && flag2 && !text.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) && !text.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
				{
					f.Add(new Finding(Severity.Warn, "font-ext", Rel(packPath, text), "Not a .ttf/.otf font — the fallback loader will skip this file."));
				}
			}
		}

		private static void CheckRootsAndNesting(string packPath, List<Finding> f)
		{
			bool flag = false;
			string[] directories = Directory.GetDirectories(packPath);
			for (int i = 0; i < directories.Length; i++)
			{
				string fileName = Path.GetFileName(directories[i]);
				string[] contentRoots = ContentRoots;
				foreach (string text in contentRoots)
				{
					if (string.Equals(fileName, text, StringComparison.OrdinalIgnoreCase))
					{
						flag = true;
						if (!string.Equals(fileName, text, StringComparison.Ordinal))
						{
							f.Add(new Finding(Severity.Warn, "root-case", fileName, "folder is '" + fileName + "' but the canonical name is '" + text + "' — works on Windows, silently ignored on case-sensitive hosts (Linux/Steam Deck). Rename it."));
						}
					}
				}
			}
			if (flag)
			{
				return;
			}
			directories = Directory.GetDirectories(packPath);
			foreach (string path in directories)
			{
				string[] contentRoots = Directory.GetDirectories(path);
				foreach (string path2 in contentRoots)
				{
					string subName = Path.GetFileName(path2);
					if (ContentRoots.Any((string r) => string.Equals(subName, r, StringComparison.OrdinalIgnoreCase)))
					{
						f.Add(new Finding(Severity.Error, "nesting", Path.GetFileName(path), "no content roots at the pack root, but '" + Path.GetFileName(path) + "/" + subName + "/' exists — content is nested one level too deep (typical zip-in-zip). Move it up."));
						return;
					}
				}
			}
			f.Add(new Finding(Severity.Error, "nesting", "", "no Stitchwork content found (no Sprites/, Spritesheets/, Sounds/, Videos/ or Text/ folder). Nothing in this pack will load."));
		}

		private static void CheckManifest(string packPath, List<Finding> f)
		{
			string path = Path.Combine(packPath, "pack.json");
			if (!File.Exists(path))
			{
				f.Add(new Finding(Severity.Info, "manifest", "pack.json", "no pack.json — the pack works, but without one users LOSE its enable-state/order/conditions when the folder is renamed or a new version ships under a new folder. Add {\"name\": \"…\", \"author\": \"…\"} to give it a durable identity."));
			}
			else if (File.ReadAllText(path).IndexOf("\"name\"", StringComparison.OrdinalIgnoreCase) < 0)
			{
				f.Add(new Finding(Severity.Warn, "manifest", "pack.json", "pack.json has no \"name\" field — display name falls back to the folder name and stable identity degrades with it."));
			}
		}

		private static void CheckDebris(string packPath, List<Finding> f)
		{
			string[] directories = Directory.GetDirectories(packPath, "*_WIP", SearchOption.AllDirectories);
			foreach (string full in directories)
			{
				f.Add(new Finding(Severity.Warn, "debris", Rel(packPath, full), "animation-canvas _WIP folder in a shipping pack — the loader skips it, but it bloats the download and confuses users. Delete before shipping (keep your local copy)."));
			}
			directories = Directory.GetFiles(packPath, "anchors.txt", SearchOption.AllDirectories);
			foreach (string full2 in directories)
			{
				f.Add(new Finding(Severity.Warn, "debris", Rel(packPath, full2), "legacy anchors.txt — no longer read (filename tags @t/@b/@l/@r/@c replaced it). Delete."));
			}
			directories = Directory.GetDirectories(packPath, "*", SearchOption.AllDirectories);
			foreach (string text in directories)
			{
				string fileName = Path.GetFileName(text);
				if (string.Equals(fileName, "Dumps", StringComparison.OrdinalIgnoreCase) || string.Equals(fileName, "TextDumps", StringComparison.OrdinalIgnoreCase))
				{
					f.Add(new Finding(Severity.Warn, "debris", Rel(packPath, text), "a dumps folder inside the pack — dumps are working material, not pack content. Don't ship them."));
				}
			}
		}

		private static void CheckSpriteTiers(string packPath, string spritesRoot, List<Finding> f)
		{
			foreach (string item in EnumerateNonWip(spritesRoot))
			{
				string text = Rel(spritesRoot, item);
				string[] array = text.Split('/');
				string text2 = Path.GetExtension(item).ToLowerInvariant();
				if (text2 != ".png")
				{
					if (!text.EndsWith("_sidecar.yml", StringComparison.OrdinalIgnoreCase))
					{
						f.Add(new Finding(Severity.Warn, "sprite-tier", Rel(packPath, item), "non-PNG file under Sprites/ — ignored by the loader (" + text2 + ")."));
					}
				}
				else if (Path.GetFileNameWithoutExtension(item).EndsWith(".png", StringComparison.OrdinalIgnoreCase))
				{
					f.Add(new Finding(Severity.Error, "sprite-double-ext", Rel(packPath, item), "doubled extension — the sprite name includes '.png' and will never match a game sprite. Rename to a single .png."));
				}
				else if (string.Equals(array[0], "T2D", StringComparison.OrdinalIgnoreCase))
				{
					if (array.Length > 3)
					{
						f.Add(new Finding(Severity.Error, "t2d-tier", Rel(packPath, item), "T2D sprite nested too deep — the T2D loader scans one atlas folder deep: Sprites/T2D/<Atlas>/<sprite>.png, Sprites/T2D/_standalone/<tex>.png, or flat Sprites/T2D/<sprite>.png. This file will not load."));
					}
					else if (array.Length == 2)
					{
						f.Add(new Finding(Severity.Info, "t2d-flat", Rel(packPath, item), "flat T2D sprite — loads fine, but matches by name across ALL atlases; if two atlases share this sprite name, qualify it: Sprites/T2D/<Atlas>/<sprite>.png."));
					}
				}
				else if (array.Any((string s) => string.Equals(s, "Clips", StringComparison.OrdinalIgnoreCase)))
				{
					if (array.Length != 4 || !string.Equals(array[1], "Clips", StringComparison.OrdinalIgnoreCase))
					{
						f.Add(new Finding(Severity.Error, "clips-shape", Rel(packPath, item), "a 'Clips' folder outside the per-clip shape — expected exactly Sprites/<Collection>/Clips/<ClipName>/<sprite>.png. This file will not load."));
					}
				}
				else if (array.Length != 3)
				{
					f.Add(new Finding(Severity.Error, "sprite-tier", Rel(packPath, item), (array.Length < 3) ? "sprite PNG above the required tier — expected Sprites/<Collection>/<Material>/<sprite>.png. Silently ignored." : "sprite PNG nested too deep — expected Sprites/<Collection>/<Material>/<sprite>.png. Silently ignored."));
				}
			}
		}

		private static void CheckSheetTiers(string packPath, string sheetsRoot, List<Finding> f)
		{
			foreach (string item in EnumerateNonWip(sheetsRoot))
			{
				string text = Rel(sheetsRoot, item);
				if (Path.GetExtension(item).ToLowerInvariant() != ".png")
				{
					f.Add(new Finding(Severity.Warn, "sheet-tier", Rel(packPath, item), "non-PNG file under Spritesheets/ — ignored by the loader."));
				}
				else if (Path.GetFileNameWithoutExtension(item).EndsWith(".png", StringComparison.OrdinalIgnoreCase))
				{
					f.Add(new Finding(Severity.Error, "sheet-double-ext", Rel(packPath, item), "doubled extension — the sheet name includes '.png' and will never match a material. Rename to a single .png."));
				}
				else if (text.Split('/').Length != 2)
				{
					f.Add(new Finding(Severity.Error, "sheet-tier", Rel(packPath, item), "spritesheet at the wrong tier — expected Spritesheets/<Collection>/<Material>.png. Silently ignored."));
				}
			}
		}

		private static void CheckAnchorTags(string packPath, string spritesRoot, List<Finding> f)
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			foreach (string item in EnumerateNonWip(spritesRoot))
			{
				if (Path.GetExtension(item).ToLowerInvariant() != ".png")
				{
					continue;
				}
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
				(string name, string anchor) tuple = IOUtil.ParseAnchorTag(fileNameWithoutExtension);
				var (text, _) = tuple;
				if (tuple.anchor == null && fileNameWithoutExtension.Contains('@'))
				{
					string text2 = fileNameWithoutExtension.Substring(fileNameWithoutExtension.LastIndexOf('@') + 1);
					if (text2.Length > 0 && (text2[0] == 'p' || text2[0] == 'P') && text2.Skip(1).All((char c) => char.IsDigit(c) || c == '_' || c == '-'))
					{
						f.Add(new Finding(Severity.Error, "tag", Rel(packPath, item), "'@" + text2 + "' looks like a precise-pivot tag but doesn't parse — the format is @p<px>_<py> (e.g. @p112_108). As-is the '@' stays in the sprite name and it never matches."));
					}
					else if (text2.Length == 1)
					{
						f.Add(new Finding(Severity.Warn, "tag", Rel(packPath, item), "'@" + text2 + "' is not a valid anchor letter (valid: @t @b @l @r @c) — the '@' stays in the sprite name."));
					}
				}
				string key = Path.GetDirectoryName(item) + "/" + text;
				List<string> list3;
				if (!dictionary.TryGetValue(key, out var value))
				{
					List<string> list = (dictionary[key] = new List<string>());
					list3 = list;
				}
				else
				{
					list3 = value;
				}
				list3.Add(fileNameWithoutExtension);
			}
			foreach (KeyValuePair<string, List<string>> item2 in dictionary.Where((KeyValuePair<string, List<string>> k) => k.Value.Count > 1))
			{
				f.Add(new Finding(Severity.Warn, "tag-conflict", Rel(packPath, Path.GetDirectoryName(item2.Key + ".x")), "multiple tag variants of one sprite (" + string.Join(", ", item2.Value) + ") — first-wins alphabetically; keep exactly one."));
			}
		}

		private static void CheckExtensions(string packPath, string root, string[] supported, string kind, List<Finding> f)
		{
			string[] files = Directory.GetFiles(root, "*.*", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				string text2 = Path.GetExtension(text).ToLowerInvariant();
				if (Array.IndexOf(supported, text2) < 0)
				{
					f.Add(new Finding(Severity.Error, kind + "-format", Rel(packPath, text), "unsupported " + kind + " format '" + text2 + "' — will not load. Supported: " + string.Join(" ", supported) + "."));
					continue;
				}
				string text3 = Path.GetExtension(Path.GetFileNameWithoutExtension(text)).ToLowerInvariant();
				if (text3.Length > 0 && Array.IndexOf(supported, text3) >= 0)
				{
					f.Add(new Finding(Severity.Error, kind + "-double-ext", Rel(packPath, text), "doubled extension — the " + kind + " name includes '" + text3 + "' and will never match a game clip. Rename to strip the inner extension (Silently ignored otherwise)."));
				}
			}
		}

		private static void CheckTextTree(string packPath, string textRoot, List<Finding> f)
		{
			string[] files = Directory.GetFiles(textRoot, "*.*", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				string text2 = Rel(textRoot, text);
				if (!text2.EndsWith(".yml", StringComparison.OrdinalIgnoreCase))
				{
					f.Add(new Finding(Severity.Warn, "text-tier", Rel(packPath, text), "non-.yml file under Text/ — ignored by the loader."));
				}
				else if (text2.Split('/').Length != 2)
				{
					f.Add(new Finding(Severity.Error, "text-tier", Rel(packPath, text), "text file at the wrong tier — expected Text/<SheetName>/<LANG>.yml. Silently ignored."));
				}
				else if (!File.ReadLines(text).Any(delegate(string l)
				{
					string text3 = l.TrimStart();
					if (text3.Length == 0 || text3[0] == '#')
					{
						return false;
					}
					int num = text3.IndexOf(':');
					return num > 0 && text3.Substring(num + 1).TrimStart().StartsWith("\"");
				}))
				{
					f.Add(new Finding(Severity.Warn, "text-empty", Rel(packPath, text), "no KEY: \"value\" entries found — the file contributes nothing."));
				}
			}
		}

		private static void CheckDumpsCrossReference(string packPath, string spritesRoot, List<Finding> f)
		{
			string dumpPath = SpriteDumper.DumpPath;
			if (!Directory.Exists(dumpPath))
			{
				return;
			}
			string[] directories = Directory.GetDirectories(spritesRoot);
			foreach (string text in directories)
			{
				string fileName = Path.GetFileName(text);
				string text2 = Path.Combine(dumpPath, fileName);
				if (!Directory.Exists(text2))
				{
					f.Add(new Finding(Severity.Info, "dumps-xref", Rel(packPath, text), "collection '" + fileName + "' isn't in your Dumps/ — possible typo, or your dumps are partial."));
					continue;
				}
				string[] directories2 = Directory.GetDirectories(text);
				foreach (string text3 in directories2)
				{
					string fileName2 = Path.GetFileName(text3);
					if (string.Equals(fileName2, "Clips", StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					string text4 = Path.Combine(text2, fileName2);
					if (!Directory.Exists(text4))
					{
						f.Add(new Finding(Severity.Warn, "dumps-xref", Rel(packPath, text3), "material '" + fileName2 + "' isn't under Dumps/" + fileName + "/ — possible typo (or a deliberate instance-specific vanilla-texture path, which dumps don't key by)."));
						continue;
					}
					string[] files = Directory.GetFiles(text3, "*.png");
					foreach (string text5 in files)
					{
						string item = IOUtil.ParseAnchorTag(Path.GetFileNameWithoutExtension(text5)).name;
						if (!File.Exists(Path.Combine(text4, item + ".png")))
						{
							f.Add(new Finding(Severity.Warn, "dumps-xref", Rel(packPath, text5), "sprite '" + item + "' isn't in Dumps/" + fileName + "/" + fileName2 + "/ — possible typo in the sprite name."));
						}
					}
				}
			}
		}

		private static string WriteReport(PackInfo pack, List<Finding> findings)
		{
			string text = Path.Combine(Plugin.BasePath, "doctor-reports");
			IOUtil.EnsureDirectoryExists(text);
			string text2 = Path.Combine(text, T2DUtil.SanitizeForFilesystem(pack.Name) + ".txt");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Stitchwork Pack Doctor — " + pack.Name);
			stringBuilder.AppendLine(pack.Path);
			stringBuilder.AppendLine(string.Format("{0:yyyy-MM-dd HH:mm}   Stitchwork {1}", DateTime.Now, "0.8.6"));
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"Result: {Count(findings, Severity.Error)} error(s), " + $"{Count(findings, Severity.Warn)} warning(s), {Count(findings, Severity.Info)} note(s)");
			if (findings.Count == 0)
			{
				stringBuilder.AppendLine().AppendLine("Clean bill of health — nothing to report.");
			}
			Severity[] array = new Severity[3]
			{
				Severity.Error,
				Severity.Warn,
				Severity.Info
			};
			for (int i = 0; i < array.Length; i++)
			{
				Severity sev = array[i];
				List<Finding> list = findings.Where((Finding x) => x.Severity == sev).ToList();
				if (list.Count == 0)
				{
					continue;
				}
				stringBuilder.AppendLine();
				stringBuilder.AppendLine($"═══ {sev.ToString().ToUpperInvariant()} ({list.Count}) ═══");
				foreach (IGrouping<string, Finding> item in from x in list
					group x by x.Rule)
				{
					foreach (Finding item2 in item.Take(12))
					{
						stringBuilder.AppendLine("  [" + item2.Rule + "] " + item2.RelPath + "\n      " + item2.Message);
					}
					if (item.Count() > 12)
					{
						stringBuilder.AppendLine($"  [{item.Key}] … and {item.Count() - 12} more like this.");
					}
				}
			}
			File.WriteAllText(text2, stringBuilder.ToString());
			return text2;
		}

		private static string FindRoot(string packPath, string root)
		{
			string[] directories = Directory.GetDirectories(packPath);
			foreach (string text in directories)
			{
				if (string.Equals(Path.GetFileName(text), root, StringComparison.OrdinalIgnoreCase))
				{
					return text;
				}
			}
			return null;
		}

		private static IEnumerable<string> EnumerateNonWip(string root)
		{
			string[] files = Directory.GetFiles(root, "*.*", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				if (text.IndexOf("_WIP" + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("_WIP" + Path.AltDirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) < 0)
				{
					yield return text;
				}
			}
		}

		private static string Rel(string root, string full)
		{
			return full.Substring(root.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).Replace('\\', '/');
		}
	}
	public enum PackSource
	{
		Plugin,
		Customizer,
		Global
	}
	public class PackInfo
	{
		private string _effAuthor;

		private bool _effAuthorComputed;

		private string _stableId;

		public string Path { get; }

		public string Name { get; }

		public string Author { get; }

		public string EffectiveAuthor
		{
			get
			{
				if (!_effAuthorComputed)
				{
					_effAuthor = ComputeEffectiveAuthor();
					_effAuthorComputed = true;
				}
				return _effAuthor;
			}
		}

		public string Version { get; }

		public string Description { get; }

		public bool IsEnabled { get; set; }

		public PackSource Source { get; }

		public string StableId => _stableId ?? (_stableId = SanitizeId(string.IsNullOrEmpty(Author) ? Name : (Author + "/" + Name)));

		public PackStats Stats { get; set; }

		public List<PackCondition> Conditions { get; set; } = new List<PackCondition>();

		public ReloadTrigger ReloadTrigger { get; set; }

		public bool HasConditions => Conditions.Count > 0;

		private string ComputeEffectiveAuthor()
		{
			if (!string.IsNullOrEmpty(Author))
			{
				return Author;
			}
			if (Source == PackSource.Customizer)
			{
				return null;
			}
			string fileName = System.IO.Path.GetFileName(System.IO.Path.GetDirectoryName(Path));
			if (string.IsNullOrEmpty(fileName))
			{
				return null;
			}
			int num = fileName.IndexOf('-');
			if (num <= 0 || num >= fileName.Length - 1)
			{
				return null;
			}
			if (char.IsDigit(fileName.Substring(num + 1)[0]))
			{
				return null;
			}
			return fileName.Substring(0, num);
		}

		private static string SanitizeId(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			return s.Replace('|', '_').Replace('\t', ' ').Replace('\n', ' ')
				.Replace('\r', ' ');
		}

		public bool EvaluateConditions(string sceneName, IReadOnlyList<PackInfo> allPacks)
		{
			if (!HasConditions)
			{
				return true;
			}
			bool flag = true;
			bool result = false;
			for (int i = 0; i < Conditions.Count; i++)
			{
				flag &= Conditions[i].Evaluate(sceneName, allPacks);
				if (i == Conditions.Count - 1 || Conditions[i].JoinNext == LogicJoin.Or)
				{
					if (flag)
					{
						result = true;
					}
					flag = true;
				}
			}
			return result;
		}

		public PackInfo(string path, string name, PackSource source, string author = null, string version = null, string description = null)
		{
			Path = path;
			Name = name;
			Source = source;
			Author = author;
			Version = version;
			Description = description;
		}

		public PackInfo Clone()
		{
			return new PackInfo(Path, Name, Source, Author, Version, Description)
			{
				IsEnabled = IsEnabled,
				Stats = Stats,
				Conditions = Conditions.Select((PackCondition c) => c.Clone()).ToList(),
				ReloadTrigger = ReloadTrigger
			};
		}
	}
	public static class PackLayout
	{
		public static readonly string[] ContentRoots = new string[7] { "Sprites", "Spritesheets", "Sounds", "Videos", "Text", "Fonts", "Recolour" };

		private static string _customizerRoot;

		private static string _globalPacksRoot;

		private static string _customizerRootFull;

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

		public static string CustomizerRoot => _customizerRoot ?? (_customizerRoot = Path.Combine(Application.dataPath, "Mods", "Customizer"));

		public static string GlobalPacksRoot
		{
			get
			{
				string globalPacksPath = Plugin.Config.GlobalPacksPath;
				if (!string.IsNullOrWhiteSpace(globalPacksPath))
				{
					return globalPacksPath.Trim();
				}
				return _globalPacksRoot ?? (_globalPacksRoot = Path.Combine(Path.GetDirectoryName(Application.dataPath) ?? Application.dataPath, "Packs"));
			}
		}

		public static void ClearMarkerRoots()
		{
			_markerRoots.Clear();
		}

		public static void RegisterMarkerRoot(string packPath)
		{
			_markerRoots.Add(Path.GetFullPath(packPath));
		}

		public static bool IsMarkerRoot(string packPath)
		{
			if (!string.IsNullOrEmpty(packPath))
			{
				return _markerRoots.Contains(Path.GetFullPath(packPath));
			}
			return false;
		}

		public static bool IsCustomizerPack(string packPath)
		{
			if (string.IsNullOrEmpty(packPath))
			{
				return false;
			}
			string fullPath = Path.GetFullPath(packPath);
			if (_markerRoots.Contains(fullPath))
			{
				return true;
			}
			if (_customizerRootFull == null)
			{
				_customizerRootFull = Path.GetFullPath(CustomizerRoot);
			}
			return fullPath.StartsWith(_customizerRootFull, StringComparison.OrdinalIgnoreCase);
		}

		public static bool LooksLikeCustomizerSkin(string dir)
		{
			if (!File.Exists(Path.Combine(dir, "active.txt")))
			{
				return false;
			}
			if (Directory.EnumerateFiles(dir, "*.dll").Any())
			{
				return false;
			}
			if (!Directory.EnumerateDirectories(dir).Any((string sub) => (!string.Equals(Path.GetFileName(sub), "Texture2D", StringComparison.OrdinalIgnoreCase)) ? Directory.EnumerateFiles(sub, "atlas*.png").Any() : Directory.EnumerateFiles(sub, "*.png").Any()) && !Directory.EnumerateFiles(dir, "sactx-*.png").Any())
			{
				return Directory.EnumerateFiles(dir, "atlas*.png").Any();
			}
			return true;
		}

		public static bool IsPackagingAsset(string filePath)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
			if (!fileNameWithoutExtension.Equals("icon", StringComparison.OrdinalIgnoreCase) && !fileNameWithoutExtension.Equals("logo", StringComparison.OrdinalIgnoreCase))
			{
				return fileNameWithoutExtension.StartsWith("library_", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		public static string SheetsRoot(string packPath)
		{
			if (!IsCustomizerPack(packPath))
			{
				return Path.Combine(packPath, "Spritesheets");
			}
			return packPath;
		}

		public static string T2DSheetsRoot(string packPath)
		{
			if (!IsCustomizerPack(packPath))
			{
				return Path.Combine(packPath, "Spritesheets", "T2D");
			}
			return Path.Combine(packPath, "Texture2D");
		}

		public static string VideosRoot(string packPath)
		{
			if (!IsCustomizerPack(packPath))
			{
				return Path.Combine(packPath, "Videos");
			}
			return packPath;
		}
	}
	public static class PackManager
	{
		private static readonly List<PackInfo> _packs = new List<PackInfo>();

		private static string _currentScene = "";

		private static readonly Dictionary<string, bool> _prevConditionalStates = new Dictionary<string, bool>();

		private static List<string> _activePackPathsCache;

		private static List<PackInfo> _hotReloadPacksCache;

		private static readonly string[] PackSubfolderNames = new string[2] { "Stitchwork", "Patchwork" };

		private static bool _legacyStateSeen;

		private static string ConfigPath => Path.Combine(Plugin.BasePath, "packs.txt");

		private static string StatsCachePath => Path.Combine(Plugin.BasePath, "packs-stats.txt");

		private static string ProfilesDir => Path.Combine(Plugin.BasePath, "Profiles");

		private static string ConditionsPath => Path.Combine(Plugin.BasePath, "packs-conditions.txt");

		public static IReadOnlyList<PackInfo> AllPacks => _packs;

		public static IReadOnlyList<string> ActivePackPaths
		{
			get
			{
				if (_activePackPathsCache == null)
				{
					_activePackPathsCache = new List<string>();
					foreach (PackInfo pack in _packs)
					{
						if (pack.IsEnabled && (!pack.HasConditions || pack.EvaluateConditions(_currentScene, _packs)))
						{
							_activePackPathsCache.Add(pack.Path);
						}
					}
				}
				return _activePackPathsCache;
			}
		}

		private static List<PackInfo> HotReloadPacks
		{
			get
			{
				if (_hotReloadPacksCache == null)
				{
					_hotReloadPacksCache = new List<PackInfo>();
					foreach (PackInfo pack in _packs)
					{
						if (pack.HasConditions && pack.ReloadTrigger == ReloadTrigger.HotReload)
						{
							_hotReloadPacksCache.Add(pack);
						}
					}
				}
				return _hotReloadPacksCache;
			}
		}

		public static bool HasHotReloadPacks => HotReloadPacks.Count > 0;

		private static void InvalidateActivePathsCache()
		{
			_activePackPathsCache = null;
			_hotReloadPacksCache = null;
		}

		public static void Initialize()
		{
			MergeWithSavedConfig(DiscoverAll());
			LoadStatsCache();
			ScanMissingStats();
			LoadConditions();
			if (_legacyStateSeen)
			{
				SaveConfig();
				SaveConditions();
				_legacyStateSeen = false;
				Plugin.Logger.LogInfo((object)"[PackManager] packs.txt / packs-conditions.txt upgraded to stable-id format.");
			}
		}

		private static List<PackInfo> DiscoverAll()
		{
			List<PackInfo> list = new List<PackInfo>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string[] packSubfolderNames = PackSubfolderNames;
			foreach (string searchPattern in packSubfolderNames)
			{
				string[] directories = Directory.GetDirectories(Paths.PluginPath, searchPattern, SearchOption.AllDirectories);
				foreach (string text in directories)
				{
					if (!SamePath(text, Plugin.BasePath) && hashSet.Add(text))
					{
						list.Add(ReadManifest(text, PackSource.Plugin));
					}
				}
			}
			string globalPacksRoot = PackLayout.GlobalPacksRoot;
			try
			{
				Directory.CreateDirectory(globalPacksRoot);
			}
			catch (Exception ex) when (ex is UnauthorizedAccessException || ex is IOException)
			{
				Plugin.Logger.LogWarning((object)("[PackManager] Global packs root not creatable: " + globalPacksRoot + " — " + ex.Message));
			}
			int num = 0;
			if (Directory.Exists(globalPacksRoot))
			{
				packSubfolderNames = PackSubfolderNames;
				foreach (string searchPattern2 in packSubfolderNames)
				{
					string[] directories = Directory.GetDirectories(globalPacksRoot, searchPattern2, SearchOption.AllDirectories);
					foreach (string text2 in directories)
					{
						if (hashSet.Add(text2))
						{
							list.Add(ReadManifest(text2, PackSource.Global));
							num++;
						}
					}
				}
			}
			Plugin.Logger.LogInfo((object)$"[PackManager] Global packs root: {globalPacksRoot} — {num} pack(s)");
			if (Plugin.CustomizerPluginPresent)
			{
				if (Directory.Exists(PackLayout.CustomizerRoot))
				{
					Plugin.Logger.LogWarning((object)"[PackManager] Customizer plugin is loaded — NOT auto-adopting its skins. Remove the Customizer plugin (Stitchwork replaces it) and its skins will appear here automatically.");
				}
			}
			else if (Directory.Exists(PackLayout.CustomizerRoot))
			{
				packSubfolderNames = Directory.GetDirectories(PackLayout.CustomizerRoot);
				foreach (string path in packSubfolderNames)
				{
					list.Add(ReadManifest(path, PackSource.Customizer));
				}
			}
			PackLayout.ClearMarkerRoots();
			foreach (string item in CustomizerMarkerCandidates())
			{
				if (hashSet.Add(item))
				{
					PackLayout.RegisterMarkerRoot(item);
					Plugin.Logger.LogInfo((object)("[PackManager] Adopted Customizer-format skin (active.txt marker): " + item));
					list.Add(ReadManifest(item, PackSource.Customizer));
				}
			}
			return list;
		}

		private static IEnumerable<string> CustomizerMarkerCandidates()
		{
			string[] directories = Directory.GetDirectories(Paths.PluginPath);
			foreach (string top in directories)
			{
				if (SamePath(top, Plugin.BasePath) || PackSubfolderNames.Any((string n) => Directory.Exists(Path.Combine(top, n))))
				{
					continue;
				}
				if (PackLayout.LooksLikeCustomizerSkin(top))
				{
					yield return top;
					continue;
				}
				string[] directories2 = Directory.GetDirectories(top);
				foreach (string nested in directories2)
				{
					if (!PackSubfolderNames.Any((string n) => Directory.Exists(Path.Combine(nested, n))) && PackLayout.LooksLikeCustomizerSkin(nested))
					{
						yield return nested;
					}
				}
			}
		}

		private static bool SamePath(string a, string b)
		{
			if (string.IsNullOrEmpty(a) || string.IsNullOrEmpty(b))
			{
				return false;
			}
			return string.Equals(Path.GetFullPath(a).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), Path.GetFullPath(b).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), StringComparison.OrdinalIgnoreCase);
		}

		private static PackInfo ReadManifest(string path, PackSource source)
		{
			string text = Path.Combine(path, "pack.json");
			if (!File.Exists(text))
			{
				string fileName = Path.GetFileName(path);
				bool flag = false;
				string[] packSubfolderNames = PackSubfolderNames;
				foreach (string b in packSubfolderNames)
				{
					if (string.Equals(fileName, b, StringComparison.OrdinalIgnoreCase))
					{
						flag = true;
						break;
					}
				}
				string name;
				if (flag)
				{
					string fileName2 = Path.GetFileName(Path.GetDirectoryName(path));
					name = (string.IsNullOrEmpty(fileName2) ? fileName : fileName2);
				}
				else
				{
					name = fileName;
				}
				return new PackInfo(path, name, source);
			}
			try
			{
				string json = File.ReadAllText(text);
				string text2 = ParseJsonString(json, "name");
				string author = ParseJsonString(json, "author");
				string version = ParseJsonString(json, "version");
				string description = ParseJsonString(json, "description");
				if (text2 == null)
				{
					Plugin.Logger.LogWarning((object)("[PackManager] pack.json at '" + text + "' has no 'name' field — using folder name"));
				}
				return new PackInfo(path, text2 ?? Path.GetFileName(path), source, author, version, description);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[PackManager] Failed to read '" + text + "': " + ex.Message + " — using folder name"));
				return new PackInfo(path, Path.GetFileName(path), source);
			}
		}

		private static string ParseJsonString(string json, string key)
		{
			string text = "\"" + key + "\"";
			int num = json.IndexOf(text, StringComparison.OrdinalIgnoreCase);
			if (num < 0)
			{
				return null;
			}
			int num2 = json.IndexOf(':', num + text.Length);
			if (num2 < 0)
			{
				return null;
			}
			int num3 = -1;
			for (int i = num2 + 1; i < json.Length; i++)
			{
				switch (json[i])
				{
				case '"':
					break;
				default:
					return null;
				case '\t':
				case '\n':
				case '\r':
				case ' ':
					continue;
				}
				num3 = i;
				break;
			}
			if (num3 < 0)
			{
				return null;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int j = num3 + 1; j < json.Length; j++)
			{
				char c = json[j];
				if (c == '\\' && j + 1 < json.Length)
				{
					char c2 = json[++j];
					switch (c2)
					{
					case '"':
						stringBuilder.Append('"');
						break;
					case '\\':
						stringBuilder.Append('\\');
						break;
					case '/':
						stringBuilder.Append('/');
						break;
					case 'n':
						stringBuilder.Append('\n');
						break;
					case 'r':
						stringBuilder.Append('\r');
						break;
					case 't':
						stringBuilder.Append('\t');
						break;
					default:
						stringBuilder.Append('\\');
						stringBuilder.Append(c2);
						break;
					}
				}
				else
				{
					if (c == '"')
					{
						return stringBuilder.ToString();
					}
					stringBuilder.Append(c);
				}
			}
			return null;
		}

		private static PackInfo FindByIdentity(IReadOnlyList<PackInfo> candidates, string id, string path)
		{
			if (!string.IsNullOrEmpty(id))
			{
				PackInfo packInfo = null;
				bool flag = false;
				foreach (PackInfo candidate in candidates)
				{
					if (string.Equals(candidate.StableId, id, StringComparison.OrdinalIgnoreCase))
					{
						if (packInfo != null)
						{
							flag = true;
							break;
						}
						packInfo = candidate;
					}
				}
				if (packInfo != null && !flag)
				{
					return packInfo;
				}
			}
			if (!string.IsNullOrEmpty(path))
			{
				foreach (PackInfo candidate2 in candidates)
				{
					if (string.Equals(candidate2.Path, path, StringComparison.OrdinalIgnoreCase))
					{
						return candidate2;
					}
				}
			}
			return null;
		}

		private static (string Id, string Path) ParseIdentityField(string field)
		{
			int num = field.IndexOf('|');
			if (num >= 0)
			{
				return (Id: field.Substring(0, num), Path: field.Substring(num + 1));
			}
			_legacyStateSeen = true;
			return (Id: null, Path: field);
		}

		private static void MergeWithSavedConfig(List<PackInfo> discovered)
		{
			_packs.Clear();
			if (!File.Exists(ConfigPath))
			{
				_packs.AddRange(discovered);
				return;
			}
			try
			{
				string[] array = File.ReadAllLines(ConfigPath);
				foreach (string text in array)
				{
					if (!string.IsNullOrWhiteSpace(text) && !text.StartsWith("#") && text.Length >= 3 && text[1] == '|')
					{
						bool isEnabled = text[0] == '+';
						(string Id, string Path) tuple = ParseIdentityField(text.Substring(2));
						string item = tuple.Id;
						string item2 = tuple.Path;
						PackInfo packInfo = FindByIdentity(discovered, item, item2);
						if (packInfo != null)
						{
							packInfo.IsEnabled = isEnabled;
							_packs.Add(packInfo);
							discovered.Remove(packInfo);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[PackManager] Failed to read packs.txt: " + ex.Message));
			}
			_packs.AddRange(discovered);
		}

		public static void SaveConfig()
		{
			List<string> list = new List<string> { "# Stitchwork Pack Order — top of list = highest priority", "# Format: +|id|path (enabled)   or   -|id|path (disabled)", "# id = stable pack identity (pack.json author/name); path = fallback for duplicates" };
			foreach (PackInfo pack in _packs)
			{
				list.Add($"{(pack.IsEnabled ? '+' : '-')}|{pack.StableId}|{pack.Path}");
			}
			File.WriteAllLines(ConfigPath, list);
		}

		public static void Apply(List<PackInfo> staged)
		{
			_packs.Clear();
			_packs.AddRange(staged);
			InvalidateActivePathsCache();
			SaveConfig();
			SaveConditions();
			ConflictTracker.Clear();
			TriggerFullReload();
			if (GameBridge.IsInGameScene)
			{
				ReloadCoordinator.RequestSceneReloadAfterDrain();
				Plugin.Logger.LogInfo((object)"[PackManager] Apply: watcher flags raised; scene reload armed (dispatches after reloads drain).");
			}
			else
			{
				Plugin.Logger.LogInfo((object)"[PackManager] Apply: watcher flags raised; scene-transition dispatch skipped (menu context — BeginSceneTransition would break menu input routing).");
			}
			ScanAllStats();
			Plugin.Logger.LogDebug((object)($"[PackManager] Applied pack order: {_packs.Count} packs, " + $"{_packs.Count((PackInfo p) => p.IsEnabled)} enabled"));
		}

		public static void Rescan()
		{
			InvalidateActivePathsCache();
			ConflictTracker.Clear();
			List<PackInfo> discovered = DiscoverAll();
			_packs.RemoveAll((PackInfo p) => !discovered.Any((PackInfo packInfo) => string.Equals(p.Path, packInfo.Path, StringComparison.OrdinalIgnoreCase)));
			foreach (PackInfo d in discovered)
			{
				if (!_packs.Any((PackInfo p) => string.Equals(p.Path, d.Path, StringComparison.OrdinalIgnoreCase)))
				{
					_packs.Add(d);
				}
			}
			Plugin.Logger.LogDebug((object)$"[PackManager] Rescan complete: {_packs.Count} packs found");
		}

		public static string GetPackName(string path)
		{
			if (path == null)
			{
				return "(base)";
			}
			return _packs.Find((PackInfo p) => string.Equals(p.Path, path, StringComparison.OrdinalIgnoreCase))?.Name ?? Path.GetFileName(path);
		}

		public static string[] GetProfileNames()
		{
			IOUtil.EnsureDirectoryExists(ProfilesDir);
			return (from n in Directory.GetFiles(ProfilesDir, "*.txt").Select(Path.GetFileNameWithoutExtension)
				orderby n
				select n).ToArray();
		}

		public static void SaveProfile(string name, List<PackInfo> packs = null)
		{
			IOUtil.EnsureDirectoryExists(ProfilesDir);
			List<string> list = new List<string>
			{
				"# Stitchwork Profile: " + name,
				"# Format: +|-|id|path[\\ttrigger\\tcond1\\tcond2...]  (conditions optional, tab-separated)"
			};
			foreach (PackInfo item in packs ?? _packs)
			{
				string text = $"{(item.IsEnabled ? '+' : '-')}|{item.StableId}|{item.Path}";
				if (item.HasConditions)
				{
					string text2 = ((item.ReloadTrigger == ReloadTrigger.HotReload) ? "hot" : "scene");
					string text3 = string.Join("\t", item.Conditions.Select((PackCondition c) => c.Serialize()));
					text = text + "\t" + text2 + "\t" + text3;
				}
				list.Add(text);
			}
			File.WriteAllLines(Path.Combine(ProfilesDir, name + ".txt"), list);
			Plugin.Logger.LogDebug((object)("[PackManager] Saved profile '" + name + "'"));
		}

		public static List<PackInfo> StageProfile(string name)
		{
			string path = Path.Combine(ProfilesDir, name + ".txt");
			if (!File.Exists(path))
			{
				return null;
			}
			List<(string, string, bool, string[])> list = new List<(string, string, bool, string[])>();
			string[] array = File.ReadAllLines(path);
			foreach (string text in array)
			{
				if (!string.IsNullOrWhiteSpace(text) && !text.StartsWith("#") && text.Length >= 3)
				{
					bool item = text[0] == '+';
					string[] array2 = text.Substring(2).Split('\t');
					string item2 = null;
					string item3 = array2[0];
					int num = array2[0].IndexOf('|');
					if (num >= 0)
					{
						item2 = array2[0].Substring(0, num);
						item3 = array2[0].Substring(num + 1);
					}
					list.Add((item2, item3, item, array2));
				}
			}
			List<PackInfo> list2 = new List<PackInfo>();
			foreach (var item8 in list)
			{
				string item4 = item8.Item1;
				string item5 = item8.Item2;
				bool item6 = item8.Item3;
				string[] item7 = item8.Item4;
				PackInfo packInfo = FindByIdentity(_packs, item4, item5);
				if (packInfo == null)
				{
					continue;
				}
				PackInfo packInfo2 = packInfo.Clone();
				packInfo2.IsEnabled = item6;
				if (item7.Length > 2)
				{
					packInfo2.ReloadTrigger = ((item7[1] == "hot") ? ReloadTrigger.HotReload : ReloadTrigger.OnSceneTransition);
					packInfo2.Conditions.Clear();
					for (int j = 2; j < item7.Length; j++)
					{
						PackCondition packCondition = PackCondition.TryDeserialize(item7[j]);
						if (packCondition != null)
						{
							packInfo2.Conditions.Add(packCondition);
						}
					}
				}
				list2.Add(packInfo2);
			}
			foreach (PackInfo p in _packs)
			{
				if (!list2.Any((PackInfo r) => string.Equals(r.Path, p.Path, StringComparison.OrdinalIgnoreCase)))
				{
					list2.Add(p.Clone());
				}
			}
			Plugin.Logger.LogDebug((object)("[PackManager] Staged profile '" + name + "'"));
			return list2;
		}

		public static void DeleteProfile(string name)
		{
			string path = Path.Combine(ProfilesDir, name + ".txt");
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			Plugin.Logger.LogDebug((object)("[PackManager] Deleted profile '" + name + "'"));
		}

		private static void LoadStatsCache()
		{
			if (!File.Exists(StatsCachePath))
			{
				return;
			}
			string[] array = File.ReadAllLines(StatsCachePath);
			foreach (string line in array)
			{
				if (PackStats.TryDeserialize(line, out var path, out var stats))
				{
					PackInfo packInfo = _packs.Find((PackInfo p) => string.Equals(p.Path, path, StringComparison.OrdinalIgnoreCase));
					if (packInfo != null)
					{
						packInfo.Stats = stats;
					}
				}
			}
		}

		private static void SaveStatsCache()
		{
			List<string> list = new List<string> { "# Stitchwork Pack Stats — auto-generated, do not edit manually" };
			foreach (PackInfo pack in _packs)
			{
				if (pack.Stats.IsScanned)
				{
					list.Add(pack.Stats.Serialize(pack.Path));
				}
			}
			File.WriteAllLines(StatsCachePath, list);
		}

		private static void ScanAllStats()
		{
			foreach (PackInfo pack in _packs)
			{
				pack.Stats = PackStats.Scan(pack.Path);
			}
			SaveStatsCache();
			Plugin.Logger.LogDebug((object)$"[PackManager] Pack stats refreshed for {_packs.Count} pack(s)");
		}

		private static void ScanMissingStats()
		{
			bool flag = false;
			foreach (PackInfo pack in _packs)
			{
				if (!pack.Stats.IsScanned)
				{
					pack.Stats = PackStats.Scan(pack.Path);
					flag = true;
				}
			}
			if (flag)
			{
				SaveStatsCache();
			}
		}

		public static void OnSceneLoaded(string sceneName)
		{
			_currentScene = sceneName;
			InvalidateActivePathsCache();
			EvaluateConditionalPacks(onlyHotReload: false);
		}

		public static void PollHotReloadConditions()
		{
			EvaluateConditionalPacks(onlyHotReload: true);
		}

		private static void EvaluateConditionalPacks(bool onlyHotReload)
		{
			IReadOnlyList<PackInfo> readOnlyList;
			if (onlyHotReload)
			{
				readOnlyList = HotReloadPacks;
			}
			else
			{
				List<PackInfo> list = new List<PackInfo>();
				foreach (PackInfo pack in _packs)
				{
					if (pack.HasConditions)
					{
						list.Add(pack);
					}
				}
				readOnlyList = list;
			}
			if (readOnlyList.Count == 0)
			{
				return;
			}
			bool flag = false;
			foreach (PackInfo item in readOnlyList)
			{
				bool flag2 = item.IsEnabled && item.EvaluateConditions(_currentScene, _packs);
				_prevConditionalStates.TryGetValue(item.Path, out var value);
				if (flag2 != value)
				{
					_prevConditionalStates[item.Path] = flag2;
					flag = true;
					Plugin.Logger.LogInfo((object)("[PackManager] '" + item.Name + "' condition → " + (flag2 ? "active" : "inactive") + " (scene='" + _currentScene + "')"));
				}
			}
			if (flag)
			{
				InvalidateActivePathsCache();
				ConflictTracker.Clear();
				TriggerFullReload();
			}
		}

		private static void LoadConditions()
		{
			if (!File.Exists(ConditionsPath))
			{
				return;
			}
			string[] array = File.ReadAllLines(ConditionsPath);
			foreach (string text in array)
			{
				if (string.IsNullOrWhiteSpace(text) || text.StartsWith("#"))
				{
					continue;
				}
				string[] array2 = text.Split('\t');
				if (array2.Length < 3)
				{
					continue;
				}
				string id;
				string path;
				int num;
				if (array2[1] == "hot" || array2[1] == "scene")
				{
					id = null;
					path = array2[0];
					num = 1;
					_legacyStateSeen = true;
				}
				else
				{
					if (array2.Length < 4)
					{
						continue;
					}
					id = array2[0];
					path = array2[1];
					num = 2;
				}
				PackInfo packInfo = FindByIdentity(_packs, id, path);
				if (packInfo == null)
				{
					continue;
				}
				packInfo.ReloadTrigger = ((array2[num] == "hot") ? ReloadTrigger.HotReload : ReloadTrigger.OnSceneTransition);
				int num2 = num + 1;
				if (num2 < array2.Length && (array2[num2] == "and" || array2[num2] == "or"))
				{
					num2++;
				}
				packInfo.Conditions.Clear();
				for (int j = num2; j < array2.Length; j++)
				{
					PackCondition packCondition = PackCondition.TryDeserialize(array2[j]);
					if (packCondition != null)
					{
						packInfo.Conditions.Add(packCondition);
					}
				}
			}
			Plugin.Logger.LogDebug((object)("[PackManager] Loaded conditions for " + $"{_packs.Count((PackInfo p) => p.HasConditions)} pack(s)"));
		}

		public static void SaveConditions()
		{
			List<string> list = new List<string> { "# Stitchwork Pack Conditions — auto-generated, do not edit manually", "# Format: id \\t path \\t trigger \\t cond1 [\\t cond2 ...]" };
			foreach (PackInfo item in _packs.Where((PackInfo q) => q.HasConditions))
			{
				string text = ((item.ReloadTrigger == ReloadTrigger.HotReload) ? "hot" : "scene");
				string text2 = string.Join("\t", item.Conditions.Select((PackCondition c) => c.Serialize()));
				list.Add(item.StableId + "\t" + item.Path + "\t" + text + "\t" + text2);
			}
			File.WriteAllLines(ConditionsPath, list);
		}

		public static void TriggerFullReload()
		{
			Plugin.TextFileWatcher?.RebuildPackWatchers();
			Plugin.FontFileWatcher?.RebuildPackWatchers();
			Plugin.SpriteFileWatcher?.RebuildPackPngWatchers();
			Plugin.AudioFileWatcher?.RebuildPackWatchers();
			RecolourHandler.ReloadRequested = true;
			FileCache.Clear();
			SpriteFileWatcher.ReloadSprites = true;
			SpriteFileWatcher.ReloadT2DSprites = true;
			AudioFileWatcher.ReloadAudio = true;
			TextFileWatcher.ReloadText = true;
			FontFileWatcher.ReloadFonts = true;
			VideoHandler.ReloadVideos = true;
		}
	}
	public readonly struct PackStats
	{
		public bool IsScanned { get; init; }

		public int Sprites { get; init; }

		public int Sheets { get; init; }

		public int Audio { get; init; }

		public int Video { get; init; }

		public int Text { get; init; }

		public int Total => Sprites + Sheets + Audio + Video + Text;

		public string Badge
		{
			get
			{
				if (!IsScanned)
				{
					return null;
				}
				List<string> list = new List<string>();
				if (Sprites > 0)
				{
					list.Add(string.Format("{0} sprite{1}", Sprites, (Sprites == 1) ? "" : "s"));
				}
				if (Sheets > 0)
				{
					list.Add(string.Format("{0} sheet{1}", Sheets, (Sheets == 1) ? "" : "s"));
				}
				if (Audio > 0)
				{
					list.Add($"{Audio} sfx");
				}
				if (Video > 0)
				{
					list.Add(string.Format("{0} video{1}", Video, (Video == 1) ? "" : "s"));
				}
				if (Text > 0)
				{
					list.Add($"{Text} text");
				}
				if (list.Count <= 0)
				{
					return null;
				}
				return string.Join("  ", list);
			}
		}

		public static PackStats Scan(string packPath)
		{
			try
			{
				return new PackStats
				{
					IsScanned = true,
					Sprites = CountFiles(packPath, "Sprites", "*.png"),
					Sheets = CountFiles(PackLayout.SheetsRoot(packPath), "", "*.png"),
					Audio = CountFiles(packPath, "Sounds", "*.*", new string[3] { ".wav", ".ogg", ".mp3" }),
					Video = CountFiles(packPath, "Videos", "*.*"),
					Text = CountFiles(packPath, "Text", "*.*", new string[2] { ".yml", ".yaml" })
				};
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[PackStats] Scan failed for '" + packPath + "': " + ex.Message));
				return new PackStats
				{
					IsScanned = true
				};
			}
		}

		private static int CountFiles(string packPath, string subdir, string pattern, string[] extensions = null)
		{
			string path = Path.Combine(packPath, subdir);
			if (!Directory.Exists(path))
			{
				return 0;
			}
			string[] files = Directory.GetFiles(path, pattern, SearchOption.AllDirectories);
			if (extensions == null)
			{
				return files.Length;
			}
			int num = 0;
			string[] array = files;
			foreach (string path2 in array)
			{
				if (Array.IndexOf(extensions, Path.GetExtension(path2).ToLowerInvariant()) >= 0)
				{
					num++;
				}
			}
			return num;
		}

		public string Serialize(string packPath)
		{
			return $"{packPath}\t{Sprites}\t{Sheets}\t{Audio}\t{Video}\t{Text}";
		}

		public static bool TryDeserialize(string line, out string path, out PackStats stats)
		{
			stats = default(PackStats);
			path = null;
			if (string.IsNullOrWhiteSpace(line) || line.StartsWith("#"))
			{
				return false;
			}
			string[] array = line.Split('\t');
			if (array.Length < 6)
			{
				return false;
			}
			if (!int.TryParse(array[1], out var result) || !int.TryParse(array[2], out var result2) || !int.TryParse(array[3], out var result3) || !int.TryParse(array[4], out var result4) || !int.TryParse(array[5], out var result5))
			{
				return false;
			}
			path = array[0];
			stats = new PackStats
			{
				IsScanned = true,
				Sprites = result,
				Sheets = result2,
				Audio = result3,
				Video = result4,
				Text = result5
			};
			return true;
		}
	}
	public static class PushPull
	{
		private static readonly string[] ContentRoots = PackLayout.ContentRoots;

		private static bool _targetResolved;

		public static PackInfo Target { get; private set; }

		public static string LastSummary { get; private set; }

		public static bool TargetIsReadOnly
		{
			get
			{
				if (Target != null)
				{
					return PackLayout.IsCustomizerPack(Target.Path);
				}
				return false;
			}
		}

		public static void SetTarget(PackInfo pack)
		{
			Target = pack;
			_targetResolved = true;
			if (Plugin.Config?.TargetPackPathEntry != null)
			{
				Plugin.Config.TargetPackPathEntry.Value = pack?.Path ?? "";
			}
		}

		public static PackInfo ResolveTarget()
		{
			if (Target != null && !PackManager.AllPacks.Contains(Target))
			{
				_targetResolved = false;
			}
			if (_targetResolved)
			{
				return Target;
			}
			_targetResolved = true;
			string path = Plugin.Config?.TargetPackPath;
			Target = (string.IsNullOrEmpty(path) ? null : PackManager.AllPacks.FirstOrDefault((PackInfo p) => string.Equals(p.Path, path, StringComparison.OrdinalIgnoreCase)));
			return Target;
		}

		public static void Push()
		{
			if (Target == null || TargetIsReadOnly)
			{
				return;
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			string[] contentRoots = ContentRoots;
			foreach (string path in contentRoots)
			{
				string text = Path.Combine(Plugin.BasePath, path);
				if (!Directory.Exists(text))
				{
					continue;
				}
				foreach (string item in Directory.EnumerateFiles(text, "*", SearchOption.AllDirectories))
				{
					string text2 = item.Substring(text.Length + 1);
					if (IsWipPath(text2))
					{
						num3++;
					}
					else if (!string.IsNullOrEmpty(Path.GetFileNameWithoutExtension(item)))
					{
						string path2 = Path.Combine(Target.Path, path, text2);
						bool num4 = File.Exists(path2);
						IOUtil.EnsureDirectoryExists(Path.GetDirectoryName(path2));
						File.Copy(IOUtil.LongSafe(item), IOUtil.LongSafe(path2), overwrite: true);
						if (num4)
						{
							num2++;
						}
						else
						{
							num++;
						}
					}
				}
			}
			LastSummary = string.Format(Loc.T("Pushed to {0}: {1} new · {2} overwritten · {3} WIP skipped"), Target.Name, num, num2, num3);
			Plugin.Logger.LogInfo((object)("[PushPull] " + LastSummary));
		}

		public static void Pull(bool replace)
		{
			if (Target == null)
			{
				return;
			}
			int num = (replace ? ClearWorkspaceContentRoots() : 0);
			int copied = 0;
			int overwritten = 0;
			if (PackLayout.IsCustomizerPack(Target.Path))
			{
				CopyTree(PackLayout.T2DSheetsRoot(Target.Path), Path.Combine(Plugin.BasePath, "Spritesheets", "T2D"), "*.png", ref copied, ref overwritten);
				CopyTree(Target.Path, Path.Combine(Plugin.BasePath, "Spritesheets"), "*.png", ref copied, ref overwritten, "Texture2D");
			}
			else
			{
				string[] contentRoots = ContentRoots;
				foreach (string path in contentRoots)
				{
					CopyTree(Path.Combine(Target.Path, path), Path.Combine(Plugin.BasePath, path), "*", ref copied, ref overwritten);
				}
			}
			LastSummary = (replace ? string.Format(Loc.T("Pulled (replace) from {0}: {1} removed · {2} copied"), Target.Name, num, copied + overwritten) : string.Format(Loc.T("Pulled (merge) from {0}: {1} new · {2} overwritten"), Target.Name, copied, overwritten));
			Plugin.Logger.LogInfo((object)("[PushPull] " + LastSummary));
		}

		private static void CopyTree(string srcRoot, string dstRoot, string pattern, ref int copied, ref int overwritten, string skipTopDir = null)
		{
			if (!Directory.Exists(srcRoot))
			{
				return;
			}
			foreach (string item in Directory.EnumerateFiles(srcRoot, pattern, SearchOption.AllDirectories))
			{
				string text = item.Substring(srcRoot.Length + 1);
				if (!IsWipPath(text) && (skipTopDir == null || !text.StartsWith(skipTopDir + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase)) && !string.IsNullOrEmpty(Path.GetFileNameWithoutExtension(item)))
				{
					string path = Path.Combine(dstRoot, text);
					bool num = File.Exists(path);
					IOUtil.EnsureDirectoryExists(Path.GetDirectoryName(path));
					File.Copy(IOUtil.LongSafe(item), IOUtil.LongSafe(path), overwrite: true);
					if (num)
					{
						overwritten++;
					}
					else
					{
						copied++;
					}
				}
			}
		}

		private static int ClearWorkspaceContentRoots()
		{
			int num = 0;
			string[] contentRoots = ContentRoots;
			foreach (string path in contentRoots)
			{
				string text = Path.Combine(Plugin.BasePath, path);
				if (!Directory.Exists(text))
				{
					continue;
				}
				foreach (string item in Directory.EnumerateFiles(text, "*", SearchOption.AllDirectories).ToList())
				{
					if (!IsWipPath(item.Substring(text.Length + 1)))
					{
						File.Delete(IOUtil.LongSafe(item));
						num++;
					}
				}
			}
			return num;
		}

		private static bool IsWipPath(string rel)
		{
			string[] array = rel.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].EndsWith("_WIP", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace Stitchwork.Handlers
{
	public static class AnimCanvasAuthoring
	{
		private struct FrameGeom
		{
			public string SpriteName;

			public string CollectionName;

			public string MaterialName;

			public Texture Atlas;

			public Vector2[] Uvs;

			public Vector3[] Positions;

			public Vector2 TexelSize;

			public float PxMin;

			public float PxMax;

			public float PyMin;

			public float PyMax;

			public FlipMode Flipped;
		}

		private struct CanvasGeom
		{
			public int W;

			public int H;

			public int PivotX;

			public int PivotY;

			public float PpuX;

			public float PpuY;
		}

		public static string WipDirFor(tk2dSpriteAnimationClip clip)
		{
			if (clip?.frames == null)
			{
				return null;
			}
			tk2dSpriteAnimationFrame[] frames = clip.frames;
			foreach (tk2dSpriteAnimationFrame val in frames)
			{
				tk2dSpriteCollectionData spriteCollection = val.spriteCollection;
				if (!((Object)(object)spriteCollection == (Object)null) && val.spriteId >= 0 && val.spriteId < spriteCollection.spriteDefinitions.Length)
				{
					return Path.Combine(SpriteLoader.LoadPath, ((Object)spriteCollection).name, T2DUtil.SanitizeForFilesystem(clip.name) + "_WIP");
				}
			}
			return null;
		}

		public static string ExtractClip(tk2dSpriteAnimationClip clip, float marginFraction = 0.5f, int marginFloorPx = 0, bool fromCurrentRender = false)
		{
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Expected O, but got Unknown
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			if (clip?.frames == null || clip.frames.Length == 0)
			{
				return null;
			}
			if (!TexUtil.RotateDrawAvailable)
			{
				Plugin.Logger.LogError((object)"[AnimWIP] Canvas extract needs the Rotate shader (stitchwork.assetbundle) — unavailable this session.");
				return null;
			}
			string text = WipDirFor(clip);
			if (text == null)
			{
				Plugin.Logger.LogWarning((object)("[AnimWIP] '" + clip?.name + "': can't resolve a sprite load path for this clip."));
				return null;
			}
			List<FrameGeom> frames = new List<FrameGeom>();
			HashSet<string> hashSet = new HashSet<string>();
			tk2dSpriteAnimationFrame[] frames2 = clip.frames;
			foreach (tk2dSpriteAnimationFrame val in frames2)
			{
				tk2dSpriteCollectionData spriteCollection = val.spriteCollection;
				if (!((Object)(object)spriteCollection == (Object)null) && val.spriteId >= 0 && val.spriteId < spriteCollection.spriteDefinitions.Length)
				{
					tk2dSpriteDefinition val2 = spriteCollection.spriteDefinitions[val.spriteId];
					if (!string.IsNullOrEmpty(val2.name) && hashSet.Add(val2.name) && TryBuildFrameGeom(spriteCollection, val2, fromCurrentRender, out var g))
					{
						frames.Add(g);
					}
				}
			}
			if (frames.Count == 0)
			{
				Plugin.Logger.LogWarning((object)("[AnimWIP] '" + clip.name + "': no usable frames to extract."));
				return null;
			}
			if (frames.Select((FrameGeom f) => f.Flipped).Distinct().Count() > 1)
			{
				Plugin.Logger.LogWarning((object)("[AnimWIP] '" + clip.name + "': MIXED flip modes across frames — " + string.Join(", ", frames.Select((FrameGeom f) => $"{f.SpriteName}={f.Flipped}"))));
			}
			else
			{
				Plugin.Logger.LogInfo((object)$"[AnimWIP] '{clip.name}': flip mode {frames[0].Flipped} (uniform across {frames.Count} frames).");
			}
			Vector2 texel = frames[0].TexelSize;
			if (frames.Any((FrameGeom f) => f.CollectionName != frames[0].CollectionName))
			{
				Plugin.Logger.LogWarning((object)("[AnimWIP] '" + clip.name + "': frames span multiple collections — canvas assumes one; folder named for '" + frames[0].CollectionName + "'."));
			}
			if (frames.Any((FrameGeom f) => Mathf.Abs(f.TexelSize.x - texel.x) > 1E-06f || Mathf.Abs(f.TexelSize.y - texel.y) > 1E-06f))
			{
				Plugin.Logger.LogWarning((object)("[AnimWIP] '" + clip.name + "': frames have mismatched texelSize — cross-atlas scale differs; registration may drift."));
			}
			CanvasGeom cg = ComputeCanvas(frames, marginFraction, marginFloorPx);
			int w = cg.W;
			int h = cg.H;
			int pivotX = cg.PivotX;
			int pivotY = cg.PivotY;
			IOUtil.EnsureDirectoryExists(text);
			StringBuilder stringBuilder = new StringBuilder();
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			stringBuilder.AppendLine("# Stitchwork animation-canvas WIP sidecar — do not hand-edit pivot/canvas.");
			stringBuilder.AppendLine("animationClip: \"" + clip.name + "\"");
			stringBuilder.AppendLine("schemaVersion: 6");
			stringBuilder.AppendLine($"issuedCanvas: {{ w: {w}, h: {h} }}");
			stringBuilder.AppendLine($"pivotInCanvas: {{ x: {w - 1 - pivotX}, y: {pivotY} }}");
			stringBuilder.AppendLine("pixelsPerUnit: " + (1f / texel.x).ToString("0.####", invariantCulture));
			stringBuilder.AppendLine("marginFraction: " + marginFraction.ToString(invariantCulture));
			stringBuilder.AppendLine("frames:");
			float ppuX = cg.PpuX;
			float ppuY = cg.PpuY;
			RenderTexture active = RenderTexture.active;
			RenderTexture temporary = RenderTexture.GetTemporary(w, h, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			Texture2D val3 = new Texture2D(w, h, (TextureFormat)4, false);
			Dictionary<int, RenderTexture> dictionary = new Dictionary<int, RenderTexture>();
			try
			{
				int num = 0;
				foreach (FrameGeom item in frames)
				{
					RenderFrameInto(temporary, val3, item, cg, dictionary);
					string text2 = $"{num:D3}_{T2DUtil.SanitizeForFilesystem(item.SpriteName)}.png";
					File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(text, text2)), ImageConversion.EncodeToPNG(val3));
					int num2 = Mathf.RoundToInt((float)pivotX + item.PxMin * ppuX);
					int num3 = Mathf.RoundToInt((float)pivotX + item.PxMax * ppuX) - num2;
					int num4 = w - num2 - num3;
					int num5 = Mathf.RoundToInt((float)pivotY + item.PyMin * ppuY);
					int num6 = Mathf.RoundToInt((float)pivotY + item.PyMax * ppuY) - num5;
					stringBuilder.AppendLine("  - spriteName: \"" + item.SpriteName + "\"");
					stringBuilder.AppendLine("    collection: \"" + item.CollectionName + "\"");
					stringBuilder.AppendLine("    material: \"" + item.MaterialName + "\"");
					stringBuilder.AppendLine("    dumpedFile: \"" + text2 + "\"");
					stringBuilder.AppendLine($"    baselineHash: \"{AnimCanvasCompile.HashPixels(val3.GetPixels32()):x16}\"");
					stringBuilder.AppendLine($"    canvasRect: {{ x: {num4}, y: {num5}, w: {num3}, h: {num6} }}");
					stringBuilder.AppendLine($"    flipped: {item.Flipped}");
					num++;
				}
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
				Object.Destroy((Object)(object)val3);
				foreach (RenderTexture value in dictionary.Values)
				{
					if ((Object)(object)value != (Object)null)
					{
						RenderTexture.ReleaseTemporary(value);
					}
				}
			}
			string path = T2DUtil.SanitizeForFilesystem(clip.name) + "_sidecar.yml";
			File.WriteAllText(IOUtil.LongSafe(Path.Combine(text, path)), stringBuilder.ToString());
			Plugin.Logger.LogInfo((object)($"[AnimWIP] '{clip.name}': {frames.Count} frame(s) → {w}×{h}, pivot ({pivotX},{pivotY}) " + "[source: " + (fromCurrentRender ? "current render" : "vanilla") + "] → " + text));
			return text;
		}

		private static bool TryBuildFrameGeom(tk2dSpriteCollectionData coll, tk2dSpriteDefinition def, bool fromCurrentRender, out FrameGeom g)
		{
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			g = default(FrameGeom);
			if (string.IsNullOrEmpty(def.name) || def.positions == null || def.positions.Length < 4)
			{
				return false;
			}
			if (def.uvs == null || def.uvs.Length < 4)
			{
				return false;
			}
			if (def.texelSize.x <= 0f || def.texelSize.y <= 0f)
			{
				return false;
			}
			Texture atlas = null;
			Vector2[] uvs = null;
			Vector3[] positions = null;
			if (fromCurrentRender || !SpriteLoader.TryGetVanilla(coll, def, out atlas, out uvs, out positions))
			{
				Material val = (((Object)(object)def.materialInst != (Object)null) ? def.materialInst : def.material);
				atlas = (((Object)(object)val != (Object)null) ? val.mainTexture : null);
				uvs = def.uvs;
				positions = def.positions;
			}
			if ((Object)(object)atlas == (Object)null || uvs == null || uvs.Length < 4 || positions == null || positions.Length < 4)
			{
				return false;
			}
			Material val2 = ((def.materialId >= 0 && coll.materials != null && def.materialId < coll.materials.Length) ? coll.materials[def.materialId] : null);
			string materialName = (((Object)(object)val2 != (Object)null) ? ((Object)val2).name.Split(' ')[0] : "");
			g = new FrameGeom
			{
				SpriteName = def.name,
				CollectionName = ((Object)coll).name,
				MaterialName = materialName,
				Atlas = atlas,
				Uvs = uvs,
				Positions = positions,
				TexelSize = def.texelSize,
				PxMin = positions.Min((Vector3 p) => p.x),
				PxMax = positions.Max((Vector3 p) => p.x),
				PyMin = positions.Min((Vector3 p) => p.y),
				PyMax = positions.Max((Vector3 p) => p.y),
				Flipped = def.flipped
			};
			return true;
		}

		private static CanvasGeom ComputeCanvas(List<FrameGeom> frames, float marginFraction, int marginFloorPx)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			float num = frames.Min((FrameGeom f) => f.PxMin);
			float num2 = frames.Max((FrameGeom f) => f.PxMax);
			float num3 = frames.Min((FrameGeom f) => f.PyMin);
			float num4 = frames.Max((FrameGeom f) => f.PyMax);
			Vector2 texelSize = frames[0].TexelSize;
			int num5 = (int)((num2 - num) / texelSize.x) + 1;
			int num6 = (int)((num4 - num3) / texelSize.y) + 1;
			int num7 = Mathf.Max(Mathf.CeilToInt(marginFraction * (float)num5), marginFloorPx);
			int num8 = Mathf.Max(Mathf.CeilToInt(marginFraction * (float)num6), marginFloorPx);
			return new CanvasGeom
			{
				W = num5 + 2 * num7,
				H = num6 + 2 * num8,
				PivotX = (int)((0f - num) / texelSize.x) + num7,
				PivotY = (int)((0f - num3) / texelSize.y) + num8,
				PpuX = 1f / texelSize.x,
				PpuY = 1f / texelSize.y
			};
		}

		private static void RenderFrameInto(RenderTexture rt, Texture2D readback, FrameGeom f, CanvasGeom cg, Dictionary<int, RenderTexture> pointAtlas)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			RenderTexture pointAtlasRT = GetPointAtlasRT(f.Atlas, pointAtlas);
			RenderTexture.active = rt;
			GL.Clear(true, true, Color.clear);
			GL.PushMatrix();
			GL.LoadPixelMatrix(0f, (float)cg.W, 0f, (float)cg.H);
			TexUtil.SetPassTextured((Texture)(object)pointAtlasRT);
			GL.Begin(7);
			GL.Color(Color.white);
			int[] array = new int[4] { 0, 1, 3, 2 };
			foreach (int num in array)
			{
				GL.TexCoord(Vector2.op_Implicit(f.Uvs[num]));
				GL.Vertex3((float)cg.PivotX + f.Positions[num].x * cg.PpuX, (float)cg.PivotY + f.Positions[num].y * cg.PpuY, 0f);
			}
			GL.End();
			GL.PopMatrix();
			readback.ReadPixels(new Rect(0f, 0f, (float)cg.W, (float)cg.H), 0, 0);
			readback.Apply();
			FlipHorizontal(readback, cg.W, cg.H);
		}

		public static List<Color32[]> RenderClipSequence(tk2dSpriteAnimationClip clip, bool fromCurrentRender, float marginFraction, out int width, out int height)
		{
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			width = (height = 0);
			if (clip?.frames == null || clip.frames.Length == 0)
			{
				return null;
			}
			if (!TexUtil.RotateDrawAvailable)
			{
				Plugin.Logger.LogError((object)"[AnimWIP] Clip render needs the Rotate shader (stitchwork.assetbundle) — unavailable this session.");
				return null;
			}
			Dictionary<string, FrameGeom> dictionary = new Dictionary<string, FrameGeom>();
			List<string> list = new List<string>();
			tk2dSpriteAnimationFrame[] frames = clip.frames;
			foreach (tk2dSpriteAnimationFrame val in frames)
			{
				tk2dSpriteCollectionData spriteCollection = val.spriteCollection;
				if ((Object)(object)spriteCollection == (Object)null || val.spriteId < 0 || val.spriteId >= spriteCollection.spriteDefinitions.Length)
				{
					continue;
				}
				tk2dSpriteDefinition val2 = spriteCollection.spriteDefinitions[val.spriteId];
				if (string.IsNullOrEmpty(val2.name))
				{
					continue;
				}
				if (!dictionary.ContainsKey(val2.name))
				{
					if (!TryBuildFrameGeom(spriteCollection, val2, fromCurrentRender, out var g))
					{
						continue;
					}
					dictionary[val2.name] = g;
				}
				list.Add(val2.name);
			}
			if (list.Count == 0)
			{
				return null;
			}
			CanvasGeom cg = ComputeCanvas(dictionary.Values.ToList(), marginFraction, 0);
			width = cg.W;
			height = cg.H;
			List<Color32[]> list2 = new List<Color32[]>(list.Count);
			RenderTexture active = RenderTexture.active;
			RenderTexture temporary = RenderTexture.GetTemporary(cg.W, cg.H, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			Texture2D val3 = new Texture2D(cg.W, cg.H, (TextureFormat)4, false);
			Dictionary<int, RenderTexture> dictionary2 = new Dictionary<int, RenderTexture>();
			try
			{
				foreach (string item in list)
				{
					RenderFrameInto(temporary, val3, dictionary[item], cg, dictionary2);
					list2.Add(val3.GetPixels32());
				}
				return list2;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
				Object.Destroy((Object)(object)val3);
				foreach (RenderTexture value in dictionary2.Values)
				{
					if ((Object)(object)value != (Object)null)
					{
						RenderTexture.ReleaseTemporary(value);
					}
				}
			}
		}

		private static RenderTexture GetPointAtlasRT(Texture atlas, Dictionary<int, RenderTexture> cache)
		{
			int instanceID = ((Object)atlas).GetInstanceID();
			if (cache.TryGetValue(instanceID, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			RenderTexture temporary = RenderTexture.GetTemporary(atlas.width, atlas.height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			((Texture)temporary).filterMode = (FilterMode)0;
			Graphics.Blit(atlas, temporary);
			cache[instanceID] = temporary;
			return temporary;
		}

		private static void FlipHorizontal(Texture2D tex, int w, int h)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Color32[] pixels = tex.GetPixels32();
			Color32[] array = (Color32[])(object)new Color32[pixels.Length];
			for (int i = 0; i < h; i++)
			{
				for (int j = 0; j < w; j++)
				{
					array[i * w + j] = pixels[i * w + (w - 1 - j)];
				}
			}
			tex.SetPixels32(array);
			tex.Apply();
		}
	}
	public static class AnimCanvasBatch
	{
		public enum BatchMode
		{
			Extract,
			Compile
		}

		private static bool _cancel;

		private static int _sceneAtStart;

		public static bool IsRunning { get; private set; }

		public static BatchMode Mode { get; private set; }

		public static int Total { get; private set; }

		public static int Processed { get; private set; }

		public static string CurrentClip { get; private set; } = "";

		public static float StartedAt { get; private set; }

		public static int Ok { get; private set; }

		public static int Skipped { get; private set; }

		public static int Failed { get; private set; }

		public static void ExtractAll(List<tk2dSpriteAnimationClip> clips, bool fromCurrentRender)
		{
			if (CanStart(clips))
			{
				if (!TexUtil.RotateDrawAvailable)
				{
					Plugin.Logger.LogError((object)"[AnimBatch] Canvas extract needs the Rotate shader (stitchwork.assetbundle) — unavailable this session.");
					return;
				}
				Begin(BatchMode.Extract, clips.Count);
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Run(clips, fromCurrentRender));
			}
		}

		public static void CompileAll(List<tk2dSpriteAnimationClip> clips)
		{
			if (CanStart(clips))
			{
				Begin(BatchMode.Compile, clips.Count);
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Run(clips, fromCurrentRender: false));
			}
		}

		public static void Cancel()
		{
			_cancel = true;
		}

		public static List<tk2dSpriteAnimationClip> WithWorkspace(List<tk2dSpriteAnimationClip> clips)
		{
			List<tk2dSpriteAnimationClip> list = new List<tk2dSpriteAnimationClip>();
			if (clips == null)
			{
				return list;
			}
			foreach (tk2dSpriteAnimationClip clip in clips)
			{
				string text = AnimCanvasAuthoring.WipDirFor(clip);
				if (text != null && Directory.Exists(IOUtil.LongSafe(text)) && File.Exists(IOUtil.LongSafe(Path.Combine(text, T2DUtil.SanitizeForFilesystem(clip.name) + "_sidecar.yml"))))
				{
					list.Add(clip);
				}
			}
			return list;
		}

		private static bool CanStart(List<tk2dSpriteAnimationClip> clips)
		{
			if (!IsRunning && !SceneTraverser.IsTraversing && clips != null)
			{
				return clips.Count > 0;
			}
			return false;
		}

		private static void Begin(BatchMode mode, int total)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Mode = mode;
			Total = total;
			Processed = 0;
			Ok = 0;
			Skipped = 0;
			Failed = 0;
			CurrentClip = "";
			_cancel = false;
			Scene activeScene = SceneManager.GetActiveScene();
			_sceneAtStart = ((Scene)(ref activeScene)).handle;
			StartedAt = Time.realtimeSinceStartup;
			IsRunning = true;
			Plugin.Logger.LogInfo((object)string.Format("[AnimBatch] {0} started: {1} clips.", (mode == BatchMode.Extract) ? "Extract" : "Compile", total));
		}

		private static IEnumerator Run(List<tk2dSpriteAnimationClip> clips, bool fromCurrentRender)
		{
			foreach (tk2dSpriteAnimationClip clip in clips)
			{
				if (_cancel)
				{
					Plugin.Logger.LogInfo((object)$"[AnimBatch] Cancelled at {Processed}/{Total}.");
					break;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).handle != _sceneAtStart)
				{
					Plugin.Logger.LogWarning((object)$"[AnimBatch] Scene changed — stopped at {Processed}/{Total}. Restart the batch in the new scene.");
					break;
				}
				CurrentClip = clip?.name ?? "?";
				try
				{
					if (Mode == BatchMode.Extract)
					{
						if (AnimCanvasAuthoring.ExtractClip(clip, 0.5f, 0, fromCurrentRender) != null)
						{
							Ok++;
						}
						else
						{
							Skipped++;
						}
					}
					else if (AnimCanvasCompile.CompileClip(clip).Count > 0)
					{
						Ok++;
					}
					else
					{
						Skipped++;
					}
				}
				catch (Exception arg)
				{
					Failed++;
					Plugin.Logger.LogError((object)$"[AnimBatch] '{CurrentClip}' failed: {arg}");
				}
				Processed++;
				yield return null;
			}
			float num = (Time.realtimeSinceStartup - StartedAt) / 60f;
			Plugin.Logger.LogInfo((object)("[AnimBatch] " + ((Mode == BatchMode.Extract) ? "Extract" : "Compile") + " done: " + $"{Ok} ok, {Skipped} skipped, {Failed} failed of {Total} ({num:F1} min)."));
			if (Mode == BatchMode.Extract && Ok > 0)
			{
				IOUtil.OpenPath(SpriteLoader.LoadPath);
			}
			IsRunning = false;
		}
	}
	public static class AnimCanvasCompile
	{
		public struct FrameOutcome
		{
			public string Sprite;

			public string Kind;

			public string Detail;
		}

		private class Sidecar
		{
			public int CanvasW;

			public int CanvasH;

			public int PivotX;

			public int PivotY;

			public readonly List<FrameEntry> Frames = new List<FrameEntry>();
		}

		private class FrameEntry
		{
			public string Sprite;

			public string Collection;

			public string Material;

			public string DumpedFile;

			public int RectX;

			public int RectY;

			public int RectW;

			public int RectH;

			public string Flipped = "Tk2d";

			public string BaselineHash;
		}

		private const int StrayTolerance = 2;

		private static int _faintThisClip;

		private static string _displacedDir;

		private static int _displacedCount;

		private static byte AlphaThreshold => (byte)Mathf.Clamp(Plugin.Config?.AnimCompileAlphaThreshold ?? 16, 1, 255);

		public static List<FrameOutcome> CompileClip(tk2dSpriteAnimationClip clip, bool forClipOnly = false)
		{
			List<FrameOutcome> list = new List<FrameOutcome>();
			string text = AnimCanvasAuthoring.WipDirFor(clip);
			if (string.IsNullOrEmpty(text) || !Directory.Exists(text))
			{
				string text2 = (string.IsNullOrEmpty(text) ? null : SameNameWipsElsewhere(text));
				Plugin.Logger.LogWarning((object)("[AnimCompile] '" + clip?.name + "': no WIP folder — extract first." + ((text2 != null) ? (" NOTE: a same-named workspace exists at " + text2 + " — that is a same-named clip on ANOTHER rig (e.g. regular vs cloakless Hornet both have 'idle'). Check the clip list's Collection line and select that rig's clip to compile its workspace.") : "")));
				return list;
			}
			string clipDest = null;
			if (forClipOnly)
			{
				if (clip.name.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
				{
					Plugin.Logger.LogWarning((object)("[AnimCompile] '" + clip.name + "': clip name isn't filesystem-safe — per-clip compile unavailable for it."));
					return list;
				}
				clipDest = clip.name;
			}
			string path = Path.Combine(text, T2DUtil.SanitizeForFilesystem(clip.name) + "_sidecar.yml");
			if (!File.Exists(path))
			{
				string text3 = SameNameWipsElsewhere(text);
				Plugin.Logger.LogWarning((object)("[AnimCompile] '" + clip.name + "': sidecar missing — re-extract." + ((text3 != null) ? (" NOTE: a same-named workspace exists at " + text3 + " — likely the same-named clip on another rig; select that rig's clip (see the clip list's Collection line) to compile it.") : "")));
				return list;
			}
			Sidecar sc = ParseSidecar(File.ReadAllLines(path));
			return CompileParsed(clip, text, sc, clipDest, list);
		}

		private static string SameNameWipsElsewhere(string expectedDir)
		{
			try
			{
				if (!Directory.Exists(SpriteLoader.LoadPath))
				{
					return null;
				}
				string fileName = Path.GetFileName(expectedDir);
				List<string> list = null;
				string[] directories = Directory.GetDirectories(SpriteLoader.LoadPath);
				foreach (string text in directories)
				{
					string text2 = Path.Combine(text, fileName);
					if (!string.Equals(text2, expectedDir, StringComparison.OrdinalIgnoreCase) && Directory.Exists(text2))
					{
						(list ?? (list = new List<string>())).Add(Path.GetFileName(text) + "/" + fileName);
					}
				}
				return (list == null) ? null : string.Join(", ", list);
			}
			catch (IOException)
			{
				return null;
			}
		}

		private static List<FrameOutcome> CompileParsed(tk2dSpriteAnimationClip clip, string dir, Sidecar sc, string clipDest, List<FrameOutcome> outcomes)
		{
			if (sc == null || sc.CanvasW <= 0 || sc.CanvasH <= 0)
			{
				Plugin.Logger.LogWarning((object)("[AnimCompile] '" + clip.name + "': sidecar unparseable or missing canvas dims."));
				return outcomes;
			}
			Plugin.Logger.LogInfo((object)($"[AnimCompile] '{clip.name}': compiling {sc.Frames.Count} frame(s) from {dir}" + ((clipDest != null) ? (" → per-clip (Clips/" + clipDest + "/)") : "")));
			_faintThisClip = 0;
			_displacedCount = 0;
			_displacedDir = Path.Combine(dir, "_displaced-" + DateTime.Now.ToString("yyyyMMdd-HHmmss"));
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (clip != null && clip.frames != null)
			{
				tk2dSpriteAnimationFrame[] frames = clip.frames;
				foreach (tk2dSpriteAnimationFrame val in frames)
				{
					tk2dSpriteCollectionData spriteCollection = val.spriteCollection;
					if (!((Object)(object)spriteCollection == (Object)null) && spriteCollection.spriteDefinitions != null && val.spriteId >= 0 && val.spriteId < spriteCollection.spriteDefinitions.Length)
					{
						tk2dSpriteDefinition val2 = spriteCollection.spriteDefinitions[val.spriteId];
						if (val2 != null && !string.IsNullOrEmpty(val2.name))
						{
							dictionary[val2.name] = ((!dictionary.TryGetValue(val2.name, out var value)) ? 1 : (value + 1));
						}
					}
				}
			}
			bool flag = false;
			foreach (FrameEntry frame in sc.Frames)
			{
				if (string.IsNullOrEmpty(frame.BaselineHash))
				{
					flag = true;
				}
				FrameOutcome item = CompileFrame(dir, sc, frame, clipDest);
				outcomes.Add(item);
				Plugin.Logger.LogInfo((object)("[AnimCompile]   " + item.Sprite + ": " + item.Kind + " — " + item.Detail));
				if ((item.Kind == "inbounds" || item.Kind == "spill") && clipDest == null && dictionary.TryGetValue(item.Sprite, out var value2) && value2 > 1)
				{
					Plugin.Logger.LogWarning((object)($"[AnimCompile]   '{item.Sprite}' is used ×{value2} in this clip (and possibly by other clips) — " + "shared art changes everywhere it appears. For per-clip divergence use the per-clip compile (Appliqué Clips/ output), which is collision-free by construction."));
				}
			}
			if (flag)
			{
				Plugin.Logger.LogInfo((object)("[AnimCompile] '" + clip.name + "': sidecar predates dirty-frame detection (schema 5) — every readable frame was written. Re-extract to enable unchanged-frame skipping."));
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			foreach (FrameOutcome outcome in outcomes)
			{
				if (outcome.Kind == "inbounds")
				{
					num++;
				}
				else if (outcome.Kind == "spill")
				{
					num2++;
				}
				else if (outcome.Kind == "unchanged")
				{
					num3++;
				}
				else
				{
					num4++;
				}
			}
			Plugin.Logger.LogInfo((object)($"[AnimCompile] '{clip.name}': done — {num} in-bounds, {num2} spill, {num3} unchanged (not written), " + string.Format("{0} skipped{1}.", num4, (_displacedCount > 0) ? $"; {_displacedCount} prior file(s) backed up to {Path.GetFileName(_displacedDir)}/" : "")));
			if (_faintThisClip > 0 && AlphaThreshold > 1)
			{
				Plugin.Logger.LogInfo((object)($"[AnimCompile] '{clip.name}': {_faintThisClip} faint pixel(s) below alpha {AlphaThreshold} were " + "treated as empty. Painting soft glow/bloom/haze? Lower AnimCompileAlphaThreshold in the config so the fringe survives the cut (keep the canvas free of stray faint pixels at low values)."));
			}
			return outcomes;
		}

		private static FrameOutcome CompileFrame(string dir, Sidecar sc, FrameEntry fe, string clipDest = null)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			string path = Path.Combine(dir, fe.DumpedFile);
			if (!File.Exists(IOUtil.LongSafe(path)))
			{
				return Skip(fe.Sprite, "edited PNG missing: " + fe.DumpedFile);
			}
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			if (!ImageConversion.LoadImage(val, File.ReadAllBytes(IOUtil.LongSafe(path))))
			{
				Object.Destroy((Object)(object)val);
				return Skip(fe.Sprite, "PNG decode failed");
			}
			try
			{
				int width = ((Texture)val).width;
				int height = ((Texture)val).height;
				if (width != sc.CanvasW || height != sc.CanvasH)
				{
					return Skip(fe.Sprite, $"canvas resized in editor ({width}x{height} vs issued {sc.CanvasW}x{sc.CanvasH}) — re-dump, don't guess");
				}
				int rectX = fe.RectX;
				int rectY = fe.RectY;
				int num = fe.RectX + fe.RectW;
				int num2 = fe.RectY + fe.RectH;
				Color32[] pixels = val.GetPixels32();
				if (!string.IsNullOrEmpty(fe.BaselineHash) && string.Equals($"{HashPixels(pixels):x16}", fe.BaselineHash, StringComparison.OrdinalIgnoreCase))
				{
					return new FrameOutcome
					{
						Sprite = fe.Sprite,
						Kind = "unchanged",
						Detail = "canvas matches the extract baseline — not written"
					};
				}
				int num3 = 0;
				byte alphaThreshold = AlphaThreshold;
				int num4 = int.MaxValue;
				int num5 = int.MaxValue;
				int num6 = int.MinValue;
				int num7 = int.MinValue;
				for (int i = 0; i < height; i++)
				{
					for (int j = 0; j < width; j++)
					{
						byte a = pixels[i * width + j].a;
						if (a < alphaThreshold)
						{
							if (a > 0)
							{
								_faintThisClip++;
							}
							continue;
						}
						if (j < num4)
						{
							num4 = j;
						}
						if (j > num6)
						{
							num6 = j;
						}
						if (i < num5)
						{
							num5 = i;
						}
						if (i > num7)
						{
							num7 = i;
						}
						if (j < rectX || j >= num || i < rectY || i >= num2)
						{
							num3++;
						}
					}
				}
				string text = ((clipDest == null) ? Path.Combine(SpriteLoader.LoadPath, fe.Collection, fe.Material) : Path.Combine(SpriteLoader.LoadPath, fe.Collection, "Clips", clipDest));
				IOUtil.EnsureDirectoryExists(text);
				bool flag = clipDest != null || string.Equals(fe.Flipped, "None", StringComparison.OrdinalIgnoreCase);
				if (num3 <= 2)
				{
					byte[] bytes = CropPng(pixels, width, height, rectX, rectY, fe.RectW, fe.RectH, flag);
					DisplaceSpriteFiles(text, fe.Sprite);
					File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(text, fe.Sprite + ".png")), bytes);
					string text2 = ((num3 > 0) ? $"; {num3} stray px outside ignored" : "");
					return new FrameOutcome
					{
						Sprite = fe.Sprite,
						Kind = "inbounds",
						Detail = $"{fe.RectW}x{fe.RectH} → {fe.Sprite}.png{text2} [{fe.Flipped}]"
					};
				}
				int num8 = Mathf.Min(num4, rectX);
				int num9 = Mathf.Min(num5, rectY);
				int num10 = Mathf.Max(num6, num - 1);
				int num11 = Mathf.Max(num7, num2 - 1);
				int num12 = num10 - num8 + 1;
				int num13 = num11 - num9 + 1;
				bool num14 = num8 <= 0 || num9 <= 0 || num10 >= width - 1 || num11 >= height - 1;
				int num15 = sc.PivotX - num8;
				int num16 = sc.PivotY - num9;
				if (flag)
				{
					num15 = num12 - 1 - num15;
				}
				byte[] bytes2 = CropPng(pixels, width, height, num8, num9, num12, num13, flag);
				string text3 = $"{fe.Sprite}@p{num15}_{num16}.png";
				DisplaceSpriteFiles(text, fe.Sprite);
				File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(text, text3)), bytes2);
				string text4 = (num14 ? "; WARNING content at canvas edge — may be clipped, use More Room" : "");
				return new FrameOutcome
				{
					Sprite = fe.Sprite,
					Kind = "spill",
					Detail = $"{num12}x{num13} @p{num15}_{num16} ({num3} px outside) → {text3}{text4}"
				};
			}
			finally
			{
				Object.Destroy((Object)(object)val);
			}
		}

		private static FrameOutcome Skip(string sprite, string why)
		{
			return new FrameOutcome
			{
				Sprite = sprite,
				Kind = "skip-error",
				Detail = why
			};
		}

		internal static ulong HashPixels(Color32[] px)
		{
			ulong num = 14695981039346656037uL;
			for (int i = 0; i < px.Length; i++)
			{
				num = (num ^ px[i].r) * 1099511628211L;
				num = (num ^ px[i].g) * 1099511628211L;
				num = (num ^ px[i].b) * 1099511628211L;
				num = (num ^ px[i].a) * 1099511628211L;
			}
			return num;
		}

		private static void DisplaceSpriteFiles(string outDir, string sprite)
		{
			if (!Directory.Exists(outDir))
			{
				return;
			}
			string[] array = new string[2]
			{
				sprite + ".png",
				sprite + "@*.png"
			};
			foreach (string searchPattern in array)
			{
				string[] files = Directory.GetFiles(outDir, searchPattern, SearchOption.TopDirectoryOnly);
				foreach (string path in files)
				{
					IOUtil.EnsureDirectoryExists(_displacedDir);
					File.Copy(IOUtil.LongSafe(path), IOUtil.LongSafe(Path.Combine(_displacedDir, Path.GetFileName(path))), overwrite: true);
					File.Delete(IOUtil.LongSafe(path));
					_displacedCount++;
				}
			}
		}

		private static byte[] CropPng(Color32[] src, int srcW, int srcH, int x0, int y0, int w, int h, bool flipX = false)
		{
			//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_0019: Expected O, but got Unknown
			//IL_001f: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b5: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (w <= 0 || h <= 0)
			{
				Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false);
				byte[] result = ImageConversion.EncodeToPNG(val);
				Object.Destroy((Object)val);
				return result;
			}
			Color32[] array = (Color32[])(object)new Color32[w * h];
			for (int i = 0; i < h; i++)
			{
				int num = y0 + i;
				for (int j = 0; j < w; j++)
				{
					int num2 = x0 + (flipX ? (w - 1 - j) : j);
					if (num2 >= 0 && num2 < srcW && num >= 0 && num < srcH)
					{
						array[i * w + j] = src[num * srcW + num2];
					}
				}
			}
			Texture2D val2 = new Texture2D(w, h, (TextureFormat)4, false);
			val2.SetPixels32(array);
			val2.Apply();
			byte[] result2 = ImageConversion.EncodeToPNG(val2);
			Object.Destroy((Object)val2);
			return result2;
		}

		private static Sidecar ParseSidecar(string[] lines)
		{
			Sidecar sidecar = new Sidecar();
			FrameEntry frameEntry = null;
			for (int i = 0; i < lines.Length; i++)
			{
				string text = lines[i].Trim();
				if (text.Length != 0 && text[0] != '#')
				{
					if (text.StartsWith("issuedCanvas:"))
					{
						sidecar.CanvasW = IntAfter(text, "w:");
						sidecar.CanvasH = IntAfter(text, "h:");
					}
					else if (text.StartsWith("pivotInCanvas:"))
					{
						sidecar.PivotX = IntAfter(text, "x:");
						sidecar.PivotY = IntAfter(text, "y:");
					}
					else if (text.StartsWith("- spriteName:"))
					{
						frameEntry = new FrameEntry
						{
							Sprite = ParseStr(text)
						};
						sidecar.Frames.Add(frameEntry);
					}
					else if (frameEntry != null && text.StartsWith("collection:"))
					{
						frameEntry.Collection = ParseStr(text);
					}
					else if (frameEntry != null && text.StartsWith("material:"))
					{
						frameEntry.Material = ParseStr(text);
					}
					else if (frameEntry != null && text.StartsWith("dumpedFile:"))
					{
						frameEntry.DumpedFile = ParseStr(text);
					}
					else if (frameEntry != null && text.StartsWith("canvasRect:"))
					{
						frameEntry.RectX = IntAfter(text, "x:");
						frameEntry.RectY = IntAfter(text, "y:");
						frameEntry.RectW = IntAfter(text, "w:");
						frameEntry.RectH = IntAfter(text, "h:");
					}
					else if (frameEntry != null && text.StartsWith("flipped:"))
					{
						frameEntry.Flipped = text.Substring(text.IndexOf(':') + 1).Trim();
					}
					else if (frameEntry != null && text.StartsWith("baselineHash:"))
					{
						frameEntry.BaselineHash = ParseStr(text);
					}
				}
			}
			if (sidecar.Frames.Count <= 0)
			{
				return null;
			}
			return sidecar;
		}

		private static string ParseStr(string line)
		{
			int num = line.IndexOf('"');
			if (num < 0)
			{
				return "";
			}
			int num2 = line.IndexOf('"', num + 1);
			if (num2 < 0)
			{
				return "";
			}
			return line.Substring(num + 1, num2 - num - 1);
		}

		private static int IntAfter(string line, string key)
		{
			int num = line.IndexOf(key, StringComparison.Ordinal);
			if (num < 0)
			{
				return 0;
			}
			int i;
			for (i = num + key.Length; i < line.Length && line[i] == ' '; i++)
			{
			}
			int num2 = i;
			if (i < line.Length && (line[i] == '-' || line[i] == '+'))
			{
				i++;
			}
			for (; i < line.Length && char.IsDigit(line[i]); i++)
			{
			}
			if (!int.TryParse(line.Substring(num2, i - num2), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return 0;
			}
			return result;
		}
	}
	internal static class AppliqueLoader
	{
		private sealed class Entry
		{
			public string CollName;

			public string ClipName;

			public string SpriteName;

			public string Anchor;

			public string FullPath;

			public string SourcePack;
		}

		private sealed class ShadowSprite
		{
			public Texture2D Tex;

			public Material Mat;

			public string LoadedPath;
		}

		private const string LogPrefix = "[Applique]";

		internal const string ShadowNamePrefix = "Stitchwork_Shadow";

		private static readonly Dictionary<string, Entry> _index = new Dictionary<string, Entry>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, tk2dSpriteCollectionData> _shadows = new Dictionary<string, tk2dSpriteCollectionData>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, ShadowSprite> _shadowSprites = new Dictionary<string, ShadowSprite>(StringComparer.OrdinalIgnoreCase);

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

		private static readonly Dictionary<tk2dSpriteAnimationClip, List<(int idx, tk2dSpriteCollectionData coll, int id)>> _backups = new Dictionary<tk2dSpriteAnimationClip, List<(int, tk2dSpriteCollectionData, int)>>();

		private static bool _rotatedNoteShown;

		internal static int IndexCount => _index.Count;

		internal static int IndexPackCount
		{
			get
			{
				int num = 0;
				foreach (Entry value in _index.Values)
				{
					if (value.SourcePack != null)
					{
						num++;
					}
				}
				return num;
			}
		}

		internal static void ClearIndex()
		{
			_index.Clear();
		}

		internal static bool HasClipOverride(string collName, string clipName, string spriteName)
		{
			if (collName != null && clipName != null && spriteName != null)
			{
				return _index.ContainsKey(collName + "/" + clipName + "/" + spriteName);
			}
			return false;
		}

		internal static bool HasAnyClipOverridesFor(string collName)
		{
			if (string.IsNullOrEmpty(collName))
			{
				return false;
			}
			foreach (Entry value in _index.Values)
			{
				if (string.Equals(value.CollName, collName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static void IndexFile(string rel, string fullPath, string sourcePack)
		{
			string[] array = rel.Split('/');
			if (array.Length != 4 || array[3].Length <= 4 || !array[3].EndsWith(".png", StringComparison.OrdinalIgnoreCase))
			{
				Plugin.Logger.LogWarning((object)("[Applique] Ignoring '" + rel + "' — expected Sprites/<coll>/Clips/<clip>/<sprite>.png."));
				return;
			}
			(string name, string anchor) tuple = IOUtil.ParseAnchorTag(array[3].Substring(0, array[3].Length - 4));
			string item = tuple.name;
			string item2 = tuple.anchor;
			string key = array[0] + "/" + array[2] + "/" + item;
			if (_index.TryGetValue(key, out var value))
			{
				if (!IOUtil.BenignDuplicate(value.FullPath, fullPath))
				{
					ConflictTracker.Record("clip", key, value.SourcePack, sourcePack, Path.GetFileName(value.FullPath) + " › " + Path.GetFileName(fullPath), value.FullPath, fullPath);
				}
				return;
			}
			_index[key] = new Entry
			{
				CollName = array[0],
				ClipName = array[2],
				SpriteName = item,
				Anchor = item2,
				FullPath = fullPath,
				SourcePack = sourcePack
			};
		}

		internal static void Apply()
		{
			int num = RestoreAll();
			if (!Plugin.Config.EnableApplique || _index.Count == 0)
			{
				if (num > 0)
				{
					Plugin.Logger.LogInfo((object)string.Format("{0} Reverted {1} frame entr(ies); no active clip overrides.", "[Applique]", num));
				}
				return;
			}
			Dictionary<string, List<tk2dSpriteAnimationClip>> dictionary = new Dictionary<string, List<tk2dSpriteAnimationClip>>(StringComparer.OrdinalIgnoreCase);
			tk2dSpriteAnimation[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteAnimation>();
			foreach (tk2dSpriteAnimation val in array)
			{
				if ((Object)(object)val == (Object)null || val.clips == null)
				{
					continue;
				}
				tk2dSpriteAnimationClip[] clips = val.clips;
				foreach (tk2dSpriteAnimationClip val2 in clips)
				{
					if (val2 != null && !string.IsNullOrEmpty(val2.name) && val2.frames != null)
					{
						if (!dictionary.TryGetValue(val2.name, out var value))
						{
							value = (dictionary[val2.name] = new List<tk2dSpriteAnimationClip>());
						}
						value.Add(val2);
					}
				}
			}
			int num2 = 0;
			int num3 = 0;
			List<string> list2 = new List<string>();
			foreach (Entry value4 in _index.Values)
			{
				if (!dictionary.TryGetValue(value4.ClipName, out var value2))
				{
					list2.Add(value4.ClipName);
					continue;
				}
				int num4 = -1;
				bool flag = false;
				bool flag2 = false;
				tk2dSpriteCollectionData spriteCollection = null;
				foreach (tk2dSpriteAnimationClip item in value2)
				{
					for (int k = 0; k < item.frames.Length; k++)
					{
						tk2dSpriteAnimationFrame val3 = item.frames[k];
						tk2dSpriteCollectionData spriteCollection2 = val3.spriteCollection;
						if ((Object)(object)spriteCollection2 == (Object)null || !string.Equals(((Object)spriteCollection2).name, value4.CollName, StringComparison.OrdinalIgnoreCase) || spriteCollection2.spriteDefinitions == null || val3.spriteId < 0 || val3.spriteId >= spriteCollection2.spriteDefinitions.Length)
						{
							continue;
						}
						tk2dSpriteDefinition val4 = spriteCollection2.spriteDefinitions[val3.spriteId];
						if (val4 == null || !string.Equals(val4.name, value4.SpriteName, StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						if (num4 < 0)
						{
							if (flag)
							{
								flag2 = true;
								break;
							}
							flag = true;
							(spriteCollection, num4) = BuildShadowDef(value4, spriteCollection2, val4);
							if (num4 < 0)
							{
								flag2 = true;
								break;
							}
							num3++;
						}
						if (!_backups.TryGetValue(item, out List<(int, tk2dSpriteCollectionData, int)> value3))
						{
							value3 = (_backups[item] = new List<(int, tk2dSpriteCollectionData, int)>());
						}
						value3.Add((k, spriteCollection2, val3.spriteId));
						item.frames[k].spriteCollection = spriteCollection;
						item.frames[k].spriteId = num4;
						num2++;
					}
					if (flag2)
					{
						break;
					}
				}
			}
			if (num2 > 0 || num > 0 || list2.Count > 0)
			{
				List<string> list4 = list2.Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList();
				string arg = ((list4.Count > 0) ? string.Format("; {0} clip name(s) not loaded yet ({1}{2})", list4.Count, string.Join(", ", list4.Take(4)), (list4.Count > 4) ? ", …" : "") : "");
				Plugin.Logger.LogInfo((object)(string.Format("{0} {1} frame entr(ies) diverted across {2} clip-sprite(s) ", "[Applique]", num2, num3) + $"({_index.Count} indexed; {num} restored first){arg}"));
			}
		}

		private static int RestoreAll()
		{
			int num = 0;
			foreach (KeyValuePair<tk2dSpriteAnimationClip, List<(int, tk2dSpriteCollectionData, int)>> backup in _backups)
			{
				tk2dSpriteAnimationClip key = backup.Key;
				if (key == null || key.frames == null)
				{
					continue;
				}
				foreach (var (num2, spriteCollection, spriteId) in backup.Value)
				{
					if (num2 >= 0 && num2 < key.frames.Length)
					{
						tk2dSpriteCollectionData spriteCollection2 = key.frames[num2].spriteCollection;
						if (!((Object)(object)spriteCollection2 == (Object)null) && _shadowCollIds.Contains(((Object)spriteCollection2).GetInstanceID()))
						{
							key.frames[num2].spriteCollection = spriteCollection;
							key.frames[num2].spriteId = spriteId;
							num++;
						}
					}
				}
			}
			_backups.Clear();
			return num;
		}

		private static (tk2dSpriteCollectionData shadow, int id) BuildShadowDef(Entry entry, tk2dSpriteCollectionData vanillaColl, tk2dSpriteDefinition vanillaDef)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Invalid comparison between Unknown and I4
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_063b: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d5: Expected O, but got Unknown
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_078f: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07be: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07db: Unknown result type (might be due to invalid IL or missing references)
			//IL_07dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
			byte[] array;
			try
			{
				array = File.ReadAllBytes(IOUtil.LongSafe(entry.FullPath));
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[Applique] Read failed for '" + entry.FullPath + "': " + ex.Message));
				return (shadow: null, id: -1);
			}
			if (vanillaDef.complexGeometry)
			{
				Plugin.Logger.LogWarning((object)("[Applique] '" + entry.SpriteName + "' has complex geometry — per-clip override skipped (unsupported in v1)."));
				return (shadow: null, id: -1);
			}
			string key = entry.CollName + "/" + entry.ClipName + "/" + entry.SpriteName;
			if (!_shadowSprites.TryGetValue(key, out var value))
			{
				value = (_shadowSprites[key] = new ShadowSprite());
			}
			if ((Object)(object)value.Tex == (Object)null)
			{
				value.Tex = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					hideFlags = (HideFlags)32,
					wrapMode = (TextureWrapMode)1
				};
			}
			if (!ImageConversion.LoadImage(value.Tex, array))
			{
				Plugin.Logger.LogWarning((object)("[Applique] PNG decode failed for '" + entry.FullPath + "'"));
				return (shadow: null, id: -1);
			}
			value.LoadedPath = entry.FullPath;
			Material val = (((Object)(object)vanillaDef.materialInst != (Object)null) ? vanillaDef.materialInst : vanillaDef.material);
			if ((Object)(object)value.Mat == (Object)null)
			{
				value.Mat = new Material(val)
				{
					hideFlags = (HideFlags)32
				};
			}
			value.Mat.mainTexture = (Texture)(object)value.Tex;
			Vector3[] positions = vanillaDef.positions;
			float num = float.MaxValue;
			float num2 = float.MinValue;
			float num3 = float.MaxValue;
			float num4 = float.MinValue;
			Vector3[] array2 = positions;
			foreach (Vector3 val2 in array2)
			{
				if (val2.x < num)
				{
					num = val2.x;
				}
				if (val2.x > num2)
				{
					num2 = val2.x;
				}
				if (val2.y < num3)
				{
					num3 = val2.y;
				}
				if (val2.y > num4)
				{
					num4 = val2.y;
				}
			}
			float num5 = num2 - num;
			float num6 = num4 - num3;
			if (num5 < 1E-06f || num6 < 1E-06f)
			{
				Plugin.Logger.LogWarning((object)("[Applique] Degenerate vanilla quad for '" + entry.SpriteName + "' — skipped."));
				return (shadow: null, id: -1);
			}
			Texture val3 = (((Object)(object)val != (Object)null) ? val.mainTexture : null);
			bool flag = (int)vanillaDef.flipped > 0;
			float num7 = float.MaxValue;
			float num8 = float.MinValue;
			float num9 = float.MaxValue;
			float num10 = float.MinValue;
			Vector2[] uvs = vanillaDef.uvs;
			foreach (Vector2 val4 in uvs)
			{
				if (val4.x < num7)
				{
					num7 = val4.x;
				}
				if (val4.x > num8)
				{
					num8 = val4.x;
				}
				if (val4.y < num9)
				{
					num9 = val4.y;
				}
				if (val4.y > num10)
				{
					num10 = val4.y;
				}
			}
			float num11 = (num8 - num7) * (float)((!((Object)(object)val3 != (Object)null)) ? 1 : val3.width);
			float num12 = (num10 - num9) * (float)((!((Object)(object)val3 != (Object)null)) ? 1 : val3.height);
			int num13 = Mathf.Max(1, Mathf.RoundToInt(flag ? num12 : num11));
			int num14 = Mathf.Max(1, Mathf.RoundToInt(flag ? num11 : num12));
			float num15 = num5 / (float)num13;
			float num16 = num6 / (float)num14;
			int width = ((Texture)value.Tex).width;
			int height = ((Texture)value.Tex).height;
			int num17 = width - num13;
			int num18 = height - num14;
			string text = entry.Anchor ?? "bottom-center";
			float num19;
			float num20;
			float num21;
			float num22;
			if (IOUtil.TryParsePivotAnchor(text, out var px, out var py))
			{
				num19 = (float)(-px) * num15;
				num20 = (float)(width - px) * num15;
				num21 = (float)(-py) * num16;
				num22 = (float)(height - py) * num16;
			}
			else
			{
				switch (text)
				{
				case "top-center":
					num19 = num - (float)num17 * 0.5f * num15;
					num20 = num2 + (float)num17 * 0.5f * num15;
					num22 = num4;
					num21 = num3 - (float)num18 * num16;
					break;
				case "left-center":
					num19 = num;
					num20 = num2 + (float)num17 * num15;
					num21 = num3 - (float)num18 * 0.5f * num16;
					num22 = num4 + (float)num18 * 0.5f * num16;
					break;
				case "right-center":
					num20 = num2;
					num19 = num - (float)num17 * num15;
					num21 = num3 - (float)num18 * 0.5f * num16;
					num22 = num4 + (float)num18 * 0.5f * num16;
					break;
				case "center":
					num19 = num - (float)num17 * 0.5f * num15;
					num20 = num2 + (float)num17 * 0.5f * num15;
					num21 = num3 - (float)num18 * 0.5f * num16;
					num22 = num4 + (float)num18 * 0.5f * num16;
					break;
				default:
					num19 = num - (float)num17 * 0.5f * num15;
					num20 = num2 + (float)num17 * 0.5f * num15;
					num21 = num3;
					num22 = num4 + (float)num18 * num16;
					break;
				}
			}
			if (flag && !_rotatedNoteShown)
			{
				_rotatedNoteShown = true;
				Plugin.Logger.LogInfo((object)(string.Format("{0} NOTE: '{1}' has a rotated vanilla def ({2}). ", "[Applique]", entry.SpriteName, vanillaDef.flipped) + "Appliqué renders replacements upright by design; if this clip's art appears mirrored, report it — rotated-target parity is the one unverified orientation case."));
			}
			Vector3[] array3 = (Vector3[])(object)new Vector3[positions.Length];
			Vector2[] array4 = (Vector2[])(object)new Vector2[positions.Length];
			float num23 = 0.5f / (float)width;
			float num24 = 0.5f / (float)height;
			for (int j = 0; j < positions.Length; j++)
			{
				float num25 = (positions[j].x - num) / num5;
				float num26 = (positions[j].y - num3) / num6;
				array3[j] = new Vector3(num19 + num25 * (num20 - num19), num21 + num26 * (num22 - num21), positions[j].z);
				array4[j] = new Vector2((num25 > 0.5f) ? (1f - num23) : num23, (num26 > 0.5f) ? (1f - num24) : num24);
			}
			Vector3 val5 = default(Vector3);
			((Vector3)(ref val5))..ctor((num19 + num20) * 0.5f, (num21 + num22) * 0.5f, 0f);
			Vector3 val6 = default(Vector3);
			((Vector3)(ref val6))..ctor((num20 - num19) * 0.5f, (num22 - num21) * 0.5f, 0.1f);
			tk2dSpriteDefinition val7 = new tk2dSpriteDefinition();
			val7.name = entry.SpriteName + "#" + entry.ClipName;
			val7.material = value.Mat;
			val7.materialInst = value.Mat;
			val7.positions = array3;
			val7.uvs = array4;
			val7.normals = ((vanillaDef.normals != null) ? ((Vector3[])vanillaDef.normals.Clone()) : null);
			val7.tangents = ((vanillaDef.tangents != null) ? ((Vector4[])vanillaDef.tangents.Clone()) : null);
			val7.indices = ((vanillaDef.indices != null) ? ((int[])vanillaDef.indices.Clone()) : null);
			val7.complexGeometry = false;
			val7.flipped = (FlipMode)0;
			val7.texelSize = new Vector2((num20 - num19) / (float)width, (num22 - num21) / (float)height);
			val7.boundsData = (Vector3[])(object)new Vector3[2] { val5, val6 };
			val7.untrimmedBoundsData = (Vector3[])(object)new Vector3[2] { val5, val6 };
			tk2dSpriteDefinition def = val7;
			tk2dSpriteCollectionData obj = EnsureShadow(entry.CollName);
			obj.premultipliedAlpha = vanillaColl.premultipliedAlpha;
			tk2dSpriteDefinition[] array5 = (tk2dSpriteDefinition[])(((object)obj.spriteDefinitions) ?? ((object)new tk2dSpriteDefinition[0]));
			int num27 = Array.FindIndex(array5, (tk2dSpriteDefinition d) => d != null && d.name == def.name);
			if (num27 < 0)
			{
				tk2dSpriteDefinition[] array6 = (tk2dSpriteDefinition[])(object)new tk2dSpriteDefinition[array5.Length + 1];
				array5.CopyTo(array6, 0);
				num27 = array5.Length;
				array5 = array6;
			}
			array5[num27] = def;
			def.materialId = num27;
			obj.spriteDefinitions = array5;
			Material[] array7 = (Material[])(((object)obj.materials) ?? ((object)new Material[0]));
			if (array7.Length < array5.Length)
			{
				Material[] array8 = (Material[])(object)new Material[array5.Length];
				array7.CopyTo(array8, 0);
				array7 = array8;
			}
			array7[num27] = value.Mat;
			obj.materials = array7;
			return (shadow: obj, id: num27);
		}

		private static tk2dSpriteCollectionData EnsureShadow(string collName)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (_shadows.TryGetValue(collName, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			GameObject val = new GameObject("Stitchwork_Shadow_" + collName);
			Object.DontDestroyOnLoad((Object)val);
			tk2dSpriteCollectionData val2 = val.AddComponent<tk2dSpriteCollectionData>();
			val2.spriteDefinitions = (tk2dSpriteDefinition[])(object)new tk2dSpriteDefinition[0];
			val2.materials = (Material[])(object)new Material[0];
			_shadows[collName] = val2;
			_shadowCollIds.Add(((Object)val2).GetInstanceID());
			return val2;
		}
	}
	public static class AudioCatalog
	{
		private static readonly HashSet<string> _names = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static bool _loaded;

		private static bool _dirty;

		private static string CatalogPath => Path.Combine(Plugin.BasePath, "audio-catalog.txt");

		public static IReadOnlyCollection<string> Names
		{
			get
			{
				EnsureLoaded();
				return _names;
			}
		}

		public static int Count
		{
			get
			{
				EnsureLoaded();
				return _names.Count;
			}
		}

		public static void Observe(string clipName)
		{
			if (!string.IsNullOrEmpty(clipName))
			{
				EnsureLoaded();
				if (_names.Add(Clean(clipName)))
				{
					_dirty = true;
				}
			}
		}

		public static void ObserveMany(IEnumerable<string> clipNames)
		{
			if (clipNames == null)
			{
				return;
			}
			EnsureLoaded();
			foreach (string clipName in clipNames)
			{
				if (!string.IsNullOrEmpty(clipName) && _names.Add(Clean(clipName)))
				{
					_dirty = true;
				}
			}
		}

		public static bool Contains(string clipName)
		{
			if (string.IsNullOrEmpty(clipName))
			{
				return false;
			}
			EnsureLoaded();
			return _names.Contains(Clean(clipName));
		}

		private static string Clean(string name)
		{
			return name.Replace("PATCHWORK_", "");
		}

		private static void EnsureLoaded()
		{
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			try
			{
				if (!File.Exists(CatalogPath))
				{
					return;
				}
				string[] array = File.ReadAllLines(CatalogPath);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.Length > 0 && text[0] != '#')
					{
						_names.Add(text);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[AudioCatalog] load failed: " + ex.Message));
			}
		}

		public static void Flush()
		{
			if (!_dirty)
			{
				return;
			}
			EnsureLoaded();
			try
			{
				List<string> list = new List<string>(_names);
				list.Sort(StringComparer.OrdinalIgnoreCase);
				StringBuilder stringBuilder = new StringBuilder(list.Count * 24 + 128);
				stringBuilder.AppendLine("# Stitchwork audio catalog — every clip name observed (loaded or played).");
				stringBuilder.AppendLine("# Auto-maintained, persisted across sessions. One clip name per line.");
				stringBuilder.AppendLine("# A name here that your pack doesn't cover is a replacement opportunity.");
				foreach (string item in list)
				{
					stringBuilder.AppendLine(item);
				}
				File.WriteAllText(CatalogPath, stringBuilder.ToString());
				_dirty = false;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[AudioCatalog] save failed: " + ex.Message));
			}
		}
	}
	public static class AudioDumper
	{
		private static GameObject _previewGO;

		public static string DumpPath => Path.Combine(SpriteDumper.DumpPath, "Audio");

		public static void Preview(AudioClip clip)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (!((Object)(object)clip == (Object)null))
			{
				if ((Object)(object)_previewGO == (Object)null)
				{
					_previewGO = new GameObject("StitchworkAudioPreview")
					{
						hideFlags = (HideFlags)61
					};
					Object.DontDestroyOnLoad((Object)(object)_previewGO);
					AudioSource obj = _previewGO.AddComponent<AudioSource>();
					obj.spatialBlend = 0f;
					obj.playOnAwake = false;
				}
				AudioSource component = _previewGO.GetComponent<AudioSource>();
				component.Stop();
				component.clip = clip;
				component.volume = 1f;
				component.Play();
			}
		}

		public static void StopPreview()
		{
			GameObject previewGO = _previewGO;
			if (previewGO != null)
			{
				AudioSource component = previewGO.GetComponent<AudioSource>();
				if (component != null)
				{
					component.Stop();
				}
			}
		}

		public static IEnumerator CaptureClipAsync(AudioClip clip, Action<bool, string> onDone)
		{
			if ((Object)(object)clip == (Object)null)
			{
				onDone(arg1: false, "no vanilla clip in memory for that name.");
				yield break;
			}
			GameObject go = new GameObject("StitchworkAudioCapture")
			{
				hideFlags = (HideFlags)61
			};
			AudioSource src = go.AddComponent<AudioSource>();
			AudioCaptureFilter cap = go.AddComponent<AudioCaptureFilter>();
			src.spatialBlend = 0f;
			src.volume = 1f;
			src.playOnAwake = false;
			src.clip = clip;
			cap.Capturing = true;
			src.Play();
			float deadline = Time.realtimeSinceStartup + clip.length + 2f;
			yield return null;
			while (src.isPlaying && Time.realtimeSinceStartup < deadline)
			{
				yield return null;
			}
			cap.Capturing = false;
			yield return null;
			yield return null;
			src.Stop();
			int num = ((cap.Channels > 0) ? cap.Channels : Mathf.Max(1, clip.channels));
			int outputSampleRate = AudioSettings.outputSampleRate;
			float[] array = cap.Samples.ToArray();
			Object.Destroy((Object)(object)go);
			if (array.Length == 0)
			{
				onDone(arg1: false, "'" + ((Object)clip).name + "' capture produced no samples (clip didn't play — muted or zero-length?).");
				yield break;
			}
			IOUtil.EnsureDirectoryExists(DumpPath);
			string text = T2DUtil.SanitizeForFilesystem(((Object)clip).name.Replace("PATCHWORK_", ""));
			string text2 = Path.Combine(DumpPath, text + ".wav");
			WriteWav16(text2, array, num, outputSampleRate);
			onDone(arg1: true, $"{text2}  ({array.Length / Mathf.Max(1, num)} frames @ {outputSampleRate} Hz, {num}ch)");
		}

		private static void WriteWav16(string path, float[] samples, int channels, int frequency)
		{
			int value = frequency * channels * 2;
			int num = channels * 2;
			int num2 = samples.Length * 2;
			using FileStream output = new FileStream(path, FileMode.Create, FileAccess.Write);
			using BinaryWriter binaryWriter = new BinaryWriter(output);
			binaryWriter.Write(Encoding.ASCII.GetBytes("RIFF"));
			binaryWriter.Write(36 + num2);
			binaryWriter.Write(Encoding.ASCII.GetBytes("WAVE"));
			binaryWriter.Write(Encoding.ASCII.GetBytes("fmt "));
			binaryWriter.Write(16);
			binaryWriter.Write((short)1);
			binaryWriter.Write((short)channels);
			binaryWriter.Write(frequency);
			binaryWriter.Write(value);
			binaryWriter.Write((short)num);
			binaryWriter.Write((short)16);
			binaryWriter.Write(Encoding.ASCII.GetBytes("data"));
			binaryWriter.Write(num2);
			foreach (float num3 in samples)
			{
				binaryWriter.Write((short)Mathf.Clamp(Mathf.RoundToInt(num3 * 32767f), -32768, 32767));
			}
		}
	}
	public class AudioCaptureFilter : MonoBehaviour
	{
		public readonly List<float> Samples = new List<float>();

		public int Channels;

		public volatile bool Capturing;

		private void OnAudioFilterRead(float[] data, int channels)
		{
			if (Capturing)
			{
				Channels = channels;
				Samples.AddRange(data);
				Array.Clear(data, 0, data.Length);
			}
		}
	}
	public sealed class AudioClipEntry
	{
		public readonly string ClipName;

		public readonly float LengthSeconds;

		public readonly int Channels;

		public readonly int Frequency;

		public readonly bool HasReplacement;

		public readonly bool CurrentlyLoaded;

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

		public AudioClipEntry(string name, float length, int channels, int frequency, bool hasReplacement)
		{
			ClipName = name;
			LengthSeconds = length;
			Channels = channels;
			Frequency = frequency;
			HasReplacement = hasReplacement;
			CurrentlyLoaded = true;
		}

		public AudioClipEntry(string name, bool hasReplacement)
		{
			ClipName = name;
			HasReplacement = hasReplacement;
			CurrentlyLoaded = false;
		}
	}
	[HarmonyPatch]
	public static class AudioHandler
	{
		public static readonly string SoundFolder = Path.Combine(Plugin.BasePath, "Sounds");

		internal static readonly string[] SupportedExtensions = new string[5] { ".ogg", ".wav", ".mp3", ".aiff", ".aif" };

		private static readonly Dictionary<string, AudioClip> LoadedClips = new Dictionary<string, AudioClip>();

		private static readonly Dictionary<int, AudioClip> _originalClips = new Dictionary<int, AudioClip>();

		private static readonly Dictionary<string, string> _soundIndex = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static bool _indexBuilt;

		private static bool _reverting;

		private static bool _inAudioPlayChain;

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

		private static int _reloadGeneration;

		public static bool IsAudioBrowserActive;

		private static FieldInfo _pmAudioClipField;

		private static PropertyInfo _pmFsmValueProp;

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

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

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

		private static bool _applySweepScheduled;

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

		public static bool HasAudioReplacements
		{
			get
			{
				if (_indexBuilt)
				{
					return _soundIndex.Count > 0;
				}
				return false;
			}
		}

		public static string MuteFilePath => Path.Combine(SoundFolder, "mute.txt");

		public static int CachedClipCount => LoadedClips.Count;

		public static event Action<AudioClip, AudioSource> OnAudioPlayed;

		public static void ApplyPatches(Harmony harmony)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_011d: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01b1: Expected O, but got Unknown
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Expected O, but got Unknown
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Method(typeof(AudioSource), "PlayHelper", new Type[2]
			{
				typeof(AudioSource),
				typeof(ulong)
			}, (Type[])null), new HarmonyMethod(typeof(AudioHandler), "PlayHelperPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(AudioSource), "PlayOneShotHelper", new Type[3]
			{
				typeof(AudioSource),
				typeof(AudioClip),
				typeof(float)
			}, (Type[])null), new HarmonyMethod(typeof(AudioHandler), "PlayOneShotHelperPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo = AccessTools.Method(typeof(AudioSource), "PlayOneShot", new Type[1] { typeof(AudioClip) }, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(AudioHandler), "PlayOneShotPublicPrefix1Arg", (Type[])null), new HarmonyMethod(typeof(AudioHandler), "PlayOneShotPublicPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.Logger.LogInfo((object)"[Audio] hooked AudioSource.PlayOneShot(AudioClip)");
			}
			else
			{
				Plugin.Logger.LogWarning((object)"[Audio] AudioSource.PlayOneShot(AudioClip) not found — single-arg public hook skipped");
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(AudioSource), "PlayOneShot", new Type[2]
			{
				typeof(AudioClip),
				typeof(float)
			}, (Type[])null);
			if (methodInfo2 != null)
			{
				harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(AudioHandler), "PlayOneShotPublicPrefix2Arg", (Type[])null), new HarmonyMethod(typeof(AudioHandler), "PlayOneShotPublicPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.Logger.LogInfo((object)"[Audio] hooked AudioSource.PlayOneShot(AudioClip, float)");
			}
			else
			{
				Plugin.Logger.LogWarning((object)"[Audio] AudioSource.PlayOneShot(AudioClip, float) not found — two-arg public hook skipped");
			}
			TryPatchSourcePlay(harmony, "Play", Type.EmptyTypes, "PlayInstancePrefix", "SourcePlayPostfix");
			TryPatchSourcePlay(harmony, "Play", new Type[1] { typeof(double) }, "PlayInstancePrefix", "SourcePlayPostfix");
			TryPatchSourcePlay(harmony, "PlayDelayed", new Type[1] { typeof(float) }, "PlayInstancePrefix", "SourcePlayPostfix");
			TryPatchSourcePlay(harmony, "PlayScheduled", new Type[1] { typeof(double) }, "PlayInstancePrefix", "SourcePlayPostfix");
			harmony.Patch((MethodBase)AccessTools.PropertySetter(typeof(AudioSource), "clip"), (HarmonyMethod)null, new HarmonyMethod(typeof(AudioHandler), "ClipSetterPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Type type = AccessTools.TypeByName("OverrideNeedolinLoop");
			if (type != null)
			{
				MethodInfo methodInfo3 = AccessTools.Method(type, "StartSyncedAudio", new Type[2]
				{
					typeof(AudioSource),
					typeof(AudioClip)
				}, (Type[])null);
				if (methodInfo3 != null)
				{
					harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(AudioHandler), "StartSyncedAudioPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					Plugin.Logger.LogWarning((object)"[Audio] OverrideNeedolinLoop.StartSyncedAudio(AudioSource, AudioClip) not found — Needolin loop replacement disabled");
				}
			}
			else
			{
				Plugin.Logger.LogWarning((object)"[Audio] OverrideNeedolinLoop type not found — Needolin loop replacement disabled");
			}
			Type type2 = AccessTools.TypeByName("HutongGames.PlayMaker.Actions.SetAudioClip");
			if (type2 != null)
			{
				MethodInfo methodInfo4 = AccessTools.Method(type2, "OnEnter", (Type[])null, (Type[])null);
				_pmAudioClipField = type2.GetField("audioClip", BindingFlags.Instance | BindingFlags.Public);
				if (_pmAudioClipField != null)
				{
					_pmFsmValueProp = _pmAudioClipField.FieldType.GetProperty("Value");
				}
				if (methodInfo4 != null && _pmAudioClipField != null && _pmFsmValueProp != null)
				{
					harmony.Patch((MethodBase)methodInfo4, new HarmonyMethod(typeof(AudioHandler), "SetAudioClipOnEnterPatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void LogAudioCall(string route, AudioClip clip, AudioSource source)
		{
			if (!((Object)(object)clip == (Object)null))
			{
				string text = ((Object)clip).name ?? "<null-name>";
				string text2 = text.Replace("PATCHWORK_", "");
				AudioCatalog.Observe(text2);
				string arg = (((Object)(object)source != (Object)null && (Object)(object)((Component)source).gameObject != (Object)null) ? ((Object)((Component)source).gameObject).name : "<no-src>");
				Log.Verbose("[Audio] route=" + route + " clip=" + text + " clean=" + text2 + " " + $"hasRepl={_soundIndex.ContainsKey(text2)} cached={LoadedClips.ContainsKey(text2)} src={arg}");
			}
		}

		private static bool IsDiagnosticSource(AudioSource source)
		{
			if ((Object)(object)source != (Object)null)
			{
				return ((Object)((Component)source).gameObject).name.StartsWith("Stitchwork", StringComparison.Ordinal);
			}
			return false;
		}

		public static bool PlayHelperPatch(AudioSource source, ulong delay)
		{
			if (_inAudioPlayChain)
			{
				return true;
			}
			if (IsDiagnosticSource(source))
			{
				return true;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				if ((Object)(object)source.clip != (Object)null)
				{
					LogAudioCall("PlayHelper", source.clip, source);
					AudioHandler.OnAudioPlayed?.Invoke(source.clip, source);
					if (_mutedClips.Count > 0 && IsMuted(((Object)source.clip).name))
					{
						return false;
					}
					LoadAudio(source);
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.PlayHelper", heapBefore);
			}
			return true;
		}

		private static void TryPatchSourcePlay(Harmony harmony, string methodName, Type[] paramTypes, string prefix, string postfix)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00be: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(AudioSource), methodName, paramTypes, (Type[])null);
			string text = "AudioSource." + methodName + "(" + string.Join(", ", paramTypes.Select((Type t) => t.Name)) + ")";
			if (methodInfo == null)
			{
				Plugin.Logger.LogWarning((object)("[Audio] " + text + " not found — hook skipped"));
				return;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(AudioHandler), prefix, (Type[])null), new HarmonyMethod(typeof(AudioHandler), postfix, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.Logger.LogInfo((object)("[Audio] hooked " + text));
		}

		public static bool PlayInstancePrefix(AudioSource __instance)
		{
			if (IsDiagnosticSource(__instance))
			{
				return true;
			}
			if (_inAudioPlayChain)
			{
				return true;
			}
			_inAudioPlayChain = true;
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.clip == (Object)null)
			{
				return true;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				LogAudioCall("Play", __instance.clip, __instance);
				AudioHandler.OnAudioPlayed?.Invoke(__instance.clip, __instance);
				if (_mutedClips.Count > 0 && IsMuted(((Object)__instance.clip).name))
				{
					return false;
				}
				LoadAudio(__instance);
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.Play", heapBefore);
			}
			return true;
		}

		public static void SourcePlayPostfix()
		{
			_inAudioPlayChain = false;
		}

		public static bool PlayOneShotHelperPatch(AudioSource source, ref AudioClip clip, float volumeScale)
		{
			if (_inAudioPlayChain)
			{
				return true;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				if ((Object)(object)clip != (Object)null)
				{
					LogAudioCall("PlayOneShot", clip, source);
					AudioHandler.OnAudioPlayed?.Invoke(clip, source);
					if (_mutedClips.Count > 0 && IsMuted(((Object)clip).name))
					{
						return false;
					}
					LoadAudio(ref clip);
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.PlayOneShot", heapBefore);
			}
			return true;
		}

		public static bool PlayOneShotPublicPrefix1Arg(AudioSource __instance, AudioClip clip)
		{
			return DispatchPublicPlayOneShot(__instance, clip, 1f);
		}

		public static bool PlayOneShotPublicPrefix2Arg(AudioSource __instance, AudioClip clip, float volumeScale)
		{
			return DispatchPublicPlayOneShot(__instance, clip, volumeScale);
		}

		private static bool DispatchPublicPlayOneShot(AudioSource source, AudioClip clip, float volumeScale)
		{
			if (_inAudioPlayChain)
			{
				return true;
			}
			if ((Object)(object)source == (Object)null || (Object)(object)clip == (Object)null)
			{
				return true;
			}
			_inAudioPlayChain = true;
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				LogAudioCall("PlayOneShot.Public", clip, source);
				AudioHandler.OnAudioPlayed?.Invoke(clip, source);
				string text = ((Object)clip).name?.Replace("PATCHWORK_", "") ?? string.Empty;
				if (IsMuted(text))
				{
					return false;
				}
				if (LoadedClips.TryGetValue(text, out var value) && (Object)(object)value != (Object)null && (Object)(object)value != (Object)(object)clip)
				{
					try
					{
						source.PlayOneShot(value, volumeScale);
					}
					catch (Exception ex)
					{
						Plugin.Logger.LogWarning((object)("[Audio] PlayOneShot.Public substitute failed for '" + text + "': " + ex.Message));
						return true;
					}
					return false;
				}
				if (_soundIndex.ContainsKey(text))
				{
					EnqueueLoad(text);
				}
				return true;
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.PlayOneShot.Public", heapBefore);
			}
		}

		public static void PlayOneShotPublicPostfix()
		{
			_inAudioPlayChain = false;
		}

		public static void ClipSetterPatch(AudioSource __instance, AudioClip value)
		{
			if (IsDiagnosticSource(__instance))
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				if ((Object)(object)value != (Object)null)
				{
					LogAudioCall("ClipSetter", value, __instance);
					AudioHandler.OnAudioPlayed?.Invoke(value, __instance);
					if (!_reverting && (!((Object)value).name.StartsWith("PATCHWORK_") || !LoadedClips.ContainsKey(((Object)value).name.Replace("PATCHWORK_", ""))))
					{
						LoadAudio(__instance);
					}
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.ClipSetter", heapBefore);
			}
		}

		public static void StartSyncedAudioPatch(AudioSource targetSource, ref AudioClip defaultClip)
		{
			if ((Object)(object)defaultClip == (Object)null || string.IsNullOrEmpty(((Object)defaultClip).name))
			{
				return;
			}
			LogAudioCall("NeedolinSync", defaultClip, targetSource);
			string text = ((Object)defaultClip).name.Replace("PATCHWORK_", "");
			if (!_soundIndex.ContainsKey(text))
			{
				return;
			}
			int num = (((Object)(object)targetSource != (Object)null) ? ((Object)targetSource).GetInstanceID() : (-1));
			if (num >= 0 && !((Object)defaultClip).name.StartsWith("PATCHWORK_") && !_originalClips.ContainsKey(num))
			{
				_originalClips[num] = defaultClip;
			}
			if (LoadedClips.TryGetValue(text, out var value))
			{
				if (!((Object)defaultClip).name.StartsWith("PATCHWORK_"))
				{
					WarnIfFormatMismatch(defaultClip, value);
				}
				defaultClip = value;
			}
			else
			{
				EnqueueLoad(text);
			}
		}

		public static void SetAudioClipOnEnterPatch(object __instance)
		{
			try
			{
				object value = _pmAudioClipField.GetValue(__instance);
				if (value == null)
				{
					return;
				}
				object? value2 = _pmFsmValueProp.GetValue(value);
				AudioClip val = (AudioClip)((value2 is AudioClip) ? value2 : null);
				if ((Object)(object)val == (Object)null || string.IsNullOrEmpty(((Object)val).name))
				{
					return;
				}
				LogAudioCall("PMSetAudioClip", val, null);
				string name = ((Object)val).name;
				if (_soundIndex.ContainsKey(name))
				{
					if (LoadedClips.TryGetValue(name, out var value3))
					{
						_pmFsmValueProp.SetValue(value, value3);
					}
					else
					{
						EnqueueLoad(name);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)$"[Audio] SetAudioClipOnEnterPatch: {(ex as TargetInvocationException)?.InnerException ?? ex}");
			}
		}

		public static void Reload()
		{
			ReloadInternal(clearCache: true);
		}

		public static void PrimeForScene()
		{
			ReloadInternal(clearCache: false);
		}

		private static void ReloadInternal(bool clearCache)
		{
			AudioCatalog.Flush();
			RebuildSoundIndex();
			Plugin.Logger.LogDebug((object)("[Audio] " + (clearCache ? "Reload" : "PrimeForScene") + ": " + $"soundIndex={_soundIndex.Count} LoadedClips={LoadedClips.Count} _originalClips={_originalClips.Count}"));
			if (!HasAudioReplacements && LoadedClips.Count == 0)
			{
				Plugin.Logger.LogDebug((object)"[Audio] early exit — no replacements and no cached clips to restore");
				return;
			}
			if (clearCache)
			{
				LoadedClips.Clear();
				_loadingInProgress.Clear();
				_reloadGeneration++;
				_formatWarned.Clear();
			}
			AudioSource[] array = Resources.FindObjectsOfTypeAll<AudioSource>();
			foreach (AudioSource val in array)
			{
				if ((Object)(object)val == (Object)null || IsDiagnosticSource(val) || !((Object)(object)val.clip != (Object)null))
				{
					continue;
				}
				string text = ((Object)val.clip).name.Replace("PATCHWORK_", "");
				if (_soundIndex.ContainsKey(text))
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (!((Object)val.clip).name.StartsWith("PATCHWORK_") && !_originalClips.ContainsKey(instanceID))
					{
						_originalClips[instanceID] = val.clip;
					}
					if (LoadedClips.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
					{
						if ((Object)(object)val.clip != (Object)(object)value && !val.isPlaying)
						{
							val.clip = value;
						}
					}
					else
					{
						EnqueueLoad(text);
					}
				}
				else
				{
					if (!((Object)val.clip).name.StartsWith("PATCHWORK_"))
					{
						continue;
					}
					int instanceID2 = ((Object)val).GetInstanceID();
					if (!_originalClips.TryGetValue(instanceID2, out var value2) || (Object)(object)value2 == (Object)null)
					{
						foreach (AudioClip value3 in _originalClips.Values)
						{
							if ((Object)(object)value3 != (Object)null && string.Equals(((Object)value3).name, text, StringComparison.OrdinalIgnoreCase))
							{
								value2 = value3;
								break;
							}
						}
						if ((Object)(object)value2 == (Object)null)
						{
							AudioClip[] array2 = Resources.FindObjectsOfTypeAll<AudioClip>();
							foreach (AudioClip val2 in array2)
							{
								if ((Object)(object)val2 != (Object)null && !((Object)val2).name.StartsWith("PATCHWORK_") && string.Equals(((Object)val2).name, text, StringComparison.OrdinalIgnoreCase))
								{
									value2 = val2;
									break;
								}
							}
						}
						if ((Object)(object)value2 != (Object)null)
						{
							_originalClips[instanceID2] = value2;
						}
					}
					if ((Object)(object)value2 != (Object)null)
					{
						_reverting = true;
						val.clip = value2;
						_reverting = false;
						continue;
					}
					Plugin.Logger.LogWarning((object)("[Audio] Reload: cannot revert '" + text + "' on '" + ((Object)((Component)val).gameObject).name + "' — vanilla clip not found in memory"));
				}
			}
			foreach (string key in _soundIndex.Keys)
			{
				EnqueueLoad(key);
			}
		}

		private static void RebuildSoundIndex()
		{
			_soundIndex.Clear();
			_indexBuilt = true;
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				ScanDir(Path.Combine(pluginPackPath, "Sounds"));
			}
			ScanDir(SoundFolder);
			RebuildMuteList();
			static void ScanDir(string dir)
			{
				if (Directory.Exists(dir))
				{
					string[] files = Directory.GetFiles(dir, "*.*", SearchOption.AllDirectories);
					foreach (string text in files)
					{
						string value = Path.GetExtension(text).ToLowerInvariant();
						if (Array.IndexOf(SupportedExtensions, value) >= 0)
						{
							string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
							_soundIndex.TryAdd(fileNameWithoutExtension, text);
						}
					}
				}
			}
		}

		public static bool IsMuted(string rawName)
		{
			if (_mutedClips.Count == 0 || string.IsNullOrEmpty(rawName))
			{
				return false;
			}
			return _mutedClips.Contains(rawName.Replace("PATCHWORK_", ""));
		}

		public static bool IsRootMuted(string cleanName)
		{
			return _rootMutedClips.Contains(cleanName);
		}

		private static void RebuildMuteList()
		{
			_mutedClips.Clear();
			_rootMutedClips.Clear();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				ReadMuteFile(Path.Combine(pluginPackPath, "Sounds", "mute.txt"), null);
			}
			ReadMuteFile(MuteFilePath, _rootMutedClips);
			static void ReadMuteFile(string path, HashSet<string> alsoInto)
			{
				if (File.Exists(path))
				{
					string[] array = File.ReadAllLines(IOUtil.LongSafe(path));
					for (int i = 0; i < array.Length; i++)
					{
						string text = array[i].Trim();
						if (text.Length != 0 && !text.StartsWith("#"))
						{
							_mutedClips.Add(text);
							alsoInto?.Add(text);
						}
					}
				}
			}
		}

		public static void SetRootMute(string cleanName, bool mute)
		{
			if (string.IsNullOrEmpty(cleanName))
			{
				return;
			}
			List<string> list = (File.Exists(MuteFilePath) ? File.ReadAllLines(IOUtil.LongSafe(MuteFilePath)).ToList() : new List<string> { "# One clip name per line. Lines starting with # are comments." });
			if (mute)
			{
				if (!list.Any((string l) => string.Equals(l.Trim(), cleanName, StringComparison.OrdinalIgnoreCase)))
				{
					list.Add(cleanName);
				}
			}
			else
			{
				list.RemoveAll((string l) => string.Equals(l.Trim(), cleanName, StringComparison.OrdinalIgnoreCase));
			}
			IOUtil.EnsureDirectoryExists(SoundFolder);
			File.WriteAllLines(IOUtil.LongSafe(MuteFilePath), list);
			RebuildMuteList();
			Plugin.Logger.LogInfo((object)string.Format("[Audio] {0} '{1}' via root mute.txt ({2} total)", mute ? "Muted" : "Unmuted", cleanName, _mutedClips.Count));
		}

		public static void LoadAudio(AudioSource source)
		{
			if (!((Object)(object)source == (Object)null) && !((Object)(object)source.clip == (Object)null) && !string.IsNullOrEmpty(((Object)source.clip).name) && !IsDiagnosticSource(source))
			{
				string text = ((Object)source.clip).name.Replace("PATCHWORK_", "");
				int instanceID = ((Object)source).GetInstanceID();
				if (!((Object)source.clip).name.StartsWith("PATCHWORK_") && !_originalClips.ContainsKey(instanceID))
				{
					_originalClips[instanceID] = source.clip;
				}
				if (LoadedClips.TryGetValue(text, out var value))
				{
					source.clip = value;
				}
				else
				{
					EnqueueLoad(text);
				}
			}
		}

		public static void LoadAudio(ref AudioClip clip)
		{
			if (!((Object)(object)clip == (Object)null) && !string.IsNullOrEmpty(((Object)clip).name))
			{
				string text = ((Object)clip).name.Replace("PATCHWORK_", "");
				if (LoadedClips.TryGetValue(text, out var value))
				{
					clip = value;
				}
				else
				{
					EnqueueLoad(text);
				}
			}
		}

		private static void EnqueueLoad(string soundName)
		{
			if (!LoadedClips.ContainsKey(soundName) && !_loadingInProgress.Contains(soundName))
			{
				string soundPath = GetSoundPath(soundName);
				if (soundPath != null)
				{
					_loadingInProgress.Add(soundName);
					((MonoBehaviour)Plugin.Instance).StartCoroutine(LoadAudioClipAsync(soundName, soundPath, _reloadGeneration));
				}
			}
		}

		private static IEnumerator LoadAudioClipAsync(string soundName, string path, int gen)
		{
			string text = "file:///" + Uri.EscapeUriString(path.Replace("\\", "/"));
			UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(text, (AudioType)0);
			int num = Plugin.Config?.AudioCompressedInMemoryThresholdKB ?? 1024;
			if (num > 0)
			{
				DownloadHandler downloadHandler = request.downloadHandler;
				DownloadHandlerAudioClip val = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
				if (val != null)
				{
					long num2 = 0L;
					try
					{
						num2 = new FileInfo(path).Length;
					}
					catch (IOException)
					{
					}
					catch (UnauthorizedAccessException)
					{
					}
					if (num2 >= (long)num * 1024L)
					{
						val.compressed = true;
					}
				}
			}
			yield return request.SendWebRequest();
			_loadingInProgress.Remove(soundName);
			if (_reloadGeneration != gen)
			{
				yield break;
			}
			if ((int)request.result != 1)
			{
				Plugin.Logger.LogError((object)("[Audio] Failed to load '" + path + "': " + request.error));
				yield break;
			}
			AudioClip content = DownloadHandlerAudioClip.GetContent(request);
			((Object)content).name = "PATCHWORK_" + soundName;
			LoadedClips[soundName] = content;
			_completedAwaitingApply.Add(soundName);
			if (!_applySweepScheduled)
			{
				_applySweepScheduled = true;
				GameBridge.InvokeNext(ApplyCompletedLoads);
			}
		}

		private static void WarnIfFormatMismatch(AudioClip vanilla, AudioClip replacement)
		{
			if (!((Object)(object)vanilla == (Object)null) && !((Object)(object)replacement == (Object)null) && vanilla.frequency != replacement.frequency)
			{
				string text = ((Object)replacement).name.Replace("PATCHWORK_", "");
				if (_formatWarned.Add(text))
				{
					Plugin.Logger.LogWarning((object)($"[Audio] '{text}': replacement is {replacement.frequency} Hz but the vanilla clip " + $"is {vanilla.frequency} Hz. Synced tracks (Needolin melodies, layered music) will " + "periodically snap or rewind under the game's sample-based sync. " + $"Re-export the file at {vanilla.frequency} Hz."));
				}
			}
		}

		private static void ApplyCompletedLoads()
		{
			_applySweepScheduled = false;
			if (_completedAwaitingApply.Count == 0)
			{
				return;
			}
			AudioSource[] array = Resources.FindObjectsOfTypeAll<AudioSource>();
			foreach (AudioSource val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.clip == (Object)null || IsDiagnosticSource(val))
				{
					continue;
				}
				string text = ((Object)val.clip).name.Replace("PATCHWORK_", "");
				if (!_completedAwaitingApply.Contains(text) || !LoadedClips.TryGetValue(text, out var value) || (Object)(object)value == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)val).GetInstanceID();
				if (!((Object)val.clip).name.StartsWith("PATCHWORK_") && !_originalClips.ContainsKey(instanceID))
				{
					_originalClips[instanceID] = val.clip;
				}
				bool flag = val.isPlaying && val.loop;
				if (!((Object)(object)val.clip == (Object)(object)value))
				{
					if (_originalClips.TryGetValue(instanceID, out var value2))
					{
						WarnIfFormatMismatch(value2, value);
					}
					val.clip = value;
					if (flag)
					{
						val.Stop();
						val.Play();
					}
				}
			}
			_completedAwaitingApply.Clear();
		}

		private static string GetSoundPath(string soundName)
		{
			if (!_indexBuilt)
			{
				RebuildSoundIndex();
			}
			if (!_soundIndex.TryGetValue(soundName, out var value))
			{
				return null;
			}
			return value;
		}

		public static List<AudioClipEntry> GetClipInventory()
		{
			if (!_indexBuilt)
			{
				RebuildSoundIndex();
			}
			Dictionary<int, AudioClipEntry> dictionary = new Dictionary<int, AudioClipEntry>();
			AudioClip[] array = Resources.FindObjectsOfTypeAll<AudioClip>();
			foreach (AudioClip val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = ((Object)val).name.Replace("PATCHWORK_", "");
				if (!string.IsNullOrWhiteSpace(text))
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (!dictionary.ContainsKey(instanceID))
					{
						dictionary[instanceID] = new AudioClipEntry(text, val.length, val.channels, val.frequency, _soundIndex.ContainsKey(text));
					}
				}
			}
			AudioSource[] array2 = Resources.FindObjectsOfTypeAll<AudioSource>();
			foreach (AudioSource val2 in array2)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2.clip == (Object)null)
				{
					continue;
				}
				int instanceID2 = ((Object)val2.clip).GetInstanceID();
				if (dictionary.TryGetValue(instanceID2, out var value))
				{
					string gameObjectPath = GetGameObjectPath(val2);
					if (!value.SourcePaths.Contains(gameObjectPath))
					{
						value.SourcePaths.Add(gameObjectPath);
					}
				}
			}
			Dictionary<string, AudioClipEntry> dictionary2 = new Dictionary<string, AudioClipEntry>(StringComparer.OrdinalIgnoreCase);
			foreach (AudioClipEntry value3 in dictionary.Values)
			{
				if (dictionary2.TryGetValue(value3.ClipName, out var value2))
				{
					foreach (string sourcePath in value3.SourcePaths)
					{
						if (!value2.SourcePaths.Contains(sourcePath))
						{
							value2.SourcePaths.Add(sourcePath);
						}
					}
				}
				else
				{
					dictionary2[value3.ClipName] = value3;
				}
			}
			List<AudioClipEntry> list = new List<AudioClipEntry>(dictionary2.Values);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (AudioClipEntry item in list)
			{
				hashSet.Add(item.ClipName);
			}
			AudioCatalog.ObserveMany(hashSet);
			foreach (string name in AudioCatalog.Names)
			{
				if (!string.IsNullOrWhiteSpace(name) && !hashSet.Contains(name))
				{
					list.Add(new AudioClipEntry(name, _soundIndex.ContainsKey(name)));
				}
			}
			AudioCatalog.Flush();
			list.Sort((AudioClipEntry a, AudioClipEntry b) => string.Compare(a.ClipName, b.ClipName, StringComparison.OrdinalIgnoreCase));
			return list;
		}

		internal static string GetGameObjectPath(AudioSource src)
		{
			if ((Object)(object)src == (Object)null)
			{
				return "";
			}
			Transform transform = ((Component)src).transform;
			string text = ((Object)transform).name;
			if ((Object)(object)transform.parent != (Object)null)
			{
				text = ((Object)transform.parent).name + "/" + text;
			}
			return text;
		}

		public static AudioClip FindVanillaClipForDump(string clipName)
		{
			if (string.IsNullOrWhiteSpace(clipName))
			{
				return null;
			}
			foreach (AudioClip value in _originalClips.Values)
			{
				if ((Object)(object)value != (Object)null && !((Object)value).name.StartsWith("PATCHWORK_") && string.Equals(((Object)value).name, clipName, StringComparison.OrdinalIgnoreCase))
				{
					return value;
				}
			}
			HashSet<int> hashSet = new HashSet<int>();
			foreach (AudioClip value2 in LoadedClips.Values)
			{
				if ((Object)(object)value2 != (Object)null)
				{
					hashSet.Add(((Object)value2).GetInstanceID());
				}
			}
			AudioClip[] array = Resources.FindObjectsOfTypeAll<AudioClip>();
			foreach (AudioClip val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)val).name.StartsWith("PATCHWORK_") && !hashSet.Contains(((Object)val).GetInstanceID()) && string.Equals(((Object)val).name, clipName, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return null;
		}

		public static AudioClip GetReplacementClipForPreview(string clipName)
		{
			if (LoadedClips.TryGetValue(clipName, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if (_soundIndex.ContainsKey(clipName))
			{
				EnqueueLoad(clipName);
			}
			return null;
		}
	}
	public enum FlagKind
	{
		Bool,
		Int,
		String,
		Enum
	}
	public struct FlagChange
	{
		public string Name;

		public FlagKind Kind;

		public object Original;

		public object Current;

		public float LastChange;

		public bool NearDialogue;

		public bool Story;
	}
	public static class DialogueFlagTracker
	{
		public const float DialogueWindow = 6f;

		private static readonly Dictionary<string, FlagChange> _changes = new Dictionary<string, FlagChange>(256);

		private static readonly Dictionary<string, FieldInfo> _fieldCache = new Dictionary<string, FieldInfo>(256);

		private static float _lastDialogueActivity = -999f;

		private static readonly string[] NameStems = new string[16]
		{
			"convo", "met", "encounter", "quest", "talk", "dlg", "location", "greet", "spoke", "heard",
			"npc", "intro", "offered", "giv", "asked", "defeated"
		};

		private static readonly string[] NpcTokens = new string[15]
		{
			"sherma", "mapper", "garmond", "nuu", "pilby", "lace", "seth", "caravan", "flea", "druid",
			"gilly", "ballow", "grindle", "farmer", "architect"
		};

		private static readonly string[] TypeTokens = new string[3] { "location", "encounter", "npc" };

		public static IReadOnlyDictionary<string, FlagChange> Changes => _changes;

		public static int Count => _changes.Count;

		public static bool IsLikelyDialogueFlag(string name, Type fieldType)
		{
			if (!string.IsNullOrEmpty(name))
			{
				string[] nameStems = NameStems;
				foreach (string value in nameStems)
				{
					if (name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
				nameStems = NpcTokens;
				foreach (string value2 in nameStems)
				{
					if (name.IndexOf(value2, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			if (fieldType != null)
			{
				string name2 = fieldType.Name;
				string[] nameStems = TypeTokens;
				foreach (string value3 in nameStems)
				{
					if (name2.IndexOf(value3, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		public static void ApplyPatches(Harmony harmony)
		{
			DialogueHandler.OnTextAccessed += OnTextAccessed;
			Patch(harmony, "SetBool", new Type[2]
			{
				typeof(string),
				typeof(bool)
			}, "SetBoolPrefix", "SetBoolPostfix");
			Patch(harmony, "SetInt", new Type[2]
			{
				typeof(string),
				typeof(int)
			}, "SetIntPrefix", "SetIntPostfix");
			Patch(harmony, "SetString", new Type[2]
			{
				typeof(string),
				typeof(string)
			}, "SetStringPrefix", "SetStringPostfix");
			Patch(harmony, "IncrementInt", new Type[1] { typeof(string) }, "IntNamePrefix", "IntNamePostfix");
			Patch(harmony, "DecrementInt", new Type[1] { typeof(string) }, "IntNamePrefix", "IntNamePostfix");
			Patch(harmony, "OnUpdatedVariable", new Type[1] { typeof(string) }, null, "OnUpdatedVariablePostfix");
		}

		private static void Patch(Harmony h, string method, Type[] args, string pre, string post)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			MethodInfo methodInfo = AccessTools.Method(typeof(PlayerData), method, args, (Type[])null);
			if (methodInfo == null)
			{
				Log.Warn("[DialogueFlagTracker] PlayerData." + method + " not found; skipped.");
			}
			else
			{
				h.Patch((MethodBase)methodInfo, (pre == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(DialogueFlagTracker), pre, (Type[])null), (post == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(DialogueFlagTracker), post, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void OnTextAccessed(string sheet, string key, string text)
		{
			_lastDialogueActivity = Time.unscaledTime;
		}

		private static void SetBoolPrefix(PlayerData __instance, string boolName, out bool __state)
		{
			__state = __instance.GetBool(boolName);
		}

		private static void SetBoolPostfix(string boolName, bool value, bool __state)
		{
			if (__state != value)
			{
				Record(boolName, FlagKind.Bool, __state, value);
			}
		}

		private static void SetIntPrefix(PlayerData __instance, string intName, out int __state)
		{
			__state = __instance.GetInt(intName);
		}

		private static void SetIntPostfix(string intName, int value, int __state)
		{
			if (__state != value)
			{
				Record(intName, FlagKind.Int, __state, value);
			}
		}

		private static void SetStringPrefix(PlayerData __instance, string stringName, out string __state)
		{
			__state = __instance.GetString(stringName);
		}

		private static void SetStringPostfix(string stringName, string value, string __state)
		{
			if (!string.Equals(__state, value))
			{
				Record(stringName, FlagKind.String, __state, value);
			}
		}

		private static void IntNamePrefix(PlayerData __instance, string intName, out int __state)
		{
			__state = __instance.GetInt(intName);
		}

		private static void IntNamePostfix(PlayerData __instance, string intName, int __state)
		{
			int num = __instance.GetInt(intName);
			if (num != __state)
			{
				Record(intName, FlagKind.Int, __state, num);
			}
		}

		private static void OnUpdatedVariablePostfix(PlayerData __instance, string variableName)
		{
			FieldInfo fieldInfo = Field(variableName);
			if (!(fieldInfo == null))
			{
				FlagKind? flagKind = KindOf(fieldInfo.FieldType);
				if (flagKind.HasValue)
				{
					object value = fieldInfo.GetValue(__instance);
					Record(variableName, flagKind.Value, value, value);
				}
			}
		}

		private static FieldInfo Field(string name)
		{
			if (!_fieldCache.TryGetValue(name, out var value))
			{
				value = typeof(PlayerData).GetField(name, BindingFlags.Instance | BindingFlags.Public);
				_fieldCache[name] = value;
			}
			return value;
		}

		private static FlagKind? KindOf(Type t)
		{
			if (!(t == typeof(bool)))
			{
				if (!(t == typeof(int)))
				{
					if (!(t == typeof(string)))
					{
						if (!t.IsEnum)
						{
							return null;
						}
						return FlagKind.Enum;
					}
					return FlagKind.String;
				}
				return FlagKind.Int;
			}
			return FlagKind.Bool;
		}

		private static void Record(string name, FlagKind kind, object oldVal, object newVal)
		{
			Type fieldType = Field(name)?.FieldType;
			bool story = IsLikelyDialogueFlag(name, fieldType);
			bool flag = Time.unscaledTime - _lastDialogueActivity <= 6f;
			if (_changes.TryGetValue(name, out var value))
			{
				value.Current = newVal;
				value.LastChange = Time.unscaledTime;
				value.NearDialogue |= flag;
				value.Story = story;
				_changes[name] = value;
			}
			else
			{
				_changes[name] = new FlagChange
				{
					Name = name,
					Kind = kind,
					Original = oldVal,
					Current = newVal,
					LastChange = Time.unscaledTime,
					NearDialogue = flag,
					Story = story
				};
			}
		}

		public static bool TrySet(string name, FlagKind kind, object value)
		{
			PlayerData instance = PlayerData.instance;
			if (instance == null)
			{
				return false;
			}
			switch (kind)
			{
			case FlagKind.Bool:
				instance.SetBool(name, (bool)value);
				break;
			case FlagKind.Int:
				instance.SetInt(name, (int)value);
				break;
			case FlagKind.String:
				instance.SetString(name, (string)value);
				break;
			case FlagKind.Enum:
			{
				FieldInfo fieldInfo = Field(name);
				if (fieldInfo == null)
				{
					return false;
				}
				fieldInfo.SetValue(instance, value);
				break;
			}
			default:
				return false;
			}
			if (_changes.TryGetValue(name, out var value2))
			{
				value2.Current = value;
				value2.LastChange = Time.unscaledTime;
				_changes[name] = value2;
			}
			return true;
		}

		public static void RevertToOriginal(string name)
		{
			if (_changes.TryGetValue(name, out var value))
			{
				TrySet(value.Name, value.Kind, value.Original);
			}
		}

		public static void RevertAll()
		{
			foreach (FlagChange item in new List<FlagChange>(_changes.Values))
			{
				TrySet(item.Name, item.Kind, item.Original);
			}
		}

		public static void ClearLog()
		{
			_changes.Clear();
		}
	}
	public static class FontHandler
	{
		private const string AssetPrefix = "Stitchwork_Fallback_";

		private const int Padding = 5;

		private static readonly List<TMP_FontAsset> _ourAssets = new List<TMP_FontAsset>();

		private static readonly List<Object> _graveyard = new List<Object>();

		private static MethodInfo _tryAddGlyphToTexture;

		private static bool _bridgeInit;

		private static bool _warnedNoTemplate;

		private static HashSet<uint> _bakedCharset;

		private static List<string> _bakedFontFiles;

		private static bool _bakedBitmapMode;

		private static float _bakedScale = -1f;

		private static readonly HashSet<uint> _seenChars = new HashSet<uint>();

		private static bool _seenDirty;

		private static float _seenDirtyAt;

		private const float SeenDebounceSec = 1.5f;

		private const int SeenCharsCap = 20000;

		public static int LoadedFallbackFonts => _ourAssets.Count;

		public static void NoteRenderedText(string text)
		{
			if (string.IsNullOrEmpty(text) || !Plugin.Config.FontFallbackEnabled || _seenChars.Count >= 20000)
			{
				return;
			}
			bool flag = false;
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (c >= '\u0080')
				{
					uint item = c;
					if (char.IsHighSurrogate(c) && i + 1 < text.Length && char.IsLowSurrogate(text[i + 1]))
					{
						item = (uint)char.ConvertToUtf32(c, text[++i]);
					}
					if (_seenChars.Add(item))
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				_seenDirty = true;
				_seenDirtyAt = Time.realtimeSinceStartup;
			}
		}

		public static void Tick()
		{
			if (_seenDirty && Time.realtimeSinceStartup - _seenDirtyAt > 1.5f)
			{
				_seenDirty = false;
				FontFileWatcher.ReloadFonts = true;
			}
		}

		public static void Reload()
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			if (!InitBridge())
			{
				return;
			}
			foreach (Object item in _graveyard)
			{
				if (item != (Object)null)
				{
					Object.Destroy(item);
				}
			}
			_graveyard.Clear();
			if (!Plugin.Config.FontFallbackEnabled)
			{
				_bakedCharset = null;
				_bakedFontFiles = null;
				if (RemoveInjected() > 0)
				{
					RefreshAllText();
				}
				return;
			}
			List<string> list = DiscoverFontFiles();
			HashSet<uint> hashSet = ComputeCharset();
			bool fontFallbackBitmapMode = Plugin.Config.FontFallbackBitmapMode;
			bool flag = _ourAssets.Count > 0 && _bakedCharset != null && _bakedFontFiles != null && fontFallbackBitmapMode == _bakedBitmapMode && Mathf.Approximately(Plugin.Config.FontFallbackScale, _bakedScale) && list.SequenceEqual<string>(_bakedFontFiles, StringComparer.OrdinalIgnoreCase) && StillInjected();
			if (flag && _bakedCharset.IsSupersetOf(hashSet))
			{
				return;
			}
			if (flag && _ourAssets.Count < 32)
			{
				HashSet<uint> hashSet2 = new HashSet<uint>(hashSet);
				hashSet2.ExceptWith(_bakedCharset);
				Material val = (fontFallbackBitmapMode ? null : FindLiveSdfMaterialTemplate());
				if (!fontFallbackBitmapMode && (Object)(object)val == (Object)null)
				{
					return;
				}
				int count = _ourAssets.Count;
				foreach (string item2 in list)
				{
					TMP_FontAsset val2 = BakeFontAsset(item2, hashSet2, val, fontFallbackBitmapMode);
					if ((Object)(object)val2 != (Object)null)
					{
						_ourAssets.Add(val2);
					}
				}
				FontEngine.UnloadAllFontFaces();
				if (_ourAssets.Count == count)
				{
					_bakedCharset.UnionWith(hashSet2);
					Plugin.Logger.LogInfo((object)$"[Font] {hashSet2.Count} rendered codepoint(s) not coverable by the fallback font(s) — recorded, no future rebake for them.");
				}
				else if (InjectIntoGlobalFallbacks())
				{
					_bakedCharset.UnionWith(hashSet2);
					Plugin.Logger.LogInfo((object)($"[Font] Delta-baked {hashSet2.Count} new codepoint(s) into {_ourAssets.Count - count} supplementary asset(s) — " + $"chain now {_ourAssets.Count} asset(s), {_bakedCharset.Count} codepoint(s) attempted."));
					RefreshAllText();
				}
				return;
			}
			_bakedCharset = null;
			_bakedFontFiles = null;
			int num = RemoveInjected();
			if (list.Count == 0)
			{
				if (num > 0)
				{
					RefreshAllText();
				}
				return;
			}
			if (hashSet.Count == 0)
			{
				Plugin.Logger.LogInfo((object)"[Font] Fallback fonts present but no non-ASCII replacement text loaded — nothing to bake yet.");
				if (num > 0)
				{
					RefreshAllText();
				}
				return;
			}
			Material val3 = (fontFallbackBitmapMode ? null : FindLiveSdfMaterialTemplate());
			if (!fontFallbackBitmapMode && (Object)(object)val3 == (Object)null)
			{
				if (!_warnedNoTemplate)
				{
					_warnedNoTemplate = true;
					Plugin.Logger.LogWarning((object)"[Font] No live SDF font material found to clone yet — will retry on next reload.");
				}
				return;
			}
			foreach (string item3 in list)
			{
				TMP_FontAsset val4 = BakeFontAsset(item3, hashSet, val3, fontFallbackBitmapMode);
				if ((Object)(object)val4 != (Object)null)
				{
					_ourAssets.Add(val4);
				}
			}
			FontEngine.UnloadAllFontFaces();
			if (_ourAssets.Count > 0 && InjectIntoGlobalFallbacks())
			{
				_bakedCharset = hashSet;
				_bakedFontFiles = list;
				_bakedBitmapMode = fontFallbackBitmapMode;
				_bakedScale = Plugin.Config.FontFallbackScale;
				Plugin.Logger.LogInfo((object)$"[Font] Injected {_ourAssets.Count} fallback font(s) covering {hashSet.Count} codepoint(s) into TMP_Settings.fallbackFontAssets.");
				RefreshAllText();
			}
		}

		private static bool StillInjected()
		{
			List<TMP_FontAsset> list = (((Object)(object)TMP_Settings.instance != (Object)null) ? TMP_Settings.fallbackFontAssets : null);
			if (list == null)
			{
				return false;
			}
			foreach (TMP_FontAsset ourAsset in _ourAssets)
			{
				if ((Object)(object)ourAsset == (Object)null || !list.Contains(ourAsset))
				{
					return false;
				}
			}
			return true;
		}

		private static bool InitBridge()
		{
			if (_bridgeInit)
			{
				return _tryAddGlyphToTexture != null;
			}
			_bridgeInit = true;
			_tryAddGlyphToTexture = AccessTools.Method(typeof(FontEngine), "TryAddGlyphToTexture", new Type[8]
			{
				typeof(uint),
				typeof(int),
				typeof(GlyphPackingMode),
				typeof(List<GlyphRect>),
				typeof(List<GlyphRect>),
				typeof(GlyphRenderMode),
				typeof(Texture2D),
				typeof(Glyph).MakeByRefType()
			}, (Type[])null);
			if (_tryAddGlyphToTexture == null)
			{
				Plugin.Logger.LogWarning((object)"[Font] FontEngine.TryAddGlyphToTexture not resolvable — fallback font baking unavailable on this game build.");
			}
			return _tryAddGlyphToTexture != null;
		}

		private static List<string> DiscoverFontFiles()
		{
			List<string> result = new List<string>();
			foreach (string activePackPath in PackManager.ActivePackPaths)
			{
				AddFontsFrom(Path.Combine(activePackPath, "Fonts", "_fallback"), result);
			}
			AddFontsFrom(Path.Combine(Plugin.BasePath, "Fonts", "_fallback"), result);
			return result;
		}

		private static void AddFontsFrom(string dir, List<string> result)
		{
			if (!Directory.Exists(dir))
			{
				return;
			}
			foreach (string item in (from f in Directory.GetFiles(dir)
				where f.EndsWith(".ttf", StringComparison.OrdinalIgnoreCase) || f.EndsWith(".otf", StringComparison.OrdinalIgnoreCase)
				select f).OrderBy<string, string>((string f) => f, StringComparer.OrdinalIgnoreCase))
			{
				if (!result.Contains(item))
				{
					result.Add(item);
				}
			}
		}

		private static HashSet<uint> ComputeCharset()
		{
			HashSet<uint> hashSet = new HashSet<uint>();
			foreach (Dictionary<string, Dictionary<string, string>> value in DialogueHandler.TextCache.Values)
			{
				foreach (Dictionary<string, string> value2 in value.Values)
				{
					foreach (string value3 in value2.Values)
					{
						if (string.IsNullOrEmpty(value3))
						{
							continue;
						}
						for (int i = 0; i < value3.Length; i++)
						{
							char c = value3[i];
							if (char.IsHighSurrogate(c) && i + 1 < value3.Length && char.IsLowSurrogate(value3[i + 1]))
							{
								hashSet.Add((uint)char.ConvertToUtf32(c, value3[++i]));
							}
							else if (c >= '\u0080')
							{
								hashSet.Add(c);
							}
						}
					}
				}
			}
			if (_seenChars.Count > 0)
			{
				HashSet<int> hashSet2 = BuildLiveCoverage();
				foreach (uint seenChar in _seenChars)
				{
					if (!hashSet2.Contains((int)seenChar))
					{
						hashSet.Add(seenChar);
					}
				}
			}
			return hashSet;
		}

		private static HashSet<int> BuildLiveCoverage()
		{
			HashSet<int> hashSet = new HashSet<int>();
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)((TMP_Asset)val).material == (Object)null || ((Object)val).name.StartsWith("Stitchwork_Fallback_", StringComparison.Ordinal))
				{
					continue;
				}
				Dictionary<int, TMP_Glyph> characterDictionary = val.characterDictionary;
				if (characterDictionary == null)
				{
					continue;
				}
				foreach (int key in characterDictionary.Keys)
				{
					hashSet.Add(key);
				}
			}
			return hashSet;
		}

		private static TMP_FontAsset BakeFontAsset(string path, HashSet<uint> charset, Material sdfTemplate, bool bitmap)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Expected O, but got Unknown
			//IL_0484: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Expected O, but got Unknown
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Expected O, but got Unknown
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Expected O, but got Unknown
			int num = Mathf.Clamp(Plugin.Config.FontFallbackPointSize, 24, 128);
			if ((int)FontEngine.InitializeFontEngine() != 0)
			{
				Plugin.Logger.LogWarning((object)"[Font] FontEngine failed to initialize.");
				return null;
			}
			if ((int)FontEngine.LoadFontFace(path, num) != 0)
			{
				Plugin.Logger.LogWarning((object)("[Font] Could not load font face: " + Path.GetFileName(path)));
				return null;
			}
			int num2 = num + 10;
			int num3;
			for (num3 = 512; num3 < 8192; num3 *= 2)
			{
				int num4 = num3 / num2;
				if ((float)(num4 * num4) >= (float)charset.Count * 1.15f)
				{
					break;
				}
			}
			Texture2D val = new Texture2D(num3, num3, (TextureFormat)1, false)
			{
				name = "Stitchwork_Fallback_" + Path.GetFileNameWithoutExtension(path) + "_Atlas",
				hideFlags = (HideFlags)32,
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			val.LoadRawTextureData(new byte[num3 * num3]);
			val.Apply(false, false);
			GlyphRenderMode val2 = (GlyphRenderMode)(bitmap ? 4117 : 4165);
			List<GlyphRect> list = new List<GlyphRect>
			{
				new GlyphRect(1, 1, num3 - 2, num3 - 2)
			};
			List<GlyphRect> list2 = new List<GlyphRect>();
			List<TMP_Glyph> list3 = new List<TMP_Glyph>(charset.Count);
			int num5 = 0;
			int num6 = 0;
			uint num7 = default(uint);
			foreach (uint item in charset.OrderBy((uint u) => u))
			{
				if (!FontEngine.TryGetGlyphIndex(item, ref num7) || num7 == 0)
				{
					num5++;
					continue;
				}
				object[] array = new object[8]
				{
					num7,
					5,
					(object)(GlyphPackingMode)0,
					list,
					list2,
					val2,
					val,
					null
				};
				bool flag;
				try
				{
					flag = (bool)_tryAddGlyphToTexture.Invoke(null, array);
				}
				catch (TargetInvocationException ex)
				{
					Plugin.Logger.LogWarning((object)$"[Font] Glyph render failed for U+{item:X4}: {ex.InnerException?.Message}");
					num6++;
					continue;
				}
				if (!flag)
				{
					num6++;
					continue;
				}
				Glyph val3 = (Glyph)array[7];
				GlyphRect glyphRect = val3.glyphRect;
				GlyphMetrics metrics = val3.metrics;
				list3.Add(new TMP_Glyph
				{
					id = (int)item,
					x = ((GlyphRect)(ref glyphRect)).x,
					y = num3 - ((GlyphRect)(ref glyphRect)).y - ((GlyphRect)(ref glyphRect)).height,
					width = ((GlyphRect)(ref glyphRect)).width,
					height = ((GlyphRect)(ref glyphRect)).height,
					xOffset = ((GlyphMetrics)(ref metrics)).horizontalBearingX,
					yOffset = ((GlyphMetrics)(ref metrics)).horizontalBearingY,
					xAdvance = ((GlyphMetrics)(ref metrics)).horizontalAdvance,
					scale = 1f
				});
			}
			if (list3.Count == 0)
			{
				Plugin.Logger.LogWarning((object)$"[Font] '{Path.GetFileName(path)}' covered none of the {charset.Count} needed codepoint(s) — skipped.");
				_graveyard.Add((Object)(object)val);
				return null;
			}
			FaceInfo faceInfo = FontEngine.GetFaceInfo();
			float scale = Plugin.Config.FontFallbackScale;
			string text = Path.GetFileNameWithoutExtension(path);
			int num8 = text.LastIndexOf("@s", StringComparison.OrdinalIgnoreCase);
			if (num8 > 0 && float.TryParse(text.Substring(num8 + 2), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				scale = Mathf.Clamp(result, 0.5f, 1.5f);
				text = text.Substring(0, num8);
			}
			FaceInfo val4 = new FaceInfo
			{
				Name = text,
				PointSize = ((FaceInfo)(ref faceInfo)).pointSize,
				Scale = scale,
				LineHeight = ((FaceInfo)(ref faceInfo)).lineHeight,
				Baseline = ((FaceInfo)(ref faceInfo)).baseline,
				Ascender = ((FaceInfo)(ref faceInfo)).ascentLine,
				Descender = ((FaceInfo)(ref faceInfo)).descentLine,
				CapHeight = ((FaceInfo)(ref faceInfo)).capLine,
				Padding = 5f,
				AtlasWidth = num3,
				AtlasHeight = num3,
				Underline = ((FaceInfo)(ref faceInfo)).underlineOffset,
				UnderlineThickness = ((FaceInfo)(ref faceInfo)).underlineThickness,
				TabWidth = ((FaceInfo)(ref faceInfo)).tabWidth,
				SubSize = 0.5f,
				SuperscriptOffset = ((FaceInfo)(ref faceInfo)).ascentLine,
				SubscriptOffset = ((FaceInfo)(ref faceInfo)).underlineOffset
			};
			Material val6;
			if (bitmap)
			{
				Shader val5 = Shader.Find("TextMeshPro/Bitmap") ?? Shader.Find("TextMeshPro/Mobile/Bitmap");
				if ((Object)(object)val5 == (Object)null)
				{
					Plugin.Logger.LogWarning((object)"[Font] No TMP bitmap shader found — cannot build bitmap-mode fallback.");
					_graveyard.Add((Object)(object)val);
					return null;
				}
				val6 = new Material(val5);
			}
			else
			{
				val6 = new Material(sdfTemplate);
				val6.SetFloat("_GradientScale", 6f);
				val6.SetFloat("_TextureWidth", (float)num3);
				val6.SetFloat("_TextureHeight", (float)num3);
			}
			((Object)val6).name = "Stitchwork_Fallback_" + Path.GetFileNameWithoutExtension(path) + "_Mat";
			((Object)val6).hideFlags = (HideFlags)32;
			val6.SetTexture("_MainTex", (Texture)(object)val);
			TMP_FontAsset val7 = ScriptableObject.CreateInstance<TMP_FontAsset>();
			((Object)val7).name = "Stitchwork_Fallback_" + Path.GetFileNameWithoutExtension(path);
			((Object)val7).hideFlags = (HideFlags)32;
			val7.fontAssetType = (FontAssetTypes)((!bitmap) ? 1 : 2);
			val7.atlas = val;
			((TMP_Asset)val7).material = val6;
			val7.AddFaceInfo(val4);
			val7.AddGlyphInfo(list3.ToArray());
			val7.AddKerningInfo(new KerningTable());
			val7.ReadFontDefinition();
			string text2 = ((num5 > 0 || num6 > 0) ? $" ({num5} not in font, {num6} pack/render failures)" : "");
			Plugin.Logger.LogInfo((object)string.Format("[Font] Baked '{0}': {1} glyph(s) into {2}x{3} {4} atlas{5}.", Path.GetFileName(path), list3.Count, num3, num3, bitmap ? "bitmap" : "SDF", text2));
			return val7;
		}

		private static Material FindLiveSdfMaterialTemplate()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((TMP_Asset)val).material == (Object)null) && !((Object)val).name.StartsWith("Stitchwork_Fallback_", StringComparison.Ordinal) && (int)val.fontAssetType == 1)
				{
					return ((TMP_Asset)val).material;
				}
			}
			return null;
		}

		private static bool InjectIntoGlobalFallbacks()
		{
			TMP_Settings instance = TMP_Settings.instance;
			if ((Object)(object)instance == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"[Font] TMP_Settings.instance is null — cannot inject (will retry on next reload).");
				return false;
			}
			List<TMP_FontAsset> list = TMP_Settings.fallbackFontAssets;
			if (list == null)
			{
				list = new List<TMP_FontAsset>();
				AccessTools.Field(typeof(TMP_Settings), "m_fallbackFontAssets")?.SetValue(instance, list);
				if (TMP_Settings.fallbackFontAssets == null)
				{
					Plugin.Logger.LogWarning((object)"[Font] Could not initialize TMP_Settings.m_fallbackFontAssets.");
					return false;
				}
			}
			list.RemoveAll((TMP_FontAsset f) => (Object)(object)f != (Object)null && ((Object)f).name.StartsWith("Stitchwork_Fallback_", StringComparison.Ordinal));
			list.AddRange(_ourAssets);
			return true;
		}

		private static int RemoveInjected()
		{
			int result = 0;
			List<TMP_FontAsset> list = (((Object)(object)TMP_Settings.instance != (Object)null) ? TMP_Settings.fallbackFontAssets : null);
			if (list != null)
			{
				result = list.RemoveAll((TMP_FontAsset f) => (Object)(object)f != (Object)null && ((Object)f).name.StartsWith("Stitchwork_Fallback_", StringComparison.Ordinal));
			}
			foreach (TMP_FontAsset ourAsset in _ourAssets)
			{
				if (!((Object)(object)ourAsset == (Object)null))
				{
					if ((Object)(object)ourAsset.atlas != (Object)null)
					{
						_graveyard.Add((Object)(object)ourAsset.atlas);
					}
					if ((Object)(object)((TMP_Asset)ourAsset).material != (Object)null)
					{
						_graveyard.Add((Object)(object)((TMP_Asset)ourAsset).material);
					}
					_graveyard.Add((Object)(object)ourAsset);
				}
			}
			_ourAssets.Clear();
			return result;
		}

		private static void RefreshAllText()
		{
			TMP_Text[] array = Resources.FindObjectsOfTypeAll<TMP_Text>();
			foreach (TMP_Text val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					val.ForceMeshUpdate();
				}
			}
		}
	}
	public static class GlobalAmbientProbe
	{
		private static bool _isOverridden;

		private static Color _savedAmbientLight;

		private static Color _savedAmbientSky;

		private static Color _savedAmbientEquator;

		private static Color _savedAmbientGround;

		private static float _savedAmbientIntensity;

		private static Vector4 _savedSHAr;

		private static Vector4 _savedSHAg;

		private static Vector4 _savedSHAb;

		private static Vector4 _savedSHBr;

		private static Vector4 _savedSHBg;

		private static Vector4 _savedSHBb;

		private static Vector4 _savedSHC;

		public static string LastStatus = "";

		public static bool IsOverridden => _isOverridden;

		public static void ZeroAll()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (!_isOverridden)
			{
				_savedAmbientLight = RenderSettings.ambientLight;
				_savedAmbientSky = RenderSettings.ambientSkyColor;
				_savedAmbientEquator = RenderSettings.ambientEquatorColor;
				_savedAmbientGround = RenderSettings.ambientGroundColor;
				_savedAmbientIntensity = RenderSettings.ambientIntensity;
				_savedSHAr = Shader.GetGlobalVector("unity_SHAr");
				_savedSHAg = Shader.GetGlobalVector("unity_SHAg");
				_savedSHAb = Shader.GetGlobalVector("unity_SHAb");
				_savedSHBr = Shader.GetGlobalVector("unity_SHBr");
				_savedSHBg = Shader.GetGlobalVector("unity_SHBg");
				_savedSHBb = Shader.GetGlobalVector("unity_SHBb");
				_savedSHC = Shader.GetGlobalVector("unity_SHC");
				_isOverridden = true;
			}
			RenderSettings.ambientLight = Color.white;
			RenderSettings.ambientSkyColor = Color.white;
			RenderSettings.ambientEquatorColor = Color.white;
			RenderSettings.ambientGroundColor = Color.white;
			Shader.SetGlobalColor("unity_AmbientSky", Color.white);
			Shader.SetGlobalColor("unity_AmbientEquator", Color.white);
			Shader.SetGlobalColor("unity_AmbientGround", Color.white);
			Shader.SetGlobalVector("unity_SHAr", Vector4.zero);
			Shader.SetGlobalVector("unity_SHAg", Vector4.zero);
			Shader.SetGlobalVector("unity_SHAb", Vector4.zero);
			Shader.SetGlobalVector("unity_SHBr", Vector4.zero);
			Shader.SetGlobalVector("unity_SHBg", Vector4.zero);
			Shader.SetGlobalVector("unity_SHBb", Vector4.zero);
			Shader.SetGlobalVector("unity_SHC", Vector4.zero);
			LastStatus = "Ambient + SH zeroed. Saved: sky=" + ColorStr(_savedAmbientSky) + " eq=" + ColorStr(_savedAmbientEquator) + " gr=" + ColorStr(_savedAmbientGround) + ", plus 7 SH coefficients.";
			Plugin.Logger.LogInfo((object)("[GlobalAmbientProbe] " + LastStatus));
		}

		public static void Restore()
		{
			//IL_0012: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (!_isOverridden)
			{
				LastStatus = "Nothing to restore.";
				return;
			}
			RenderSettings.ambientLight = _savedAmbientLight;
			RenderSettings.ambientSkyColor = _savedAmbientSky;
			RenderSettings.ambientEquatorColor = _savedAmbientEquator;
			RenderSettings.ambientGroundColor = _savedAmbientGround;
			RenderSettings.ambientIntensity = _savedAmbientIntensity;
			Shader.SetGlobalColor("unity_AmbientSky", _savedAmbientSky);
			Shader.SetGlobalColor("unity_AmbientEquator", _savedAmbientEquator);
			Shader.SetGlobalColor("unity_AmbientGround", _savedAmbientGround);
			Shader.SetGlobalVector("unity_SHAr", _savedSHAr);
			Shader.SetGlobalVector("unity_SHAg", _savedSHAg);
			Shader.SetGlobalVector("unity_SHAb", _savedSHAb);
			Shader.SetGlobalVector("unity_SHBr", _savedSHBr);
			Shader.SetGlobalVector("unity_SHBg", _savedSHBg);
			Shader.SetGlobalVector("unity_SHBb", _savedSHBb);
			Shader.SetGlobalVector("unity_SHC", _savedSHC);
			_isOverridden = false;
			LastStatus = "Ambient + SH restored.";
			Plugin.Logger.LogInfo((object)("[GlobalAmbientProbe] " + LastStatus));
		}

		private static string ColorStr(Color c)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({c.r:0.00},{c.g:0.00},{c.b:0.00})";
		}
	}
	public static class MaterialDumper
	{
		private enum MpbPropType
		{
			Color,
			Float,
			Vector
		}

		private static readonly (string Name, MpbPropType Type)[] KnownTintProps = new(string, MpbPropType)[15]
		{
			("_Color", MpbPropType.Color),
			("_CharacterTintColor", MpbPropType.Color),
			("_FlashColor", MpbPropType.Color),
			("_FlashAmount", MpbPropType.Float),
			("_IsCharacter", MpbPropType.Float),
			("_IsHero", MpbPropType.Float),
			("_CanDesaturate", MpbPropType.Float),
			("_Desaturation", MpbPropType.Float),
			("_CanLerpAmbient", MpbPropType.Float),
			("_AmbientLerp", MpbPropType.Float),
			("_BlackThreadAmount", MpbPropType.Float),
			("_IsBlackThreaded", MpbPropType.Float),
			("_CanHueShift", MpbPropType.Float),
			("_HueShift", MpbPropType.Float),
			("_IsMaskingSprite", MpbPropType.Float)
		};

		public static string LastStatus = "";

		private static readonly string[] CandidateGlobalNames = new string[30]
		{
			"unity_AmbientSky", "unity_AmbientEquator", "unity_AmbientGround", "unity_FogColor", "unity_LightColor0", "unity_SHAr", "unity_SHAg", "unity_SHAb", "unity_SHBr", "unity_SHBg",
			"unity_SHBb", "unity_SHC", "_SceneTint", "_SceneColor", "_AmbientColor", "_GlobalColor", "_GlobalTint", "_LightColor", "_LightTint", "_FogColor",
			"_TimeOfDayColor", "_DayNightTint", "_SaturationGlobal", "_BrightnessGlobal", "_ContrastGlobal", "_TintColor", "_Tint", "_Brightness", "_Saturation", "_Contrast"
		};

		public static string DefaultOutputPath
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Scene activeScene = SceneManager.GetActiveScene();
				string obj = ((Scene)(ref activeScene)).name ?? "unknown";
				StringBuilder stringBuilder = new StringBuilder(obj.Length);
				string text = obj;
				foreach (char c in text)
				{
					if (char.IsLetterOrDigit(c) || c == '_' || c == '-')
					{
						stringBuilder.Append(c);
					}
					else
					{
						stringBuilder.Append('_');
					}
				}
				return Path.Combine(Plugin.BasePath, $"material-tint-dump__{stringBuilder}.txt");
			}
		}

		public static string DumpAll(string outputPath = null)
		{
			if (outputPath == null)
			{
				outputPath = DefaultOutputPath;
			}
			StringBuilder stringBuilder = new StringBuilder(16384);
			try
			{
				WriteHeader(stringBuilder);
			}
			catch (Exception arg)
			{
				stringBuilder.AppendLine($"[error] header: {arg}");
			}
			try
			{
				WriteSceneGlobals(stringBuilder);
			}
			catch (Exception arg2)
			{
				stringBuilder.AppendLine($"[error] scene globals: {arg2}");
			}
			try
			{
				WriteCollections(stringBuilder);
			}
			catch (Exception arg3)
			{
				stringBuilder.AppendLine($"[error] collections: {arg3}");
			}
			try
			{
				WriteRenderers(stringBuilder);
			}
			catch (Exception arg4)
			{
				stringBuilder.AppendLine($"[error] renderers: {arg4}");
			}
			try
			{
				IOUtil.EnsureDirectoryExists(Path.GetDirectoryName(outputPath));
				File.WriteAllText(IOUtil.LongSafe(outputPath), stringBuilder.ToString());
				LastStatus = $"Wrote {stringBuilder.Length:N0} chars to {Path.GetFileName(outputPath)}";
				Plugin.Logger.LogInfo((object)("[MaterialDumper] " + LastStatus + " (" + outputPath + ")"));
				return outputPath;
			}
			catch (Exception ex)
			{
				LastStatus = "FAILED to write report: " + ex.Message;
				Plugin.Logger.LogError((object)("[MaterialDumper] " + LastStatus));
				return null;
			}
		}

		private static void WriteHeader(StringBuilder sb)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			sb.AppendLine("# Stitchwork — Material Tint Diagnostic Dump");
			sb.AppendLine($"# Generated: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
			sb.AppendLine($"# Active scene: {((Scene)(ref activeScene)).name} (build index {((Scene)(ref activeScene)).buildIndex})");
			sb.AppendLine("# Stitchwork version: 0.8.6");
			sb.AppendLine();
			sb.AppendLine("Scope:");
			sb.AppendLine("  1. Scene-level state (RenderSettings, Camera, Lights, shader globals)");
			sb.AppendLine("  2. Every live tk2dSpriteCollectionData's per-material shader properties");
			sb.AppendLine("  3. A sample of tk2d sprite + standard renderer per-instance state");
			sb.AppendLine();
			sb.AppendLine("Cross-reference: docs/material-tint-investigation.md.");
			sb.AppendLine();
			sb.AppendLine();
		}

		private static void WriteSceneGlobals(StringBuilder sb)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_058a: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine("================================================================");
			sb.AppendLine("  SCENE GLOBALS");
			sb.AppendLine("================================================================");
			sb.AppendLine();
			sb.AppendLine("[RenderSettings]");
			sb.AppendLine($"  ambientMode         = {RenderSettings.ambientMode}");
			sb.AppendLine("  ambientLight        = " + C(RenderSettings.ambientLight));
			sb.AppendLine("  ambientSkyColor     = " + C(RenderSettings.ambientSkyColor));
			sb.AppendLine("  ambientEquatorColor = " + C(RenderSettings.ambientEquatorColor));
			sb.AppendLine("  ambientGroundColor  = " + C(RenderSettings.ambientGroundColor));
			sb.AppendLine($"  ambientIntensity    = {RenderSettings.ambientIntensity:0.000}");
			sb.AppendLine($"  fog                 = {RenderSettings.fog}");
			sb.AppendLine($"  fogMode             = {RenderSettings.fogMode}");
			sb.AppendLine("  fogColor            = " + C(RenderSettings.fogColor));
			sb.AppendLine($"  fogDensity          = {RenderSettings.fogDensity:0.000}");
			sb.AppendLine($"  fogStartDistance    = {RenderSettings.fogStartDistance:0.000}");
			sb.AppendLine($"  fogEndDistance      = {RenderSettings.fogEndDistance:0.000}");
			sb.AppendLine();
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null)
			{
				sb.AppendLine("[Camera.main: '" + ((Object)main).name + "']");
				sb.AppendLine("  backgroundColor     = " + C(main.backgroundColor));
				sb.AppendLine($"  clearFlags          = {main.clearFlags}");
				sb.AppendLine($"  allowHDR            = {main.allowHDR}");
				sb.AppendLine($"  allowMSAA           = {main.allowMSAA}");
				sb.AppendLine($"  cullingMask         = 0x{main.cullingMask:X8}");
				sb.AppendLine($"  orthographic        = {main.orthographic}");
				sb.AppendLine($"  orthographicSize    = {main.orthographicSize:0.000}");
			}
			else
			{
				sb.AppendLine("[Camera.main] (none)");
			}
			sb.AppendLine();
			Camera[] array = Object.FindObjectsByType<Camera>((FindObjectsSortMode)0);
			sb.AppendLine($"[All Cameras] ({array.Length} total)");
			Camera[] array2 = array;
			foreach (Camera val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					sb.AppendLine("  '" + TPath(((Component)val).transform) + "' " + $"depth={val.depth:0.0} clear={val.clearFlags} bg={C(val.backgroundColor)}");
				}
			}
			sb.AppendLine();
			Light[] array3 = Object.FindObjectsByType<Light>((FindObjectsSortMode)0);
			sb.AppendLine($"[Lights] ({array3.Length} total)");
			Light[] array4 = array3;
			foreach (Light val2 in array4)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					sb.AppendLine($"  '{TPath(((Component)val2).transform)}'  enabled={((Behaviour)val2).enabled} " + $"type={val2.type} color={C(val2.color)} " + $"intensity={val2.intensity:0.00} bounceIntensity={val2.bounceIntensity:0.00}");
				}
			}
			sb.AppendLine();
			sb.AppendLine("[Post-process / Volume scan — reflection probe]");
			string[] array5;
			try
			{
				string[] obj = new string[3] { "UnityEngine.Rendering.PostProcessing.PostProcessVolume", "UnityEngine.Rendering.Volume", "UnityEngine.Rendering.PostProcessing.PostProcessLayer" };
				int num = 0;
				array5 = obj;
				foreach (string text in array5)
				{
					Type type = AccessTools.TypeByName(text);
					if (type == null)
					{
						continue;
					}
					Object[] array6 = Object.FindObjectsByType(type, (FindObjectsSortMode)0);
					if (array6.Length == 0)
					{
						continue;
					}
					sb.AppendLine($"  type {text}: {array6.Length} instance(s)");
					Object[] array7 = array6;
					foreach (Object obj2 in array7)
					{
						Component val3 = (Component)(object)((obj2 is Component) ? obj2 : null);
						if (val3 == null)
						{
							continue;
						}
						string text2 = "?";
						try
						{
							PropertyInfo property = type.GetProperty("enabled", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							if (property != null)
							{
								text2 = ((bool)property.GetValue(val3)).ToString();
							}
						}
						catch (TargetInvocationException)
						{
						}
						catch (InvalidCastException)
						{
						}
						sb.AppendLine("    '" + TPath(val3.transform) + "'  enabled=" + text2);
					}
					num += array6.Length;
				}
				if (num == 0)
				{
					sb.AppendLine("  (no PostProcessVolume / Volume / PostProcessLayer found)");
				}
			}
			catch (Exception ex3)
			{
				sb.AppendLine("  [error: " + ex3.Message + "]");
			}
			sb.AppendLine();
			sb.AppendLine("[Shader Globals — speculative probe]");
			sb.AppendLine("  (probed by candidate names; non-default values are signal)");
			bool flag = false;
			array5 = CandidateGlobalNames;
			foreach (string text3 in array5)
			{
				Color globalColor = Shader.GetGlobalColor(text3);
				if (globalColor.r != 0f || globalColor.g != 0f || globalColor.b != 0f || globalColor.a != 0f)
				{
					sb.AppendLine("  GlobalColor '" + text3 + "' = " + C(globalColor));
					flag = true;
				}
				float globalFloat = Shader.GetGlobalFloat(text3);
				if (Math.Abs(globalFloat) > 0.0001f)
				{
					sb.AppendLine($"  GlobalFloat '{text3}' = {globalFloat:0.000}");
					flag = true;
				}
				Vector4 globalVector = Shader.GetGlobalVector(text3);
				if (((Vector4)(ref globalVector)).sqrMagnitude > 0.0001f)
				{
					sb.AppendLine("  GlobalVector '" + text3 + "' = " + ((Vector4)(ref globalVector)).ToString("F3"));
					flag = true;
				}
			}
			if (!flag)
			{
				sb.AppendLine("  (none of the probed names had non-default values)");
			}
			sb.AppendLine();
			sb.AppendLine();
		}

		private static void WriteCollections(StringBuilder sb)
		{
			sb.AppendLine("================================================================");
			sb.AppendLine("  tk2dSpriteCollectionData materials");
			sb.AppendLine("================================================================");
			sb.AppendLine();
			tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			sb.AppendLine($"({array.Length} collections)");
			sb.AppendLine();
			tk2dSpriteCollectionData[] array2 = array;
			foreach (tk2dSpriteCollectionData val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					sb.AppendLine("--- " + ((Object)val).name + " ---");
					if (val.materials == null || val.materials.Length == 0)
					{
						sb.AppendLine("  (no materials)");
						sb.AppendLine();
						continue;
					}
					for (int j = 0; j < val.materials.Length; j++)
					{
						Material val2 = val.materials[j];
						if ((Object)(object)val2 == (Object)null)
						{
							sb.AppendLine($"  [Material {j}] (null)");
							continue;
						}
						string name = ((Object)val2).name;
						string arg = ((name != null) ? name.Split(' ')[0] : null) ?? "<unnamed>";
						string arg2 = (((Object)(object)val2.shader != (Object)null) ? ((Object)val2.shader).name : "<null shader>");
						sb.AppendLine($"  [Material {j}: {arg}]  shader: {arg2}");
						string[] array3 = null;
						try
						{
							array3 = val2.shaderKeywords;
						}
						catch
						{
						}
						if (array3 != null && array3.Length != 0)
						{
							sb.AppendLine("    keywords: " + string.Join(", ", array3));
						}
						DumpShaderProperties(sb, val2, "    ");
						sb.AppendLine();
					}
				}
				catch (Exception ex)
				{
					sb.AppendLine("  [error: " + ex.Message + "]");
				}
				sb.AppendLine();
			}
		}

		private static void DumpShaderProperties(StringBuilder sb, Material mat, string indent)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected I4, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			Shader shader = mat.shader;
			if ((Object)(object)shader == (Object)null)
			{
				sb.AppendLine(indent + "(null shader; no properties)");
				return;
			}
			int num = 0;
			try
			{
				num = shader.GetPropertyCount();
			}
			catch (Exception ex)
			{
				sb.AppendLine(indent + "(GetPropertyCount failed: " + ex.Message + ")");
				return;
			}
			if (num == 0)
			{
				sb.AppendLine(indent + "(shader exposes 0 properties)");
				return;
			}
			for (int i = 0; i < num; i++)
			{
				try
				{
					string propertyName = shader.GetPropertyName(i);
					ShaderPropertyType propertyType = shader.GetPropertyType(i);
					string text;
					switch ((int)propertyType)
					{
					case 0:
						text = C(mat.GetColor(propertyName));
						break;
					case 1:
					{
						Vector4 vector = mat.GetVector(propertyName);
						text = ((Vector4)(ref vector)).ToString("F3");
						break;
					}
					case 2:
					case 3:
						text = mat.GetFloat(propertyName).ToString("0.000");
						break;
					case 4:
					{
						Texture texture = mat.GetTexture(propertyName);
						if ((Object)(object)texture == (Object)null)
						{
							text = "(null)";
							break;
						}
						Texture2D val = (Texture2D)(object)((texture is Texture2D) ? texture : null);
						if (val != null)
						{
							text = $"{((object)val).GetType().Name} '{((Object)val).name}' {((Texture)val).width}x{((Texture)val).height} fmt={val.format}";
						}
						else
						{
							RenderTexture val2 = (RenderTexture)(object)((texture is RenderTexture) ? texture : null);
							text = ((val2 == null) ? (((object)texture).GetType().Name + " '" + ((Object)texture).name + "'") : $"RenderTexture '{((Object)val2).name}' {((Texture)val2).width}x{((Texture)val2).height} fmt={val2.format}");
						}
						break;
					}
					case 5:
						text = mat.GetInt(propertyName).ToString();
						break;
					default:
						text = "(unknown property type)";
						break;
					}
					sb.AppendLine($"{indent}{propertyName,-22} ({propertyType,-8}) = {text}");
				}
				catch (Exception ex2)
				{
					sb.AppendLine($"{indent}  [error on property {i}: {ex2.Message}]");
				}
			}
		}

		private static void WriteRenderers(StringBuilder sb)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			sb.AppendLine("================================================================");
			sb.AppendLine("  RENDERERS — sample of per-instance state");
			sb.AppendLine("================================================================");
			sb.AppendLine();
			sb.AppendLine("Per-renderer .color and MaterialPropertyBlock samples. Capped at");
			sb.AppendLine("first 100 entries each to keep the report scannable.");
			sb.AppendLine();
			try
			{
				tk2dBaseSprite[] array = Resources.FindObjectsOfTypeAll<tk2dBaseSprite>();
				sb.AppendLine($"[tk2dBaseSprite] ({array.Length} total)");
				int num = 0;
				int num2 = 0;
				tk2dBaseSprite[] array2 = array;
				foreach (tk2dBaseSprite val in array2)
				{
					if (!((Object)(object)val == (Object)null))
					{
						if (num >= 100)
						{
							break;
						}
						Color val2 = Color.white;
						try
						{
							val2 = val.color;
						}
						catch
						{
						}
						bool flag = val2.r == 1f && val2.g == 1f && val2.b == 1f && val2.a == 1f;
						if (!flag)
						{
							num2++;
						}
						sb.AppendLine("  " + (flag ? " " : "*") + " '" + TPath(((Component)val).transform) + "' color=" + C(val2));
						num++;
					}
				}
				if (array.Length > 100)
				{
					sb.AppendLine($"  ... +{array.Length - 100} more (sample shown above)");
				}
				sb.AppendLine($"  ({num2} of first {num} have non-white .color — flagged with '*')");
				sb.AppendLine();
			}
			catch (Exception ex)
			{
				sb.AppendLine("[tk2dBaseSprite] error: " + ex.Message);
				sb.AppendLine();
			}
			try
			{
				SpriteRenderer[] array3 = Resources.FindObjectsOfTypeAll<SpriteRenderer>();
				sb.AppendLine($"[SpriteRenderer] ({array3.Length} total)");
				int num3 = 0;
				int num4 = 0;
				SpriteRenderer[] array4 = array3;
				foreach (SpriteRenderer val3 in array4)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						if (num3 >= 100)
						{
							break;
						}
						bool flag2 = val3.color.r == 1f && val3.color.g == 1f && val3.color.b == 1f && val3.color.a == 1f;
						if (!flag2)
						{
							num4++;
						}
						sb.AppendLine("  " + (flag2 ? " " : "*") + " '" + TPath(((Component)val3).transform) + "' color=" + C(val3.color));
						num3++;
					}
				}
				if (array3.Length > 100)
				{
					sb.AppendLine($"  ... +{array3.Length - 100} more (sample shown above)");
				}
				sb.AppendLine($"  ({num4} of first {num3} have non-white .color — flagged with '*')");
				sb.AppendLine();
			}
			catch (Exception ex2)
			{
				sb.AppendLine("[SpriteRenderer] error: " + ex2.Message);
				sb.AppendLine();
			}
			try
			{
				Renderer[] array5 = Resources.FindObjectsOfTypeAll<Renderer>();
				sb.AppendLine("[MaterialPropertyBlock contents — probed by known names]");
				sb.AppendLine("  Known names: " + string.Join(", ", KnownTintProps.Select(((string Name, MpbPropType Type) p) => p.Name)));
				sb.AppendLine("  Showing renderers with at least one non-default known tint property.");
				sb.AppendLine("  Capped at first 100 to keep the report scannable.");
				sb.AppendLine();
				MaterialPropertyBlock val4 = new MaterialPropertyBlock();
				int num5 = 0;
				int num6 = 0;
				int num7 = 0;
				Renderer[] array6 = array5;
				foreach (Renderer val5 in array6)
				{
					if ((Object)(object)val5 == (Object)null)
					{
						continue;
					}
					val5.GetPropertyBlock(val4);
					if (val4.isEmpty)
					{
						continue;
					}
					num5++;
					List<string> list = new List<string>();
					(string, MpbPropType)[] knownTintProps = KnownTintProps;
					for (int num8 = 0; num8 < knownTintProps.Length; num8++)
					{
						(string, MpbPropType) tuple = knownTintProps[num8];
						string text = ProbeMpbProperty(val4, tuple.Item1, tuple.Item2);
						if (text != null)
						{
							list.Add(text);
						}
					}
					if (list.Count == 0)
					{
						continue;
					}
					num6++;
					if (num7 >= 100)
					{
						continue;
					}
					sb.AppendLine("  '" + TPath(((Component)val5).transform) + "' (" + ((object)val5).GetType().Name + ")");
					foreach (string item in list)
					{
						sb.AppendLine("      " + item);
					}
					num7++;
				}
				if (num5 == 0)
				{
					sb.AppendLine("  (no renderers carry an MPB override)");
				}
				else
				{
					if (num6 > 100)
					{
						sb.AppendLine($"  ... +{num6 - 100} more renderers with " + "non-default known tint props");
					}
					sb.AppendLine($"  total renderers scanned: {array5.Length}");
					sb.AppendLine($"  renderers with non-empty MPB: {num5}");
					sb.AppendLine($"  renderers with non-default known tint props: {num6}");
					sb.AppendLine("  ratio (interesting/all-MPB): " + $"{((num5 == 0) ? 0.0 : ((double)num6 * 100.0 / (double)num5)):0.0}%");
				}
				sb.AppendLine();
			}
			catch (Exception ex3)
			{
				sb.AppendLine("[MaterialPropertyBlock] error: " + ex3.Message);
				sb.AppendLine();
			}
		}

		private static string ProbeMpbProperty(MaterialPropertyBlock mpb, string name, MpbPropType type)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			switch (type)
			{
			case MpbPropType.Color:
			{
				Color color = mpb.GetColor(name);
				bool num2 = color.r == 1f && color.g == 1f && color.b == 1f && color.a == 1f;
				bool flag = color.r == 0f && color.g == 0f && color.b == 0f && color.a == 0f;
				if (num2 || flag)
				{
					return null;
				}
				return $"{name,-22} (Color  ) = {C(color)}";
			}
			case MpbPropType.Float:
			{
				float num = mpb.GetFloat(name);
				if (Math.Abs(num) < 0.0001f)
				{
					return null;
				}
				return $"{name,-22} (Float  ) = {num:0.000}";
			}
			case MpbPropType.Vector:
			{
				Vector4 vector = mpb.GetVector(name);
				if (((Vector4)(ref vector)).sqrMagnitude < 0.0001f)
				{
					return null;
				}
				return string.Format("{0,-22} (Vector ) = {1}", name, ((Vector4)(ref vector)).ToString("F3"));
			}
			default:
				return null;
			}
		}

		private static string C(Color c)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			return $"({c.r:0.000}, {c.g:0.000}, {c.b:0.000}, {c.a:0.000})";
		}

		private static string TPath(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return "<null>";
			}
			StringBuilder stringBuilder = new StringBuilder(64);
			stringBuilder.Append(((Object)t).name);
			Transform parent = t.parent;
			while ((Object)(object)parent != (Object)null)
			{
				stringBuilder.Insert(0, '/');
				stringBuilder.Insert(0, ((Object)parent).name);
				parent = parent.parent;
			}
			return stringBuilder.ToString();
		}
	}
	public static class RecolourHandler
	{
		private sealed class Rule
		{
			public Color Old;

			public Color New;

			public float Tol = 0.05f;

			public string Source;
		}

		private sealed class SceneRules
		{
			public readonly List<Rule> Renderer = new List<Rule>();

			public readonly List<Rule> Particle = new List<Rule>();

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

			public Color? Ambient;
		}

		private sealed class TrackedTint
		{
			public Color From;

			public Color Written;

			public Rule Rule;

			public Sprite SpriteRef;

			public int TkSpriteId;
		}

		public const float DefaultTolerance = 0.05f;

		public static bool ReloadRequested;

		private static SceneRules _rules;

		private static string _rulesScene;

		private static readonly Dictionary<int, (SpriteRenderer sr, Color vanilla)> _applied = new Dictionary<int, (SpriteRenderer, Color)>();

		private static readonly Dictionary<int, (ParticleSystem ps, Color vanilla)> _appliedPs = new Dictionary<int, (ParticleSystem, Color)>();

		private static Rule _preview;

		private static Color? _previewAmbient;

		private static bool _ambientApplied;

		private static Color _ambVanLight;

		private static Color _ambVanSky;

		private static Color _ambVanEquator;

		private static Color _ambVanGround;

		private static List<Rule> _globalRules;

		private static Rule _globalPreview;

		private static readonly List<Rule> _effGlobal = new List<Rule>();

		private static bool _effGlobalDirty = true;

		private static readonly Dictionary<int, (SpriteRenderer sr, TrackedTint t)> _trackedSr = new Dictionary<int, (SpriteRenderer, TrackedTint)>();

		private static readonly Dictionary<int, (tk2dBaseSprite tk, TrackedTint t)> _trackedTk = new Dictionary<int, (tk2dBaseSprite, TrackedTint)>();

		private static float _nextGlobalSweep;

		public static int AppliedCount => _applied.Count + _appliedPs.Count;

		public static Color CurrentAmbientVanilla
		{
			get
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				if (!_ambientApplied)
				{
					return RenderSettings.ambientLight;
				}
				return _ambVanLight;
			}
		}

		public static string GlobalFile => Path.Combine(Plugin.BasePath, "Recolour", "_global.txt");

		public static int GlobalTrackedCount => _trackedSr.Count + _trackedTk.Count;

		public static string RootFileFor(string scene)
		{
			return Path.Combine(Plugin.BasePath, "Recolour", scene + ".txt");
		}

		public static void OnSceneUnloaded()
		{
			RestoreAll();
			_rules = null;
			_rulesScene = null;
			_preview = null;
		}

		internal static bool SceneOwned(GameObject go)
		{
			//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)
			Scene scene = go.scene;
			return !string.Equals(((Scene)(ref scene)).name, "DontDestroyOnLoad", StringComparison.Ordinal);
		}

		public static void Reload()
		{
			RestoreAll();
			_rules = null;
			_rulesScene = null;
			ApplyToScene();
			ReloadGlobal();
		}

		public static void ApplyToScene()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (string.IsNullOrEmpty(name))
			{
				return;
			}
			if (!string.Equals(_rulesScene, name, StringComparison.Ordinal))
			{
				_rules = LoadRules(name);
				_rulesScene = name;
			}
			List<Rule> list = EffectiveRendererRules();
			if (list.Count > 0)
			{
				SpriteRenderer[] array = Object.FindObjectsByType<SpriteRenderer>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (SpriteRenderer val in array)
				{
					if ((Object)(object)val == (Object)null || !SceneOwned(((Component)val).gameObject))
					{
						continue;
					}
					int instanceID = ((Object)val).GetInstanceID();
					if (_applied.ContainsKey(instanceID))
					{
						continue;
					}
					Color color = val.color;
					foreach (Rule item in list)
					{
						if (Match(color, item.Old, item.Tol))
						{
							if (_rules == null || _rules.Groups.Count <= 0 || InGroups(((Component)val).transform))
							{
								_applied[instanceID] = (val, color);
								val.color = item.New;
							}
							break;
						}
					}
				}
			}
			if (_rules != null && _rules.Particle.Count > 0)
			{
				ParticleSystem[] array2 = Object.FindObjectsByType<ParticleSystem>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (ParticleSystem val2 in array2)
				{
					if ((Object)(object)val2 == (Object)null || !SceneOwned(((Component)val2).gameObject))
					{
						continue;
					}
					int instanceID2 = ((Object)val2).GetInstanceID();
					if (_appliedPs.ContainsKey(instanceID2))
					{
						continue;
					}
					MainModule main = val2.main;
					MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
					if ((int)((MinMaxGradient)(ref startColor)).mode != 0)
					{
						continue;
					}
					Color color2 = ((MinMaxGradient)(ref startColor)).color;
					foreach (Rule item2 in _rules.Particle)
					{
						if (Match(color2, item2.Old, item2.Tol))
						{
							_appliedPs[instanceID2] = (val2, color2);
							((MainModule)(ref main)).startColor = new MinMaxGradient(item2.New);
							break;
						}
					}
				}
			}
			Color? val3 = _previewAmbient ?? ((_rules != null) ? _rules.Ambient : ((Color?)null));
			if (val3.HasValue)
			{
				ApplyAmbient(val3.Value);
			}
		}

		private static void ApplyAmbient(Color c)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!_ambientApplied)
			{
				SnapshotAmbientVanilla();
				_ambientApplied = true;
			}
			ApplyAmbientValues(c);
		}

		private static void SnapshotAmbientVanilla()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			_ambVanLight = RenderSettings.ambientLight;
			_ambVanSky = RenderSettings.ambientSkyColor;
			_ambVanEquator = RenderSettings.ambientEquatorColor;
			_ambVanGround = RenderSettings.ambientGroundColor;
		}

		private static void ApplyAmbientValues(Color c)
		{
			//IL_0000: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			RenderSettings.ambientLight = c;
			RenderSettings.ambientSkyColor = c;
			RenderSettings.ambientEquatorColor = c;
			RenderSettings.ambientGroundColor = c;
			Shader.SetGlobalColor("unity_AmbientSky", c);
			Shader.SetGlobalColor("unity_AmbientEquator", c);
			Shader.SetGlobalColor("unity_AmbientGround", c);
		}

		public static void EnforceAmbient()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!_ambientApplied)
			{
				return;
			}
			Color? val = _previewAmbient ?? ((_rules != null) ? _rules.Ambient : ((Color?)null));
			if (val.HasValue)
			{
				Color value = val.Value;
				if (!(RenderSettings.ambientLight == value))
				{
					SnapshotAmbientVanilla();
					ApplyAmbientValues(value);
				}
			}
		}

		private static void RestoreAll()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, (SpriteRenderer, Color)> item in _applied)
			{
				var (val, color) = item.Value;
				if (!((Object)(object)val == (Object)null))
				{
					val.color = color;
				}
			}
			_applied.Clear();
			foreach (KeyValuePair<int, (ParticleSystem, Color)> appliedP in _appliedPs)
			{
				var (val2, val3) = appliedP.Value;
				if (!((Object)(object)val2 == (Object)null))
				{
					MainModule main = val2.main;
					((MainModule)(ref main)).startColor = new MinMaxGradient(val3);
				}
			}
			_appliedPs.Clear();
			if (_ambientApplied)
			{
				RenderSettings.ambientLight = _ambVanLight;
				RenderSettings.ambientSkyColor = _ambVanSky;
				RenderSettings.ambientEquatorColor = _ambVanEquator;
				RenderSettings.ambientGroundColor = _ambVanGround;
				Shader.SetGlobalColor("unity_AmbientSky", _ambVanSky);
				Shader.SetGlobalColor("unity_AmbientEquator", _ambVanEquator);
				Shader.SetGlobalColor("unity_AmbientGround", _ambVanGround);
				_ambientApplied = false;
			}
		}

		public static void SetPreview(Color oldC, Color newC, float tol = 0.05f)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_preview = new Rule
			{
				Old = oldC,
				New = newC,
				Tol = tol,
				Source = null
			};
			RestoreAll();
			ApplyToScene();
		}

		public static void ClearPreview()
		{
			ClearGlobalPreview();
			if (_preview != null || _previewAmbient.HasValue)
			{
				_preview = null;
				_previewAmbient = null;
				RestoreAll();
				ApplyToScene();
			}
		}

		public static void SetAmbientPreview(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			_previewAmbient = c;
			RestoreAll();
			ApplyToScene();
		}

		public static void WriteRule(string scene, Color oldC, Color newC)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			UpsertRuleLine(RootFileFor(scene), oldC, newC);
			_preview = null;
			Reload();
		}

		public static void RemoveRule(string scene, Color oldC)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (RemoveRuleLine(RootFileFor(scene), oldC))
			{
				_preview = null;
				Reload();
			}
		}

		private static void UpsertRuleLine(string file, Color oldC, Color newC)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			IOUtil.EnsureDirectoryExists(Path.GetDirectoryName(file));
			List<string> list = (File.Exists(file) ? new List<string>(File.ReadAllLines(IOUtil.LongSafe(file))) : new List<string>());
			string text = ToHex(oldC) + " -> " + ToHex(newC);
			int num = FindRuleLine(list, oldC);
			if (num >= 0)
			{
				list[num] = text;
			}
			else
			{
				list.Add(text);
			}
			File.WriteAllLines(IOUtil.LongSafe(file), list);
		}

		private static bool RemoveRuleLine(string file, Color oldC)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(file))
			{
				return false;
			}
			List<string> list = new List<string>(File.ReadAllLines(IOUtil.LongSafe(file)));
			int num = FindRuleLine(list, oldC);
			if (num < 0)
			{
				return false;
			}
			list.RemoveAt(num);
			File.WriteAllLines(IOUtil.LongSafe(file), list);
			return true;
		}

		public static bool TryGetVanilla(int rendererId, out Color vanilla)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (_applied.TryGetValue(rendererId, out (SpriteRenderer, Color) value))
			{
				vanilla = value.Item2;
				return true;
			}
			vanilla = default(Color);
			return false;
		}

		public static List<(Color oldC, Color newC)> GetRootRules(string scene)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			List<(Color, Color)> list = new List<(Color, Color)>();
			string path = RootFileFor(scene);
			if (!File.Exists(path))
			{
				return list;
			}
			string[] array = File.ReadAllLines(IOUtil.LongSafe(path));
			for (int i = 0; i < array.Length; i++)
			{
				if (TryParseRuleLine(array[i], out var particle, out var rule) && !particle)
				{
					list.Add((rule.Old, rule.New));
				}
			}
			return list;
		}

		private static int FindRuleLine(List<string> lines, Color oldC)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < lines.Count; i++)
			{
				if (TryParseRuleLine(lines[i], out var particle, out var rule) && !particle && Match(rule.Old, oldC, Mathf.Max(rule.Tol, 0.05f)))
				{
					return i;
				}
			}
			return -1;
		}

		public static void WriteAmbientRule(string scene, Color c)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			string path = RootFileFor(scene);
			IOUtil.EnsureDirectoryExists(Path.GetDirectoryName(path));
			List<string> list = (File.Exists(path) ? new List<string>(File.ReadAllLines(IOUtil.LongSafe(path))) : new List<string>());
			int num = list.FindIndex((string l) => l.TrimStart().StartsWith("ambient:", StringComparison.OrdinalIgnoreCase));
			string text = "ambient: " + ToHex(c);
			if (num >= 0)
			{
				list[num] = text;
			}
			else
			{
				list.Insert(0, text);
			}
			File.WriteAllLines(IOUtil.LongSafe(path), list);
			_previewAmbient = null;
			Reload();
		}

		public static void RemoveAmbientRule(string scene)
		{
			string path = RootFileFor(scene);
			if (File.Exists(path))
			{
				List<string> list = new List<string>(File.ReadAllLines(IOUtil.LongSafe(path)));
				if (list.RemoveAll((string l) => l.TrimStart().StartsWith("ambient:", StringComparison.OrdinalIgnoreCase)) != 0)
				{
					File.WriteAllLines(IOUtil.LongSafe(path), list);
					_previewAmbient = null;
					Reload();
				}
			}
		}

		public static bool TryGetRootAmbient(string scene, out Color c)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			c = default(Color);
			string path = RootFileFor(scene);
			if (!File.Exists(path))
			{
				return false;
			}
			string[] array = File.ReadAllLines(IOUtil.LongSafe(path));
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.StartsWith("ambient:", StringComparison.OrdinalIgnoreCase) && TryParseHex(text.Substring(8).Trim(), out c))
				{
					return true;
				}
			}
			return false;
		}

		private static List<Rule> EffectiveRendererRules()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (_preview == null)
			{
				if (_rules == null)
				{
					return new List<Rule>();
				}
				return _rules.Renderer;
			}
			List<Rule> list = new List<Rule> { _preview };
			if (_rules != null)
			{
				foreach (Rule item in _rules.Renderer)
				{
					if (!Match(item.Old, _preview.Old, Mathf.Max(item.Tol, _preview.Tol)))
					{
						list.Add(item);
					}
				}
			}
			return list;
		}

		private static SceneRules LoadRules(string scene)
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			ConflictTracker.ClearTypes("recolour");
			SceneRules rules = null;
			List<Rule> renderer = new List<Rule>();
			List<Rule> particle = new List<Rule>();
			foreach (string activePackPath in PackManager.ActivePackPaths)
			{
				LoadFile(Path.Combine(activePackPath, "Recolour", scene + ".txt"), activePackPath, rootWins: false);
			}
			LoadFile(RootFileFor(scene), null, rootWins: true);
			if (rules == null)
			{
				return null;
			}
			rules.Renderer.AddRange(renderer);
			rules.Particle.AddRange(particle);
			if (rules.Renderer.Count > 0 || rules.Particle.Count > 0 || rules.Ambient.HasValue)
			{
				Plugin.Logger.LogInfo((object)($"[Recolour] Scene '{scene}': {rules.Renderer.Count} renderer rule(s), " + $"{rules.Particle.Count} particle rule(s), {rules.Groups.Count} group scope(s)" + (rules.Ambient.HasValue ? (", ambient " + ToHex(rules.Ambient.Value)) : "") + "."));
			}
			return rules;
			static Rule FindNear(List<Rule> list, Rule r)
			{
				//IL_0012: 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)
				foreach (Rule item in list)
				{
					if (Match(item.Old, r.Old, Mathf.Max(item.Tol, r.Tol)))
					{
						return item;
					}
				}
				return null;
			}
			void LoadFile(string file, string source, bool rootWins)
			{
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				if (File.Exists(file))
				{
					if (rules == null)
					{
						rules = new SceneRules();
					}
					string[] array = File.ReadAllLines(IOUtil.LongSafe(file));
					for (int i = 0; i < array.Length; i++)
					{
						string text = array[i].Trim();
						if (text.Length != 0)
						{
							bool particle2;
							Rule rule;
							if (text.StartsWith("group:", StringComparison.OrdinalIgnoreCase))
							{
								string text2 = text.Substring(6).Trim();
								if (text2.Length > 0 && !rules.Groups.Contains(text2))
								{
									rules.Groups.Add(text2);
								}
							}
							else if (text.StartsWith("ambient:", StringComparison.OrdinalIgnoreCase))
							{
								if (TryParseHex(text.Substring(8).Trim(), out var c))
								{
									rules.Ambient = c;
								}
							}
							else if (TryParseRuleLine(text, out particle2, out rule))
							{
								rule.Source = source;
								List<Rule> list = (particle2 ? particle : renderer);
								Rule rule2 = FindNear(list, rule);
								if (rule2 == null)
								{
									list.Add(rule);
								}
								else if (rootWins)
								{
									if (!SameColour(rule2.New, rule.New))
									{
										ConflictTracker.Record("recolour", scene + "/" + ToHex(rule.Old), null, rule2.Source);
									}
									list[list.IndexOf(rule2)] = rule;
								}
								else if (!SameColour(rule2.New, rule.New))
								{
									ConflictTracker.Record("recolour", scene + "/" + ToHex(rule.Old), rule2.Source, source);
								}
							}
						}
					}
				}
			}
		}

		private static bool TryParseRuleLine(string line, out bool particle, out Rule rule)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			particle = false;
			rule = null;
			line = line.Trim();
			if (line.StartsWith("particle:", StringComparison.OrdinalIgnoreCase))
			{
				particle = true;
				line = line.Substring(9).Trim();
			}
			int num = line.IndexOf("->", StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			string s = line.Substring(0, num).Trim();
			string text = line.Substring(num + 2).Trim();
			float tol = 0.05f;
			int num2 = text.IndexOf(' ');
			if (num2 > 0)
			{
				string s2 = text.Substring(num2 + 1).Trim();
				text = text.Substring(0, num2).Trim();
				if (float.TryParse(s2, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					tol = Mathf.Clamp(result, 0.001f, 0.5f);
				}
			}
			if (!TryParseHex(s, out var c) || !TryParseHex(text, out var c2))
			{
				return false;
			}
			rule = new Rule
			{
				Old = c,
				New = c2,
				Tol = tol
			};
			return true;
		}

		private static List<Rule> EffectiveGlobalRules()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (_globalRules == null)
			{
				LoadGlobalRules();
				_effGlobalDirty = true;
			}
			if (_effGlobalDirty)
			{
				_effGlobalDirty = false;
				_effGlobal.Clear();
				if (_globalPreview != null)
				{
					_effGlobal.Add(_globalPreview);
				}
				foreach (Rule globalRule in _globalRules)
				{
					if (_globalPreview == null || !Match(globalRule.Old, _globalPreview.Old, Mathf.Max(globalRule.Tol, _globalPreview.Tol)))
					{
						_effGlobal.Add(globalRule);
					}
				}
			}
			return _effGlobal;
		}

		private static void LoadGlobalRules()
		{
			ConflictTracker.ClearTypes("recolour-global");
			_globalRules = new List<Rule>();
			foreach (string activePackPath in PackManager.ActivePackPaths)
			{
				LoadFile(Path.Combine(activePackPath, "Recolour", "_global.txt"), activePackPath, rootWins: false);
			}
			LoadFile(GlobalFile, null, rootWins: true);
			if (_globalRules.Count > 0)
			{
				Plugin.Logger.LogInfo((object)$"[Recolour] Global: {_globalRules.Count} volatile rule(s) loaded.");
			}
			static void LoadFile(string file, string source, bool rootWins)
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				if (File.Exists(file))
				{
					string[] array = File.ReadAllLines(IOUtil.LongSafe(file));
					for (int i = 0; i < array.Length; i++)
					{
						string text = array[i].Trim();
						if (text.Length != 0 && !(!TryParseRuleLine(text, out var particle, out var rule) || particle))
						{
							rule.Source = source;
							Rule rule2 = null;
							foreach (Rule globalRule in _globalRules)
							{
								if (Match(globalRule.Old, rule.Old, Mathf.Max(globalRule.Tol, rule.Tol)))
								{
									rule2 = globalRule;
									break;
								}
							}
							if (rule2 == null)
							{
								_globalRules.Add(rule);
							}
							else if (rootWins)
							{
								if (!SameColour(rule2.New, rule.New))
								{
									ConflictTracker.Record("recolour-global", "_global/" + ToHex(rule.Old), null, rule2.Source);
								}
								_globalRules[_globalRules.IndexOf(rule2)] = rule;
							}
							else if (!SameColour(rule2.New, rule.New))
							{
								ConflictTracker.Record("recolour-global", "_global/" + ToHex(rule.Old), rule2.Source, source);
							}
						}
					}
				}
			}
		}

		private static Rule MatchGlobalRule(List<Rule> rules, Color c)
		{
			//IL_0011: 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)
			foreach (Rule rule in rules)
			{
				if (Match(c, rule.Old, rule.Tol))
				{
					return rule;
				}
			}
			return null;
		}

		public static void TickGlobal()
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			List<Rule> list = EffectiveGlobalRules();
			if (list.Count == 0)
			{
				if (GlobalTrackedCount > 0)
				{
					ReleaseAllGlobal();
				}
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextGlobalSweep)
			{
				return;
			}
			_nextGlobalSweep = realtimeSinceStartup + 0.25f;
			SpriteRenderer[] array = Object.FindObjectsByType<SpriteRenderer>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (SpriteRenderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)val).GetInstanceID();
				if (!_trackedSr.ContainsKey(instanceID) && !_applied.ContainsKey(instanceID))
				{
					Rule rule = MatchGlobalRule(list, val.color);
					if (rule != null)
					{
						_trackedSr[instanceID] = (val, new TrackedTint
						{
							From = val.color,
							Written = rule.New,
							Rule = rule,
							SpriteRef = val.sprite
						});
						val.color = rule.New;
					}
				}
			}
			tk2dBaseSprite[] array2 = Object.FindObjectsByType<tk2dBaseSprite>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (tk2dBaseSprite val2 in array2)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				int instanceID2 = ((Object)val2).GetInstanceID();
				if (!_trackedTk.ContainsKey(instanceID2))
				{
					Rule rule2 = MatchGlobalRule(list, val2.color);
					if (rule2 != null)
					{
						_trackedTk[instanceID2] = (val2, new TrackedTint
						{
							From = val2.color,
							Written = rule2.New,
							Rule = rule2,
							TkSpriteId = val2.spriteId
						});
						val2.color = rule2.New;
					}
				}
			}
		}

		private static bool SameRGB(Color a, Color b)
		{
			//IL_0000: 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_0013: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			if (Mathf.Approximately(a.r, b.r) && Mathf.Approximately(a.g, b.g))
			{
				return Mathf.Approximately(a.b, b.b);
			}
			return false;
		}

		private static Color WithAlphaOf(Color rgb, Color alphaSrc)
		{
			//IL_0000: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Color(rgb.r, rgb.g, rgb.b, alphaSrc.a);
		}

		public static void EnforceGlobal()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			if (GlobalTrackedCount == 0)
			{
				return;
			}
			List<Rule> list = EffectiveGlobalRules();
			List<int> list2 = null;
			foreach (KeyValuePair<int, (SpriteRenderer, TrackedTint)> item in _trackedSr)
			{
				var (val, trackedTint) = item.Value;
				if ((Object)(object)val == (Object)null)
				{
					(list2 ?? (list2 = new List<int>())).Add(item.Key);
					continue;
				}
				if (!list.Contains(trackedTint.Rule) || (Object)(object)val.sprite != (Object)(object)trackedTint.SpriteRef)
				{
					if (SameRGB(val.color, trackedTint.Written))
					{
						val.color = WithAlphaOf(trackedTint.From, val.color);
					}
					(list2 ?? (list2 = new List<int>())).Add(item.Key);
					continue;
				}
				Color color = val.color;
				if (SameRGB(color, trackedTint.Written))
				{
					if (color != trackedTint.Written)
					{
						trackedTint.Written = color;
					}
					continue;
				}
				Rule rule = MatchGlobalRule(list, color);
				if (rule != null)
				{
					trackedTint.From = color;
					trackedTint.Written = rule.New;
					trackedTint.Rule = rule;
					val.color = rule.New;
				}
				else
				{
					(list2 ?? (list2 = new List<int>())).Add(item.Key);
				}
			}
			if (list2 != null)
			{
				foreach (int item2 in list2)
				{
					_trackedSr.Remove(item2);
				}
				list2.Clear();
			}
			foreach (KeyValuePair<int, (tk2dBaseSprite, TrackedTint)> item3 in _trackedTk)
			{
				var (val2, trackedTint2) = item3.Value;
				if ((Object)(object)val2 == (Object)null)
				{
					(list2 ?? (list2 = new List<int>())).Add(item3.Key);
					continue;
				}
				if (!list.Contains(trackedTint2.Rule) || val2.spriteId != trackedTint2.TkSpriteId)
				{
					if (SameRGB(val2.color, trackedTint2.Written))
					{
						val2.color = WithAlphaOf(trackedTint2.From, val2.color);
					}
					(list2 ?? (list2 = new List<int>())).Add(item3.Key);
					continue;
				}
				Color color2 = val2.color;
				if (SameRGB(color2, trackedTint2.Written))
				{
					if (color2 != trackedTint2.Written)
					{
						trackedTint2.Written = color2;
					}
					continue;
				}
				Rule rule2 = MatchGlobalRule(list, color2);
				if (rule2 != null)
				{
					trackedTint2.From = color2;
					trackedTint2.Written = rule2.New;
					trackedTint2.Rule = rule2;
					val2.color = rule2.New;
				}
				else
				{
					(list2 ?? (list2 = new List<int>())).Add(item3.Key);
				}
			}
			if (list2 == null)
			{
				return;
			}
			foreach (int item4 in list2)
			{
				_trackedTk.Remove(item4);
			}
		}

		private static void ReleaseAllGlobal()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<int, (SpriteRenderer, TrackedTint)> item in _trackedSr)
			{
				var (val, trackedTint) = item.Value;
				if ((Object)(object)val != (Object)null && SameRGB(val.color, trackedTint.Written))
				{
					val.color = WithAlphaOf(trackedTint.From, val.color);
				}
			}
			_trackedSr.Clear();
			foreach (KeyValuePair<int, (tk2dBaseSprite, TrackedTint)> item2 in _trackedTk)
			{
				var (val2, trackedTint2) = item2.Value;
				if ((Object)(object)val2 != (Object)null && SameRGB(val2.color, trackedTint2.Written))
				{
					val2.color = WithAlphaOf(trackedTint2.From, val2.color);
				}
			}
			_trackedTk.Clear();
		}

		public static void SetGlobalPreview(Color oldC, Color newC, float tol = 0.05f)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_globalPreview = new Rule
			{
				Old = oldC,
				New = newC,
				Tol = tol
			};
			_effGlobalDirty = true;
			_nextGlobalSweep = 0f;
		}

		public static void ClearGlobalPreview()
		{
			if (_globalPreview != null)
			{
				_globalPreview = null;
				_effGlobalDirty = true;
			}
		}

		public static void WriteGlobalRule(Color oldC, Color newC)
		{
			//IL_0005: 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)
			UpsertRuleLine(GlobalFile, oldC, newC);
			_globalPreview = null;
			ReloadGlobal();
		}

		public static void RemoveGlobalRule(Color oldC)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (RemoveRuleLine(GlobalFile, oldC))
			{
				_globalPreview = null;
				ReloadGlobal();
			}
		}

		public static bool TryGetGlobalRule(Color oldC, out Color newC)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			newC = default(Color);
			if (_globalRules == null)
			{
				LoadGlobalRules();
			}
			foreach (Rule globalRule in _globalRules)
			{
				if (Match(globalRule.Old, oldC, Mathf.Max(globalRule.Tol, 0.05f)))
				{
					newC = globalRule.New;
					return true;
				}
			}
			return false;
		}

		public static bool TryGetGlobalFrom(int rendererId, out Color from)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (_trackedSr.TryGetValue(rendererId, out (SpriteRenderer, TrackedTint) value))
			{
				from = value.Item2.From;
				return true;
			}
			if (_trackedTk.TryGetValue(rendererId, out (tk2dBaseSprite, TrackedTint) value2))
			{
				from = value2.Item2.From;
				return true;
			}
			from = default(Color);
			return false;
		}

		public static void ReloadGlobal()
		{
			_globalRules = null;
			_effGlobalDirty = true;
			_nextGlobalSweep = 0f;
		}

		public static bool TryParseHex(string s, out Color c)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			c = default(Color);
			if (string.IsNullOrEmpty(s))
			{
				return false;
			}
			if (s[0] == '#')
			{
				s = s.Substring(1);
			}
			if (s.Length != 6 && s.Length != 8)
			{
				return false;
			}
			if (!uint.TryParse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (s.Length == 6)
			{
				result = (result << 8) | 0xFF;
			}
			c = new Color((float)((result >> 24) & 0xFF) / 255f, (float)((result >> 16) & 0xFF) / 255f, (float)((result >> 8) & 0xFF) / 255f, (float)(result & 0xFF) / 255f);
			return true;
		}

		public static string ToHex(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			var (b, b2, b3, b4) = Key(c);
			return $"#{b:X2}{b2:X2}{b3:X2}{b4:X2}";
		}

		public static bool Match(Color a, Color b, float tol)
		{
			//IL_0000: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (Mathf.Abs(a.r - b.r) <= tol && Mathf.Abs(a.g - b.g) <= tol && Mathf.Abs(a.b - b.b) <= tol)
			{
				return Mathf.Abs(a.a - b.a) <= tol;
			}
			return false;
		}

		private static (byte, byte, byte, byte) Key(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			return ((byte)Mathf.RoundToInt(Mathf.Clamp01(c.r) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(c.g) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(c.b) * 255f), (byte)Mathf.RoundToInt(Mathf.Clamp01(c.a) * 255f));
		}

		private static bool SameColour(Color a, Color b)
		{
			//IL_0000: 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)
			var (b2, b3, b4, b5) = Key(a);
			var (b6, b7, b8, b9) = Key(b);
			if (b2 == b6 && b3 == b7 && b4 == b8)
			{
				return b5 == b9;
			}
			return false;
		}

		private static bool InGroups(Transform t)
		{
			string text = ((Object)t).name;
			Transform parent = t.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			foreach (string group in _rules.Groups)
			{
				if (text.IndexOf(group, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class ReloadCoordinator
	{
		private static bool _pendingSceneDispatch;

		private static bool AnyFlagSet
		{
			get
			{
				if (!SpriteFileWatcher.ReloadSprites && !SpriteFileWatcher.ReloadT2DSprites && !AudioFileWatcher.ReloadAudio && !TextFileWatcher.ReloadText && !FontFileWatcher.ReloadFonts && !VideoHandler.ReloadVideos && !RecolourHandler.ReloadRequested)
				{
					return SpriteLoader.IsReloadingSliced;
				}
				return true;
			}
		}

		internal static void RequestSceneReloadAfterDrain()
		{
			_pendingSceneDispatch = true;
		}

		internal static void Poll()
		{
			SpriteFileWatcher.Tick();
			FontHandler.Tick();
			ReloadToast.TickSpriteFlush();
			if (SpriteFileWatcher.ReloadSprites)
			{
				Plugin.Logger.LogDebug((object)"[Update] ReloadSprites flag set — triggering SpriteLoader.Reload()");
				SpriteFileWatcher.ReloadSprites = false;
				ReloadToast.ArmSpriteFlush();
				if (Plugin.Config.SlicedSpriteReload)
				{
					SpriteLoader.RequestSlicedReload();
				}
				else
				{
					DevProfiler.StartOp();
					FileCache.BeginCycle();
					try
					{
						SpriteLoader.Reload();
					}
					finally
					{
						FileCache.EndCycle();
					}
					float num = DevProfiler.StopOp("SpriteLoader.Reload");
					if (num > 250f)
					{
						Plugin.Logger.LogInfo((object)$"[ReloadTiming] SpriteLoader.Reload: {num:F0} ms (synchronous — one frozen frame)");
					}
					Plugin.Logger.LogDebug((object)$"[Reload] SpriteLoader.Reload completed in {num:F1}ms");
				}
			}
			if (SpriteFileWatcher.ReloadT2DSprites)
			{
				Plugin.Logger.LogDebug((object)"[Update] ReloadT2DSprites flag set — triggering T2DLoader.ReloadSpritesInScene()");
				SpriteFileWatcher.ReloadT2DSprites = false;
				DevProfiler.StartOp();
				FileCache.BeginCycle();
				try
				{
					T2DLoader.ReloadSpritesInScene();
				}
				finally
				{
					FileCache.EndCycle();
				}
				float num2 = DevProfiler.StopOp("T2DLoader.ReloadSpritesInScene");
				if (num2 > 250f)
				{
					Plugin.Logger.LogInfo((object)$"[ReloadTiming] T2DLoader.ReloadSpritesInScene: {num2:F0} ms");
				}
				Plugin.Logger.LogDebug((object)$"[Reload] T2DLoader.ReloadSpritesInScene completed in {num2:F1}ms");
				ReloadToast.Flush(ReloadToast.Kind.T2D, "T2D");
				T2DLoader.OnSceneLoaded();
				T2DTextureController.RequestRefresh();
				T2DLoader.RefreshSubstitutedCursor();
				Plugin.ScheduleDeferredApplyPasses();
				if (!GCUtil.IsIncrementalMode && GCUtil.HeapPressure > 0.7)
				{
					DevProfiler.MarkExpectedCollect("t2d-reload");
					GCUtil.ForceCollect();
				}
			}
			if (AudioFileWatcher.ReloadAudio)
			{
				AudioFileWatcher.ReloadAudio = false;
				DevProfiler.StartOp();
				FileCache.BeginCycle();
				try
				{
					AudioHandler.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
				DevProfiler.StopOp("AudioHandler.Reload");
				ReloadToast.Flush(ReloadToast.Kind.Audio, Loc.T("Audio"));
				if (!GCUtil.IsIncrementalMode && GCUtil.HeapPressure > 0.7)
				{
					DevProfiler.MarkExpectedCollect("audio-reload");
					GCUtil.ForceCollect();
				}
			}
			if (TextFileWatcher.ReloadText)
			{
				TextFileWatcher.ReloadText = false;
				DevProfiler.StartOp();
				FileCache.BeginCycle();
				try
				{
					DialogueHandler.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
				DevProfiler.StopOp("DialogueHandler.Reload");
				ReloadToast.Flush(ReloadToast.Kind.Text, Loc.T("Text"));
				FontFileWatcher.ReloadFonts = true;
			}
			if (FontFileWatcher.ReloadFonts)
			{
				FontFileWatcher.ReloadFonts = false;
				DevProfiler.StartOp();
				try
				{
					FontHandler.Reload();
				}
				finally
				{
					DevProfiler.StopOp("FontHandler.Reload");
				}
				ReloadToast.Flush(ReloadToast.Kind.Font, Loc.T("Fonts"));
			}
			if (VideoHandler.ReloadVideos)
			{
				VideoHandler.ReloadVideos = false;
				DevProfiler.StartOp();
				FileCache.BeginCycle();
				try
				{
					VideoHandler.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
				DevProfiler.StopOp("VideoHandler.Reload");
			}
			if (RecolourHandler.ReloadRequested)
			{
				RecolourHandler.ReloadRequested = false;
				DevProfiler.StartOp();
				try
				{
					RecolourHandler.Reload();
				}
				finally
				{
					DevProfiler.StopOp("RecolourHandler.Reload");
				}
				DevProfiler.StartOp();
				try
				{
					SlashColourHandler.Reload();
				}
				finally
				{
					DevProfiler.StopOp("SlashColourHandler.Reload");
				}
			}
			GCUtil.BumpThresholdForStitchwork();
			if (_pendingSceneDispatch && !AnyFlagSet)
			{
				_pendingSceneDispatch = false;
				if (!GameBridge.IsInGameScene)
				{
					Plugin.Logger.LogInfo((object)"[Reload] Deferred scene reload dropped — no longer in a game scene.");
				}
				else if (GameBridge.TriggerSceneReloadCurrent())
				{
					Plugin.Logger.LogInfo((object)"[Reload] Reloads drained — pack-apply scene reload dispatched.");
				}
				else
				{
					Plugin.Logger.LogInfo((object)"[Reload] Reloads drained but GameBridge scene reload unavailable — in-place only.");
				}
			}
		}
	}
	public static class SceneTraverser
	{
		private static readonly Queue<string> sceneQueue = new Queue<string>();

		private static int scenesProcessed = 0;

		private static bool _isTraversing = false;

		private static int _scenesSinceLastGC = 0;

		private static bool _sceneArrived;

		private static int _consecutiveArrivalFailures;

		private const float FrameBudgetSec = 0.04f;

		private const float SceneArriveTimeoutSec = 90f;

		private const float UnloadTimeoutSec = 60f;

		private const int MaxConsecutiveArrivalFailures = 3;

		private static int GCEveryNScenes => Plugin.Config.GCEveryNScenes;

		public static bool IsTraversing => _isTraversing;

		public static int Processed => scenesProcessed;

		public static int Total => scenesProcessed + sceneQueue.Count;

		public static string CurrentScene { get; private set; } = "";

		public static string SubProgress { get; private set; } = "";

		public static float StartedAt { get; private set; }

		public static void TraverseAllScenes()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (_isTraversing)
			{
				return;
			}
			Plugin.Logger.LogInfo((object)"Starting scene traversal for full sprite dump...");
			_isTraversing = true;
			_scenesSinceLastGC = 0;
			_consecutiveArrivalFailures = 0;
			sceneQueue.Clear();
			scenesProcessed = 0;
			StartedAt = Time.realtimeSinceStartup;
			foreach (KeyValuePair<string, SceneInfo> item in SceneTeleportMap.GetTeleportMap())
			{
				if ((int)item.Value.MapZone != 0)
				{
					Plugin.Logger.LogDebug((object)$"Enqueued scene: {item.Key} : {item.Value.MapZone}");
					sceneQueue.Enqueue(item.Key);
				}
			}
			Plugin.Logger.LogInfo((object)$"Full dump: {sceneQueue.Count} scenes queued.");
			((MonoBehaviour)Plugin.Instance).StartCoroutine(RunTraversal());
		}

		public static void NotifySceneLoaded()
		{
			_sceneArrived = true;
		}

		private static IEnumerator RunTraversal()
		{
			try
			{
				while (sceneQueue.Count > 0)
				{
					string next = sceneQueue.Dequeue();
					scenesProcessed++;
					CurrentScene = next;
					SubProgress = "";
					_sceneArrived = false;
					GameManager.instance.LoadScene(next);
					float deadline = Time.unscaledTime + 90f;
					while (!_sceneArrived && Time.unscaledTime < deadline)
					{
						yield return null;
					}
					if (!_sceneArrived)
					{
						Plugin.Logger.LogWarning((object)$"[FullDump] '{next}' did not fire sceneLoaded within {90f:F0} s — skipped.");
						_consecutiveArrivalFailures++;
						if (_consecutiveArrivalFailures >= 3)
						{
							Plugin.Logger.LogError((object)($"[FullDump] {3} consecutive scenes failed to arrive — the " + "engine's scene-load pipeline is wedged (usually a game-side scene-load exception on the LAST SUCCESSFUL scene; check the log above it). Aborting the run at " + $"{scenesProcessed}/{Total}; dumps up to this point are on disk."));
							break;
						}
						continue;
					}
					_consecutiveArrivalFailures = 0;
					GameBridge.SetHeroInvincible(on: true);
					tk2dSpriteCollectionData[] collections = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
					float num = Time.realtimeSinceStartup + 0.04f;
					for (int i = 0; i < collections.Length; i++)
					{
						tk2dSpriteCollectionData val = collections[i];
						if (!((Object)(object)val == (Object)null))
						{
							SubProgress = $"{i + 1}/{collections.Length}";
							SpriteDumper.DumpCollection(val);
							if (Time.realtimeSinceStartup >= num)
							{
								yield return null;
								num = Time.realtimeSinceStartup + 0.04f;
							}
						}
					}
					SubProgress = "";
					T2DDumper.DumpAllT2DSprites();
					yield return null;
					AsyncOperation unload = Resources.UnloadUnusedAssets();
					float unloadDeadline = Time.unscaledTime + 60f;
					while (!unload.isDone && Time.unscaledTime < unloadDeadline)
					{
						yield return null;
					}
					if (!unload.isDone)
					{
						Plugin.Logger.LogWarning((object)($"[FullDump] UnloadUnusedAssets did not complete within {60f:F0} s after " + "'" + next + "' — continuing without it (a wedged game scene-load routine blocks the unload op; if the next scenes fail to arrive, the run will abort with a summary)."));
					}
					_scenesSinceLastGC++;
					bool flag = GCUtil.HeapPressure > 0.75;
					if (_scenesSinceLastGC >= GCEveryNScenes || flag)
					{
						string text = (flag ? $"heap pressure {GCUtil.HeapPressure:P0}" : $"{_scenesSinceLastGC} scenes");
						Plugin.Logger.LogDebug((object)("[GC] Running cleanup after " + text + "..."));
						GCUtil.ForceCollect();
						_scenesSinceLastGC = 0;
					}
					Log.Verbose($"[FullDump] Progress: {scenesProcessed}/{Total} scenes");
				}
			}
			finally
			{
				_isTraversing = false;
				CurrentScene = "";
				SubProgress = "";
				float num2 = (Time.realtimeSinceStartup - StartedAt) / 60f;
				Plugin.Logger.LogInfo((object)($"Full dump complete! Processed {scenesProcessed} scenes in {num2:F1} min. " + "Output: " + SpriteDumper.DumpPath));
				Resources.UnloadUnusedAssets();
				GCUtil.ForceCollect();
				GameBridge.SetHeroInvincible(on: false);
				GameBridge.ReturnToMainMenuNoSave();
			}
		}

		public static void OnDumpCompleted()
		{
			_scenesSinceLastGC++;
			bool flag = GCUtil.HeapPressure > 0.75;
			if (_scenesSinceLastGC >= GCEveryNScenes || flag)
			{
				string text = (flag ? $"heap pressure {GCUtil.HeapPressure:P0}" : $"{_scenesSinceLastGC} scenes");
				Plugin.Logger.LogDebug((object)("[GC] Running cleanup after " + text + "..."));
				Resources.UnloadUnusedAssets();
				GCUtil.ForceCollect();
				_scenesSinceLastGC = 0;
			}
		}
	}
	public static class SlashColourHandler
	{
		private static Color? _fileBase;

		private static Color? _fileFire;

		private static Color? _filePoison;

		private static Color? _prevBase;

		private static Color? _prevFire;

		private static Color? _prevPoison;

		private static bool _loaded;

		private static readonly Dictionary<NailElements, Color> _vanillaTint = new Dictionary<NailElements, Color>();

		private static readonly FieldRef<NailAttackBase, tk2dSprite> _slashSpriteRef = AccessTools.FieldRefAccess<NailAttackBase, tk2dSprite>("slashSprite");

		private static readonly FieldRef<NailAttackBase, HeroController> _hcRef = AccessTools.FieldRefAccess<NailAttackBase, HeroController>("hc");

		private static readonly FieldRef<HeroExtraNailSlash, SpriteRenderer[]> _tintSpritesRef = AccessTools.FieldRefAccess<HeroExtraNailSlash, SpriteRenderer[]>("tintSprites");

		private static readonly FieldRef<HeroExtraNailSlash, tk2dSprite[]> _tintTkRef = AccessTools.FieldRefAccess<HeroExtraNailSlash, tk2dSprite[]>("tintTk2dSprites");

		private static readonly FieldRef<HeroNailImbuement, NailImbuementConfig[]> _nailConfigsRef = AccessTools.FieldRefAccess<HeroNailImbuement, NailImbuementConfig[]>("nailConfigs");

		public static string RootFile => Path.Combine(Plugin.BasePath, "Recolour", "_slash.txt");

		public static Color? EffectiveBase
		{
			get
			{
				EnsureLoaded();
				return _prevBase ?? _fileBase;
			}
		}

		public static Color? EffectiveFire
		{
			get
			{
				EnsureLoaded();
				return _prevFire ?? _fileFire;
			}
		}

		public static Color? EffectivePoison
		{
			get
			{
				EnsureLoaded();
				return _prevPoison ?? _filePoison;
			}
		}

		public static void ApplyPatches(Harmony harmony)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Method(typeof(NailAttackBase), "OnSlashStarting", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SlashColourHandler), "OnSlashStartingPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(HeroExtraNailSlash), "OnEnable", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SlashColourHandler), "ExtraSlashOnEnablePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void OnSlashStartingPostfix(NailAttackBase __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			Color? effectiveBase = EffectiveBase;
			if (!effectiveBase.HasValue)
			{
				return;
			}
			Color valueOrDefault = effectiveBase.GetValueOrDefault();
			HeroController val = _hcRef.Invoke(__instance);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.NailImbuement == (Object)null) && !((Object)(object)val.NailImbuement.CurrentImbuement != (Object)null))
			{
				tk2dSprite val2 = _slashSpriteRef.Invoke(__instance);
				if ((Object)(object)val2 != (Object)null)
				{
					((tk2dBaseSprite)val2).color = valueOrDefault;
				}
			}
		}

		private static void ExtraSlashOnEnablePostfix(HeroExtraNailSlash __instance)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			Color? effectiveBase = EffectiveBase;
			if (!effectiveBase.HasValue)
			{
				return;
			}
			Color valueOrDefault = effectiveBase.GetValueOrDefault();
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.NailImbuement == (Object)null || (Object)(object)instance.NailImbuement.CurrentImbuement != (Object)null)
			{
				return;
			}
			SpriteRenderer[] array = _tintSpritesRef.Invoke(__instance);
			if (array != null)
			{
				SpriteRenderer[] array2 = array;
				foreach (SpriteRenderer val in array2)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.color = valueOrDefault;
					}
				}
			}
			tk2dSprite[] array3 = _tintTkRef.Invoke(__instance);
			if (array3 == null)
			{
				return;
			}
			tk2dSprite[] array4 = array3;
			foreach (tk2dSprite val2 in array4)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					((tk2dBaseSprite)val2).color = valueOrDefault;
				}
			}
		}

		public static void Invalidate()
		{
			_loaded = false;
		}

		private static void EnsureLoaded()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (_loaded)
			{
				return;
			}
			_loaded = true;
			ConflictTracker.ClearTypes("recolour-slash");
			Dictionary<string, (Color c, string src)> merged = new Dictionary<string, (Color, string)>();
			foreach (string activePackPath in PackManager.ActivePackPaths)
			{
				LoadFile(Path.Combine(activePackPath, "Recolour", "_slash.txt"), activePackPath, rootWins: false);
			}
			LoadFile(RootFile, null, rootWins: true);
			_fileBase = (merged.TryGetValue("base", out (Color, string) value) ? new Color?(value.Item1) : ((Color?)null));
			_fileFire = (merged.TryGetValue("fire", out (Color, string) value2) ? new Color?(value2.Item1) : ((Color?)null));
			_filePoison = (merged.TryGetValue("poison", out (Color, string) value3) ? new Color?(value3.Item1) : ((Color?)null));
			if (merged.Count > 0)
			{
				Plugin.Logger.LogInfo((object)$"[Recolour] Slash: {merged.Count} colour rule(s) loaded.");
			}
			void LoadFile(string file, string source, bool rootWins)
			{
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				if (File.Exists(file))
				{
					string[] array = File.ReadAllLines(IOUtil.LongSafe(file));
					for (int i = 0; i < array.Length; i++)
					{
						string text = array[i].Trim();
						int num = text.IndexOf(':');
						if (num > 0)
						{
							string text2 = text.Substring(0, num).Trim().ToLowerInvariant();
							if ((!(text2 != "base") || !(text2 != "fire") || !(text2 != "poison")) && RecolourHandler.TryParseHex(text.Substring(num + 1).Trim(), out var c))
							{
								if (!merged.TryGetValue(text2, out (Color, string) value4))
								{
									merged[text2] = (c, source);
								}
								else if (rootWins)
								{
									if (value4.Item1 != c)
									{
										ConflictTracker.Record("recolour-slash", "_slash/" + text2, null, value4.Item2);
									}
									merged[text2] = (c, source);
								}
								else if (value4.Item1 != c)
								{
									ConflictTracker.Record("recolour-slash", "_slash/" + text2, value4.Item2, source);
								}
							}
						}
					}
				}
			}
		}

		public static void ApplyToConfigs()
		{
			HeroController instance = HeroController.instance;
			if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.NailImbuement == (Object)null))
			{
				NailImbuementConfig[] array = _nailConfigsRef.Invoke(instance.NailImbuement);
				if (array != null)
				{
					ApplyOne(array, (NailElements)1, EffectiveFire);
					ApplyOne(array, (NailElements)2, EffectivePoison);
				}
			}
		}

		private static void ApplyOne(NailImbuementConfig[] configs, NailElements el, Color? c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			//IL_0057: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			int num = (int)el;
			if (num < 0 || num >= configs.Length)
			{
				return;
			}
			NailImbuementConfig val = configs[num];
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Color value;
			if (c.HasValue)
			{
				Color valueOrDefault = c.GetValueOrDefault();
				if (!_vanillaTint.ContainsKey(el))
				{
					_vanillaTint[el] = val.NailTintColor;
				}
				val.NailTintColor = valueOrDefault;
			}
			else if (_vanillaTint.TryGetValue(el, out value))
			{
				val.NailTintColor = value;
				_vanillaTint.Remove(el);
			}
		}

		public static void Reload()
		{
			Invalidate();
			ApplyToConfigs();
		}

		public static Color VanillaFor(string key)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected I4, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (key == "base")
			{
				return Color.white;
			}
			NailElements val = (NailElements)((key == "fire") ? 1 : 2);
			if (_vanillaTint.TryGetValue(val, out var value))
			{
				return value;
			}
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.NailImbuement != (Object)null)
			{
				NailImbuementConfig[] array = _nailConfigsRef.Invoke(instance.NailImbuement);
				int num = (int)val;
				if (array != null && num < array.Length && (Object)(object)array[num] != (Object)null)
				{
					return array[num].NailTintColor;
				}
			}
			return Color.white;
		}

		public static void SetPreview(string key, Color c)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			switch (key)
			{
			case "base":
				_prevBase = c;
				break;
			case "fire":
				_prevFire = c;
				break;
			case "poison":
				_prevPoison = c;
				break;
			}
			ApplyToConfigs();
		}

		public static void ClearPreview()
		{
			_prevBase = (_prevFire = (_prevPoison = null));
			ApplyToConfigs();
		}

		public static bool TryGetRootRule(string key, out Color c)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			c = default(Color);
			if (!File.Exists(RootFile))
			{
				return false;
			}
			string[] array = File.ReadAllLines(IOUtil.LongSafe(RootFile));
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				int num = text.IndexOf(':');
				if (num > 0 && string.Equals(text.Substring(0, num).Trim(), key, StringComparison.OrdinalIgnoreCase))
				{
					return RecolourHandler.TryParseHex(text.Substring(num + 1).Trim(), out c);
				}
			}
			return false;
		}

		public static void WriteRule(string key, Color c)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = (File.Exists(RootFile) ? new List<string>(File.ReadAllLines(IOUtil.LongSafe(RootFile))) : new List<string>());
			string text = key + ": " + RecolourHandler.ToHex(c);
			int num = list.FindIndex((string l) => l.TrimStart().StartsWith(key + ":", StringComparison.OrdinalIgnoreCase));
			if (num >= 0)
			{
				list[num] = text;
			}
			else
			{
				list.Add(text);
			}
			IOUtil.EnsureDirectoryExists(Path.GetDirectoryName(RootFile));
			File.WriteAllLines(IOUtil.LongSafe(RootFile), list);
			Reload();
		}

		public static void RemoveRule(string key)
		{
			if (File.Exists(RootFile))
			{
				List<string> list = new List<string>(File.ReadAllLines(IOUtil.LongSafe(RootFile)));
				if (list.RemoveAll((string l) => l.TrimStart().StartsWith(key + ":", StringComparison.OrdinalIgnoreCase)) != 0)
				{
					File.WriteAllLines(IOUtil.LongSafe(RootFile), list);
					Reload();
				}
			}
		}
	}
	public static class SpriteDumper
	{
		private static bool _rotateFallbackWarned;

		public static string DumpPath => Path.Combine(Plugin.BasePath, "Dumps");

		public static string ConvertPath => Path.Combine(Plugin.BasePath, "Converted");

		public static void DumpCollection(tk2dSpriteCollectionData collection, bool convert = false)
		{
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)collection).name != null && ((Object)collection).name.StartsWith("Stitchwork_Shadow", StringComparison.Ordinal))
			{
				return;
			}
			string text = (convert ? ConvertPath : DumpPath);
			Material[] materials = collection.materials;
			foreach (Material val in materials)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.mainTexture == (Object)null || val.mainTexture.width == 0 || val.mainTexture.height == 0)
				{
					continue;
				}
				string text2 = ((Object)val).name.Split(' ')[0];
				int matIndex = Array.IndexOf(collection.materials, val);
				tk2dSpriteDefinition[] array = ((matIndex < 0) ? Array.Empty<tk2dSpriteDefinition>() : collection.spriteDefinitions.Where((tk2dSpriteDefinition def) => def.materialId == matIndex).ToArray());
				if (array.Length == 0)
				{
					continue;
				}
				Texture atlas;
				Vector2[] uvs;
				Vector3[] positions;
				bool flag = SpriteLoader.TryGetVanilla(collection, array[0], out atlas, out uvs, out positions);
				Texture val2 = (flag ? atlas : val.mainTexture);
				RenderTexture val3 = null;
				if (!(val2 is RenderTexture))
				{
					val3 = TexUtil.GetReadable(val2);
					val2 = (Texture)(object)val3;
				}
				RenderTexture active = RenderTexture.active;
				bool flag2 = false;
				try
				{
					RenderTexture.active = (RenderTexture)(object)((val2 is RenderTexture) ? val2 : null);
					GL.PushMatrix();
					flag2 = true;
					GL.LoadPixelMatrix(0f, (float)val2.width, (float)val2.height, 0f);
					tk2dSpriteDefinition[] array2 = array;
					foreach (tk2dSpriteDefinition val4 in array2)
					{
						if (string.IsNullOrEmpty(val4.name) || File.Exists(IOUtil.LongSafe(Path.Combine(text, ((Object)collection).name, text2, val4.name + ".png"))))
						{
							continue;
						}
						Vector2[] uvs2 = val4.uvs;
						if (flag)
						{
							SpriteLoader.TryGetVanilla(collection, val4, out var _, out uvs2, out positions);
						}
						Rect spriteRect = SpriteUtil.GetSpriteRect(uvs2, val2);
						if (((Rect)(ref spriteRect)).width == 0f || ((Rect)(ref spriteRect)).height == 0f)
						{
							continue;
						}
						Texture2D val5 = new Texture2D((int)((Rect)(ref spriteRect)).width, (int)((Rect)(ref spriteRect)).height, (TextureFormat)4, false);
						try
						{
							val5.ReadPixels(spriteRect, 0, 0);
							val5.Apply();
							if ((int)val4.flipped == 0)
							{
								byte[] bytes = ImageConversion.EncodeToPNG(val5);
								IOUtil.EnsureDirectoryExists(Path.Combine(text, ((Object)collection).name, text2));
								File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(text, ((Object)collection).name, text2, val4.name + ".png")), bytes);
							}
							else
							{
								DumpRotatedSprite(val4, val5, spriteRect, text, ((Object)collection).name, text2);
							}
						}
						finally
						{
							Object.Destroy((Object)(object)val5);
						}
					}
				}
				finally
				{
					if (flag2)
					{
						GL.PopMatrix();
					}
					RenderTexture.active = active;
					if ((Object)(object)val3 != (Object)null)
					{
						RenderTexture.ReleaseTemporary(val3);
					}
				}
			}
		}

		public static (int sheets, int written, int identical) ConvertCollectionSheets(tk2dSpriteCollectionData collection, bool onlyChanged)
		{
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			if ((Object)(object)collection == (Object)null || collection.materials == null || collection.spriteDefinitions == null)
			{
				return (sheets: 0, written: 0, identical: 0);
			}
			Material[] materials = collection.materials;
			foreach (Material val in materials)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.mainTexture == (Object)null)
				{
					continue;
				}
				string text = ((Object)val).name.Split(' ')[0];
				int matIndex = Array.IndexOf(collection.materials, val);
				if (matIndex < 0)
				{
					continue;
				}
				tk2dSpriteDefinition[] array = collection.spriteDefinitions.Where((tk2dSpriteDefinition d) => d.materialId == matIndex).ToArray();
				if (array.Length == 0)
				{
					continue;
				}
				Texture2D val2 = SpriteLoader.FindSpritesheetTex(collection, ((Object)val).GetInstanceID(), text);
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				num++;
				Texture atlas;
				Vector2[] uvs;
				Vector3[] positions;
				bool flag = SpriteLoader.TryGetVanilla(collection, array[0], out atlas, out uvs, out positions);
				RenderTexture val3 = (RenderTexture)(object)((atlas is RenderTexture) ? atlas : null);
				RenderTexture temporary = RenderTexture.GetTemporary(((Texture)val2).width, ((Texture)val2).height, 0, (RenderTextureFormat)0);
				Graphics.Blit((Texture)(object)val2, temporary);
				RenderTexture active = RenderTexture.active;
				bool flag2 = false;
				try
				{
					Dictionary<string, byte[]> dictionary = null;
					Texture atlas2;
					tk2dSpriteDefinition[] array2;
					if (onlyChanged && flag && (Object)(object)val3 != (Object)null && ((Texture)val3).width == ((Texture)val2).width && ((Texture)val3).height == ((Texture)val2).height)
					{
						dictionary = new Dictionary<string, byte[]>();
						RenderTexture.active = val3;
						GL.PushMatrix();
						flag2 = true;
						GL.LoadPixelMatrix(0f, (float)((Texture)val3).width, (float)((Texture)val3).height, 0f);
						array2 = array;
						foreach (tk2dSpriteDefinition val4 in array2)
						{
							if (string.IsNullOrEmpty(val4.name))
							{
								continue;
							}
							Vector2[] uvs2 = val4.uvs;
							SpriteLoader.TryGetVanilla(collection, val4, out atlas2, out uvs2, out positions);
							Rect spriteRect = SpriteUtil.GetSpriteRect(uvs2, (Texture)(object)val3);
							if (((Rect)(ref spriteRect)).width != 0f && ((Rect)(ref spriteRect)).height != 0f)
							{
								Texture2D val5 = new Texture2D((int)((Rect)(ref spriteRect)).width, (int)((Rect)(ref spriteRect)).height, (TextureFormat)4, false);
								try
								{
									val5.ReadPixels(spriteRect, 0, 0);
									val5.Apply();
									dictionary[val4.name] = val5.GetRawTextureData();
								}
								finally
								{
									Object.Destroy((Object)(object)val5);
								}
							}
						}
						GL.PopMatrix();
						flag2 = false;
					}
					RenderTexture.active = temporary;
					GL.PushMatrix();
					flag2 = true;
					GL.LoadPixelMatrix(0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height, 0f);
					array2 = array;
					foreach (tk2dSpriteDefinition val6 in array2)
					{
						if (string.IsNullOrEmpty(val6.name))
						{
							continue;
						}
						Vector2[] uvs3 = val6.uvs;
						if (flag)
						{
							SpriteLoader.TryGetVanilla(collection, val6, out atlas2, out uvs3, out positions);
						}
						Rect spriteRect2 = SpriteUtil.GetSpriteRect(uvs3, (Texture)(object)temporary);
						if (((Rect)(ref spriteRect2)).width == 0f || ((Rect)(ref spriteRect2)).height == 0f)
						{
							continue;
						}
						Texture2D val7 = new Texture2D((int)((Rect)(ref spriteRect2)).width, (int)((Rect)(ref spriteRect2)).height, (TextureFormat)4, false);
						try
						{
							val7.ReadPixels(spriteRect2, 0, 0);
							val7.Apply();
							if (dictionary != null && dictionary.TryGetValue(val6.name, out var value) && BytesEqual(value, val7.GetRawTextureData()))
							{
								num3++;
								continue;
							}
							string text2 = Path.Combine(ConvertPath, ((Object)collection).name, text);
							IOUtil.EnsureDirectoryExists(text2);
							if ((int)val6.flipped == 0)
							{
								File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(text2, val6.name + ".png")), ImageConversion.EncodeToPNG(val7));
							}
							else
							{
								DumpRotatedSprite(val6, val7, spriteRect2, ConvertPath, ((Object)collection).name, text);
							}
							num2++;
						}
						finally
						{
							Object.Destroy((Object)(object)val7);
						}
					}
				}
				finally
				{
					if (flag2)
					{
						GL.PopMatrix();
					}
					RenderTexture.active = active;
					RenderTexture.ReleaseTemporary(temporary);
					Object.Destroy((Object)(object)val2);
				}
			}
			return (sheets: num, written: num2, identical: num3);
		}

		private static bool BytesEqual(byte[] a, byte[] b)
		{
			if (a != null && b != null)
			{
				return a.AsSpan().SequenceEqual(b);
			}
			return false;
		}

		public static Texture2D RotateToScreen(Texture2D src, FlipMode flip)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0015: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			(Vector2 uBasis, Vector2 vBasis) tuple = SpriteUtil.DumpBasisFor(flip);
			Vector2 item = tuple.uBasis;
			Vector2 item2 = tuple.vBasis;
			bool num = (int)flip > 0;
			int num2 = (num ? ((Texture)src).height : ((Texture)src).width);
			int num3 = (num ? ((Texture)src).width : ((Texture)src).height);
			RenderTexture temporary = RenderTexture.GetTemporary(num2, num3, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			RenderTexture active = RenderTexture.active;
			Texture2D val = new Texture2D(num2, num3, (TextureFormat)4, false);
			bool flag = false;
			try
			{
				RenderTexture.active = temporary;
				GL.PushMatrix();
				flag = true;
				GL.LoadPixelMatrix(0f, (float)((Texture)temporary).height, (float)((Texture)temporary).width, 0f);
				TexUtil.DrawRotated(new Rect(0f, 0f, (float)((Texture)src).width, (float)((Texture)src).height), (Texture)(object)src, item, item2);
				val.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
				val.Apply();
				return val;
			}
			finally
			{
				if (flag)
				{
					GL.PopMatrix();
				}
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		private static void DumpRotatedSprite(tk2dSpriteDefinition def, Texture2D spriteTex, Rect spriteRect, string baseDir, string collectionName, string matname)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if (!TexUtil.RotateDrawAvailable)
			{
				if (!_rotateFallbackWarned)
				{
					_rotateFallbackWarned = true;
					Plugin.Logger.LogWarning((object)"[SpriteDumper] Rotate shader unavailable — rotated frames dump in atlas orientation (sideways).");
				}
				IOUtil.EnsureDirectoryExists(Path.Combine(baseDir, collectionName, matname));
				File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(baseDir, collectionName, matname, def.name + ".png")), ImageConversion.EncodeToPNG(spriteTex));
				return;
			}
			RenderTexture temporary = RenderTexture.GetTemporary((int)((Rect)(ref spriteRect)).height, (int)((Rect)(ref spriteRect)).width, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			Texture2D val = null;
			RenderTexture active = RenderTexture.active;
			bool flag = false;
			try
			{
				RenderTexture.active = temporary;
				GL.PushMatrix();
				flag = true;
				GL.LoadPixelMatrix(0f, (float)((Texture)temporary).height, (float)((Texture)temporary).width, 0f);
				var (uB, vB) = SpriteUtil.DumpBasisFor(def.flipped);
				TexUtil.DrawRotated(new Rect(0f, 0f, (float)((Texture)spriteTex).width, (float)((Texture)spriteTex).height), (Texture)(object)spriteTex, uB, vB);
				val = new Texture2D((int)((Rect)(ref spriteRect)).height, (int)((Rect)(ref spriteRect)).width, (TextureFormat)4, false);
				val.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
				val.Apply();
				byte[] bytes = ImageConversion.EncodeToPNG(val);
				IOUtil.EnsureDirectoryExists(Path.Combine(baseDir, collectionName, matname));
				File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(baseDir, collectionName, matname, def.name + ".png")), bytes);
			}
			finally
			{
				if (flag)
				{
					GL.PopMatrix();
				}
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		public static void DumpSingleSprite(tk2dSpriteDefinition def, tk2dSpriteCollectionData collection)
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			if (def == null || string.IsNullOrEmpty(def.name) || (Object)(object)collection == (Object)null || collection.materials == null || def.materialId < 0 || def.materialId >= collection.materials.Length)
			{
				return;
			}
			Material val = collection.materials[def.materialId];
			if ((Object)(object)val == (Object)null || (Object)(object)val.mainTexture == (Object)null || val.mainTexture.width == 0 || val.mainTexture.height == 0)
			{
				return;
			}
			string text = ((Object)val).name.Split(' ')[0];
			if (File.Exists(IOUtil.LongSafe(Path.Combine(DumpPath, ((Object)collection).name, text, def.name + ".png"))))
			{
				return;
			}
			Texture atlas;
			Vector2[] uvs;
			Vector3[] positions;
			Texture val2 = (SpriteLoader.TryGetVanilla(collection, def, out atlas, out uvs, out positions) ? atlas : val.mainTexture);
			RenderTexture val3 = null;
			if (!(val2 is RenderTexture))
			{
				val3 = TexUtil.GetReadable(val2);
				val2 = (Texture)(object)val3;
			}
			RenderTexture active = RenderTexture.active;
			bool flag = false;
			try
			{
				RenderTexture.active = (RenderTexture)(object)((val2 is RenderTexture) ? val2 : null);
				GL.PushMatrix();
				flag = true;
				GL.LoadPixelMatrix(0f, (float)val2.width, (float)val2.height, 0f);
				Rect spriteRect = SpriteUtil.GetSpriteRect(uvs, val2);
				if (((Rect)(ref spriteRect)).width == 0f || ((Rect)(ref spriteRect)).height == 0f)
				{
					return;
				}
				Texture2D val4 = new Texture2D((int)((Rect)(ref spriteRect)).width, (int)((Rect)(ref spriteRect)).height, (TextureFormat)4, false);
				try
				{
					val4.ReadPixels(spriteRect, 0, 0);
					val4.Apply();
					if ((int)def.flipped == 0)
					{
						byte[] bytes = ImageConversion.EncodeToPNG(val4);
						IOUtil.EnsureDirectoryExists(Path.Combine(DumpPath, ((Object)collection).name, text));
						File.WriteAllBytes(IOUtil.LongSafe(Path.Combine(DumpPath, ((Object)collection).name, text, def.name + ".png")), bytes);
					}
					else
					{
						DumpRotatedSprite(def, val4, spriteRect, DumpPath, ((Object)collection).name, text);
					}
				}
				finally
				{
					Object.Destroy((Object)(object)val4);
				}
			}
			finally
			{
				if (flag)
				{
					GL.PopMatrix();
				}
				RenderTexture.active = active;
				if ((Object)(object)val3 != (Object)null)
				{
					RenderTexture.ReleaseTemporary(val3);
				}
			}
		}
	}
	[HarmonyPatch]
	public static class SpriteLoader
	{
		private sealed class AtlasExpansionPlan
		{
			public int VanillaWidth;

			public int VanillaHeight;

			public int Width;

			public int Height;

			public readonly Dictionary<string, Rect> AllocatedRects = new Dictionary<string, Rect>();

			public readonly Dictionary<string, Rect> VanillaRects = new Dictionary<string, Rect>();

			public readonly Dictionary<string, string> Anchors = new Dictionary<string, string>();

			public readonly Dictionary<string, (int w, int h)> RepDimensions = new Dictionary<string, (int, int)>();
		}

		internal enum ReplacementSource
		{
			None,
			WorkingFolder,
			Pack
		}

		private static readonly Dictionary<string, HashSet<string>> LoadedAtlases = new Dictionary<string, HashSet<string>>();

		private static readonly Dictionary<string, Dictionary<string, RenderTexture>> LoadedAtlasesTextures = new Dictionary<string, Dictionary<string, RenderTexture>>();

		private static readonly Dictionary<int, (Material mat, RenderTexture rt)> _boundMaterials = new Dictionary<int, (Material, RenderTexture)>();

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

		private static float _nextBindingCheck;

		private static int _rebindHeals;

		private static readonly Dictionary<string, Dictionary<string, HashSet<string>>> LoadedSprites = new Dictionary<string, Dictionary<string, HashSet<string>>>();

		private static readonly Dictionary<int, RenderTexture> _originalTextures = new Dictionary<int, RenderTexture>();

		private static readonly Dictionary<string, string> _instanceKeyToName = new Dictionary<string, string>();

		private static readonly Dictionary<string, int> _nameInstanceCount = new Dictionary<string, int>(StringComparer.Ordinal);

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

		private static readonly Dictionary<int, string> _vanillaTexNames = new Dictionary<int, string>();

		private static readonly Dictionary<int, int> _vanillaCaptureSourceId = new Dictionary<int, int>();

		private static readonly Dictionary<(string collName, int matIndex), RenderTexture> _originalTexturesByColIndex = new Dictionary<(string, int), RenderTexture>();

		private static readonly Dictionary<(string collName, int matIndex), string> _vanillaTexNamesByColIndex = new Dictionary<(string, int), string>();

		private static readonly Dictionary<(int matId, string name), Vector2[]> _originalUVs = new Dictionary<(int, string), Vector2[]>();

		private static readonly Dictionary<(int matId, string name), Vector3[]> _originalPositions = new Dictionary<(int, string), Vector3[]>();

		private static readonly HashSet<tk2dSpriteCollectionData> _collectionsExpandedThisReload = new HashSet<tk2dSpriteCollectionData>();

		private static bool? _copyTextureToRTSupportedCache;

		private static readonly ConditionalWeakTable<tk2dSpriteCollectionData, string> _instanceKeyCache = new ConditionalWeakTable<tk2dSpriteCollectionData, string>();

		private static readonly Dictionary<string, (string FullPath, string Pack)> _spriteFileIndex = new Dictionary<string, (string, string)>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, (string FullPath, string Pack)> _sheetFileIndex = new Dictionary<string, (string, string)>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, string> _spriteAnchors = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		private static bool _anchorsTxtWarned;

		private const int NativeDrawGraceTexels = 5;

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

		private static bool _fileIndexBuilt;

		private static int _loadedSpriteCount;

		private static int _spriteDefsWalked;

		private static int _rotatedReplacements;

		private static readonly HashSet<tk2dSpriteCollectionData> _collectionsRevertedThisReload = new HashSet<tk2dSpriteCollectionData>();

		private static readonly Dictionary<string, int> _perCollectionReplacements = new Dictionary<string, int>();

		private static int _reloadGen;

		private static bool _rerunRequested;

		private const long SliceBudgetMs = 12L;

		public static string LoadPath => Path.Combine(Plugin.BasePath, "Sprites");

		public static string AtlasLoadPath => Path.Combine(Plugin.BasePath, "Spritesheets");

		private static bool _copyTextureToRTSupported
		{
			get
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Invalid comparison between Unknown and I4
				if (Plugin.Config != null && Plugin.Config.DisableCopyTextureFastPath)
				{
					return false;
				}
				if (_copyTextureToRTSupportedCache.HasValue)
				{
					return _copyTextureToRTSupportedCache.Value;
				}
				bool flag = (SystemInfo.copyTextureSupport & 8) > 0;
				_copyTextureToRTSupportedCache = flag;
				Plugin.Logger.LogInfo((object)($"[SpriteLoader] CopyTextureSupport.TextureToRT = {flag}" + (flag ? "" : " — falling back to Graphics.DrawTexture for atlas blits")));
				return flag;
			}
		}

		public static int LoadedCollectionCount => LoadedAtlases.Count;

		public static int LoadedSpriteCount => _loadedSpriteCount;

		public static long AtlasVramBytes
		{
			get
			{
				long num = 0L;
				foreach (Dictionary<string, RenderTexture> value in LoadedAtlasesTextures.Values)
				{
					foreach (RenderTexture value2 in value.Values)
					{
						if ((Object)(object)value2 != (Object)null)
						{
							num += (long)((Texture)value2).width * (long)((Texture)value2).height * 4;
						}
					}
				}
				foreach (RenderTexture value3 in _originalTextures.Values)
				{
					if ((Object)(object)value3 != (Object)null)
					{
						num += (long)((Texture)value3).width * (long)((Texture)value3).height * 4;
					}
				}
				return num;
			}
		}

		public static int AtlasRTCount
		{
			get
			{
				int num = _originalTextures.Count;
				foreach (Dictionary<string, RenderTexture> value in LoadedAtlasesTextures.Values)
				{
					num += value.Count;
				}
				return num;
			}
		}

		internal static int FileIndexVersion { get; private set; }

		public static bool IsReloadingSliced { get; private set; }

		public static int SlicedTotal { get; private set; }

		public static int SlicedProcessed { get; private set; }

		public static string SlicedCurrent { get; private set; } = "";

		public static float SlicedStartedAt { get; private set; }

		private static void RegisterBinding(Material mat, RenderTexture rt)
		{
			_boundMaterials[((Object)mat).GetInstanceID()] = (mat, rt);
		}

		private static void UnregisterBinding(Material mat)
		{
			_boundMaterials.Remove(((Object)mat).GetInstanceID());
		}

		internal static void TickBindingWatchdog()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextBindingCheck)
			{
				return;
			}
			_nextBindingCheck = realtimeSinceStartup + 1f;
			if (SceneTraverser.IsTraversing)
			{
				return;
			}
			List<int> list = null;
			foreach (KeyValuePair<int, (Material, RenderTexture)> boundMaterial in _boundMaterials)
			{
				var (val, val2) = boundMaterial.Value;
				if ((Object)(object)val == (Object)null)
				{
					(list ?? (list = new List<int>())).Add(boundMaterial.Key);
					continue;
				}
				Texture mainTexture = val.mainTexture;
				if ((object)mainTexture != val2)
				{
					string text = (((Object)(object)mainTexture == (Object)null) ? "(null)" : $"'{((Object)mainTexture).name}' ({((object)mainTexture).GetType().Name} {mainTexture.width}x{mainTexture.height})");
					_rebindHeals++;
					string text2 = "[SpriteLoader] Atlas binding hijacked on material '" + ((Object)val).name + "': now " + text + " " + $"— re-pointing to the composite RT (heal #{_rebindHeals}). An external mod rebound this material.";
					if (_rebindWarned.Add(boundMaterial.Key))
					{
						Plugin.Logger.LogWarning((object)text2);
					}
					else
					{
						Plugin.Logger.LogDebug((object)text2);
					}
					val.mainTexture = (Texture)(object)val2;
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (int item in list)
			{
				_boundMaterials.Remove(item);
			}
		}

		private static string InstanceKey(tk2dSpriteCollectionData coll)
		{
			if (_instanceKeyCache.TryGetValue(coll, out var value))
			{
				return value;
			}
			string text = ((Object)coll).name + "\0" + ((Object)coll).GetInstanceID();
			_instanceKeyCache.Add(coll, text);
			return text;
		}

		public static bool TryGetVanilla(tk2dSpriteCollectionData coll, tk2dSpriteDefinition def, out Texture atlas, out Vector2[] uvs, out Vector3[] positions)
		{
			atlas = null;
			uvs = def.uvs;
			positions = def.positions;
			if ((Object)(object)coll == (Object)null || coll.materials == null || def.materialId < 0 || def.materialId >= coll.materials.Length)
			{
				return false;
			}
			Material val = coll.materials[def.materialId];
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)val).GetInstanceID();
			if (!_originalTextures.TryGetValue(instanceID, out var value) || !((Object)(object)value != (Object)null) || !value.IsCreated())
			{
				_originalTexturesByColIndex.TryGetValue((((Object)coll).name, def.materialId), out value);
			}
			if ((Object)(object)value == (Object)null || !value.IsCreated())
			{
				return false;
			}
			atlas = (Texture)(object)value;
			(int, string) key = (instanceID, def.name);
			if (_originalUVs.TryGetValue(key, out var value2) && value2 != null)
			{
				uvs = value2;
			}
			if (_originalPositions.TryGetValue(key, out var value3) && value3 != null)
			{
				positions = value3;
			}
			return true;
		}

		public static void ApplyPatches(Harmony harmony)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Method(typeof(tk2dSpriteCollectionData), "Init", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SpriteLoader), "InitPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void InitPostfix(tk2dSpriteCollectionData __instance)
		{
			LoadCollection(__instance);
		}

		public static void LoadCollection(tk2dSpriteCollectionData collection)
		{
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Expected O, but got Unknown
			//IL_08fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0916: Unknown result type (might be due to invalid IL or missing references)
			//IL_091b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0943: Unknown result type (might be due to invalid IL or missing references)
			//IL_094e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0953: Unknown result type (might be due to invalid IL or missing references)
			//IL_0955: Unknown result type (might be due to invalid IL or missing references)
			//IL_095a: Unknown result type (might be due to invalid IL or missing references)
			//IL_095c: Unknown result type (might be due to invalid IL or missing references)
			//IL_095e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0962: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09da: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0623: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_0630: Unknown result type (might be due to invalid IL or missing references)
			//IL_063a: Expected O, but got Unknown
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_071f: Unknown result type (might be due to invalid IL or missing references)
			if (ArchitectBridge.ShouldSuppressLoadCollection())
			{
				return;
			}
			if (!_fileIndexBuilt)
			{
				RebuildFileIndex();
			}
			string key = InstanceKey(collection);
			bool num = !_instanceKeyToName.ContainsKey(key);
			_instanceKeyToName[key] = ((Object)collection).name;
			if (num)
			{
				_nameInstanceCount[((Object)collection).name] = _nameInstanceCount.GetValueOrDefault(((Object)collection).name) + 1;
			}
			bool flag = _nameInstanceCount.GetValueOrDefault(((Object)collection).name) > 1 && _collectionsWithFiles.Contains(((Object)collection).name) && _duplicateNameWarned.Add(((Object)collection).name);
			if (flag)
			{
				Plugin.Logger.LogWarning((object)("[SpriteLoader] Duplicate collection name '" + ((Object)collection).name + "' " + $"(instanceId {((Object)collection).GetInstanceID()}). " + "Use the vanilla texture name as the folder/file name to target this instance specifically: Sprites/" + ((Object)collection).name + "/{texName}/... or Spritesheets/" + ((Object)collection).name + "/{texName}.png  (texture names logged per material below when vanilla is first captured)."));
			}
			bool flag2 = false;
			Material[] materials = collection.materials;
			foreach (Material val in materials)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string name = ((Object)val).name;
				string text = ((Object)val).name.Split(' ')[0];
				int instanceID = ((Object)val).GetInstanceID();
				bool num2 = !_collectionsWithFiles.Contains(((Object)collection).name);
				int num3 = Array.IndexOf(collection.materials, val);
				if (!num2 && !(val.mainTexture is RenderTexture) && (Object)(object)val.mainTexture != (Object)null)
				{
					int instanceID2 = ((Object)val.mainTexture).GetInstanceID();
					if (!_vanillaCaptureSourceId.TryGetValue(instanceID, out var value) || value != instanceID2 || !_originalTextures.ContainsKey(instanceID))
					{
						if (_originalTextures.TryGetValue(instanceID, out var value2) && (Object)(object)value2 != (Object)null && ((Texture)value2).width == val.mainTexture.width && ((Texture)value2).height == val.mainTexture.height)
						{
							Graphics.Blit(val.mainTexture, value2);
						}
						else
						{
							if ((Object)(object)value2 != (Object)null)
							{
								value2.Release();
								Object.Destroy((Object)(object)value2);
							}
							RenderTexture val2 = new RenderTexture(val.mainTexture.width, val.mainTexture.height, 0, (RenderTextureFormat)0, TexUtil.ReadWriteForSource(val.mainTexture))
							{
								hideFlags = (HideFlags)32,
								name = name + "_vanilla"
							};
							Graphics.Blit(val.mainTexture, val2);
							_originalTextures[instanceID] = val2;
						}
						string name2 = ((Object)val.mainTexture).name;
						_vanillaTexNames[instanceID] = name2;
						if (num3 >= 0)
						{
							_originalTexturesByColIndex[(((Object)collection).name, num3)] = _originalTextures[instanceID];
							_vanillaTexNamesByColIndex[(((Object)collection).name, num3)] = name2;
						}
						if (flag)
						{
							Plugin.Logger.LogWarning((object)("[SpriteLoader]   mat '" + text + "' → vanilla texture '" + name2 + "'"));
						}
						_vanillaCaptureSourceId[instanceID] = instanceID2;
					}
				}
				if (!_originalTextures.TryGetValue(instanceID, out var value3) || (Object)(object)value3 == (Object)null)
				{
					(string, int) key2 = (((Object)collection).name, num3);
					if (num3 < 0 || !_originalTexturesByColIndex.TryGetValue(key2, out value3) || !((Object)(object)value3 != (Object)null) || !value3.IsCreated())
					{
						continue;
					}
					_originalTextures[instanceID] = value3;
					if (_vanillaTexNamesByColIndex.TryGetValue(key2, out var value4))
					{
						_vanillaTexNames[instanceID] = value4;
					}
				}
				else
				{
					(string, int) key3 = (((Object)collection).name, num3);
					if (num3 >= 0 && _originalTexturesByColIndex.TryGetValue(key3, out var value5) && (Object)(object)value5 != (Object)null && (Object)(object)value5 != (Object)(object)value3 && value5.IsCreated())
					{
						_originalTextures[instanceID] = value5;
						value3 = value5;
						if (_vanillaTexNamesByColIndex.TryGetValue(key3, out var value6))
						{
							_vanillaTexNames[instanceID] = value6;
						}
					}
				}
				if (!_collectionsWithFiles.Contains(((Object)collection).name))
				{
					if (RestoreVanillaDefsForMat(collection, instanceID, num3))
					{
						_collectionsRevertedThisReload.Add(collection);
					}
					if (LoadedAtlasesTextures.TryGetValue(key, out var value7) && value7.TryGetValue(name, out var value8) && (Object)(object)value8 != (Object)null)
					{
						if (((Texture)value8).width != ((Texture)value3).width || ((Texture)value8).height != ((Texture)value3).height)
						{
							value8.Release();
							((Texture)value8).width = ((Texture)value3).width;
							((Texture)value8).height = ((Texture)value3).height;
							value8.Create();
						}
						Graphics.Blit((Texture)(object)value3, value8);
						val.mainTexture = (Texture)(object)value8;
						RegisterBinding(val, value8);
					}
					else
					{
						val.mainTexture = (Texture)(object)value3;
						UnregisterBinding(val);
					}
					continue;
				}
				if (!LoadedAtlases.TryGetValue(key, out var value9))
				{
					value9 = (LoadedAtlases[key] = new HashSet<string>());
				}
				Dictionary<string, RenderTexture> value12;
				RenderTexture value13;
				if (value9.Add(name))
				{
					if (RestoreVanillaDefsForMat(collection, instanceID, num3))
					{
						_collectionsRevertedThisReload.Add(collection);
					}
					AtlasExpansionPlan atlasExpansionPlan = ((num3 >= 0) ? PlanExpansion(collection, num3, instanceID, text, value3) : null);
					Texture2D val3 = FindSpritesheetTex(collection, instanceID, text);
					Texture val4 = (Texture)(((Object)(object)val3 != (Object)null) ? ((object)val3) : ((object)value3));
					if ((Object)(object)val3 != (Object)null)
					{
						flag2 = true;
					}
					int num4 = atlasExpansionPlan?.Width ?? val4.width;
					int num5 = atlasExpansionPlan?.Height ?? val4.height;
					if (!LoadedAtlasesTextures.TryGetValue(key, out var value10))
					{
						value10 = (LoadedAtlasesTextures[key] = new Dictionary<string, RenderTexture>());
					}
					if (!value10.TryGetValue(name, out var value11) || (Object)(object)value11 == (Object)null)
					{
						RenderTexture val5 = new RenderTexture(num4, num5, 0, (RenderTextureFormat)0, TexUtil.ReadWriteForSource(val4))
						{
							hideFlags = (HideFlags)32,
							name = name
						};
						value11 = (value10[name] = val5);
					}
					else if (((Texture)value11).width != num4 || ((Texture)value11).height != num5)
					{
						value11.Release();
						((Texture)value11).width = num4;
						((Texture)value11).height = num5;
						value11.Create();
					}
					if (atlasExpansionPlan != null)
					{
						RenderTexture active = RenderTexture.active;
						RenderTexture.active = value11;
						GL.Clear(false, true, Color.clear);
						RenderTexture.active = active;
						if (_copyTextureToRTSupported)
						{
							Graphics.CopyTexture(val4, 0, 0, 0, 0, val4.width, val4.height, (Texture)(object)value11, 0, 0, 0, 0);
						}
						else
						{
							RenderTexture active2 = RenderTexture.active;
							RenderTexture.active = value11;
							GL.PushMatrix();
							GL.LoadPixelMatrix(0f, (float)((Texture)value11).width, (float)((Texture)value11).height, 0f);
							Graphics.DrawTexture(new Rect(0f, (float)(((Texture)value11).height - val4.height), (float)val4.width, (float)val4.height), val4);
							GL.PopMatrix();
							RenderTexture.active = active2;
						}
					}
					else
					{
						Graphics.Blit(val4, value11);
					}
					if ((Object)(object)val3 != (Object)null)
					{
						Object.Destroy((Object)(object)val3);
					}
					if (atlasExpansionPlan != null)
					{
						ApplyExpansionPlan(collection, atlasExpansionPlan, instanceID, num3, ((Texture)value11).width, ((Texture)value11).height);
						_collectionsExpandedThisReload.Add(collection);
					}
					val.mainTexture = (Texture)(object)value11;
					RegisterBinding(val, value11);
				}
				else if (LoadedAtlasesTextures.TryGetValue(key, out value12) && value12.TryGetValue(name, out value13))
				{
					val.mainTexture = (Texture)(object)value13;
					RegisterBinding(val, value13);
				}
				RenderTexture active3 = RenderTexture.active;
				Texture mainTexture = val.mainTexture;
				RenderTexture.active = (RenderTexture)(object)((mainTexture is RenderTexture) ? mainTexture : null);
				GL.PushMatrix();
				GL.LoadPixelMatrix(0f, (float)val.mainTexture.width, (float)val.mainTexture.height, 0f);
				if (num3 >= 0)
				{
					tk2dSpriteDefinition[] spriteDefinitions = collection.spriteDefinitions;
					foreach (tk2dSpriteDefinition val7 in spriteDefinitions)
					{
						if (val7.materialId != num3 || string.IsNullOrEmpty(val7.name))
						{
							continue;
						}
						if (!LoadedSprites.TryGetValue(key, out var value14))
						{
							value14 = (LoadedSprites[key] = new Dictionary<string, HashSet<string>>());
						}
						if (!value14.TryGetValue(name, out var value15))
						{
							value15 = (value14[name] = new HashSet<string>());
						}
						if (!value15.Add(val7.name))
						{
							continue;
						}
						_spriteDefsWalked++;
						Texture2D val8 = FindSprite(((Object)collection).name, instanceID, text, val7.name);
						if ((Object)(object)val8 == (Object)null)
						{
							continue;
						}
						_loadedSpriteCount++;
						_perCollectionReplacements.TryGetValue(((Object)collection).name, out var value16);
						_perCollectionReplacements[((Object)collection).name] = value16 + 1;
						if ((int)val7.flipped != 0)
						{
							_rotatedReplacements++;
						}
						Rect spriteRect = SpriteUtil.GetSpriteRect(val7, val.mainTexture);
						((Rect)(ref spriteRect)).y = (float)val.mainTexture.height - ((Rect)(ref spriteRect)).y - ((Rect)(ref spriteRect)).height;
						(Vector2 uBasis, Vector2 vBasis) tuple = SpriteUtil.CompositeBasisFor(val7.flipped);
						Vector2 item = tuple.uBasis;
						Vector2 item2 = tuple.vBasis;
						Rect dest = spriteRect;
						if ((int)val7.flipped == 0)
						{
							int num6 = (int)((Rect)(ref spriteRect)).width - ((Texture)val8).width;
							int num7 = (int)((Rect)(ref spriteRect)).height - ((Texture)val8).height;
							if ((num6 > 0 || num7 > 0) && num6 >= 0 && num7 >= 0 && num6 <= 5 && num7 <= 5)
							{
								((Rect)(ref dest))..ctor(((Rect)(ref spriteRect)).x, ((Rect)(ref spriteRect)).y + (float)num7, (float)((Texture)val8).width, (float)((Texture)val8).height);
							}
						}
						TexUtil.DrawRotated(dest, (Texture)(object)val8, item, item2);
						Object.Destroy((Object)(object)val8);
					}
				}
				val.mainTexture.IncrementUpdateCount();
				GL.PopMatrix();
				RenderTexture.active = active3;
			}
			if (flag2 && Plugin.Config.ConvertSpritesheets)
			{
				SpriteDumper.DumpCollection(collection, convert: true);
			}
		}

		internal static List<(string Coll, string Mat, RenderTexture Live, RenderTexture Vanilla)> GetCompositePairsForDiagnostics()
		{
			List<(string, string, RenderTexture, RenderTexture)> list = new List<(string, string, RenderTexture, RenderTexture)>();
			HashSet<int> hashSet = new HashSet<int>();
			tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val in array)
			{
				if ((Object)(object)val == (Object)null || val.materials == null || (((Object)val).name != null && ((Object)val).name.StartsWith("Stitchwork_Shadow")))
				{
					continue;
				}
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						Texture mainTexture = val2.mainTexture;
						RenderTexture val3 = (RenderTexture)(object)((mainTexture is RenderTexture) ? mainTexture : null);
						if (val3 != null && hashSet.Add(((Object)val3).GetInstanceID()) && _originalTextures.TryGetValue(((Object)val2).GetInstanceID(), out var value) && (Object)(object)value != (Object)null && value.IsCreated())
						{
							list.Add((((Object)val).name, ((Object)val2).name.Split(' ')[0], val3, value));
						}
					}
				}
			}
			return list;
		}

		internal static List<(tk2dSpriteCollectionData Coll, Material Mat, int MatIndex, RenderTexture Live, RenderTexture Vanilla, string VanillaTexName)> GetAtlasExportTargets()
		{
			List<(tk2dSpriteCollectionData, Material, int, RenderTexture, RenderTexture, string)> list = new List<(tk2dSpriteCollectionData, Material, int, RenderTexture, RenderTexture, string)>();
			HashSet<int> hashSet = new HashSet<int>();
			tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val in array)
			{
				if ((Object)(object)val == (Object)null || val.materials == null || (((Object)val).name != null && ((Object)val).name.StartsWith("Stitchwork_Shadow")))
				{
					continue;
				}
				for (int j = 0; j < val.materials.Length; j++)
				{
					Material val2 = val.materials[j];
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					Texture mainTexture = val2.mainTexture;
					RenderTexture val3 = (RenderTexture)(object)((mainTexture is RenderTexture) ? mainTexture : null);
					if (val3 != null && hashSet.Add(((Object)val3).GetInstanceID()))
					{
						int instanceID = ((Object)val2).GetInstanceID();
						if (_originalTextures.TryGetValue(instanceID, out var value) && (Object)(object)value != (Object)null && value.IsCreated())
						{
							_vanillaTexNames.TryGetValue(instanceID, out var value2);
							list.Add((val, val2, j, val3, value, string.IsNullOrEmpty(value2) ? ((Object)val2).name.Split(' ')[0] : value2));
						}
					}
				}
			}
			return list;
		}

		internal static string FindWorkspaceSpriteFile(tk2dSpriteCollectionData coll, tk2dSpriteDefinition def)
		{
			if ((Object)(object)coll == (Object)null || def == null || string.IsNullOrEmpty(def.name))
			{
				return null;
			}
			Material val = (((Object)(object)def.materialInst != (Object)null) ? def.materialInst : def.material);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (_vanillaTexNames.TryGetValue(((Object)val).GetInstanceID(), out var value) && !string.IsNullOrEmpty(value))
			{
				string text = Path.Combine(LoadPath, ((Object)coll).name, value, def.name + ".png");
				if (File.Exists(text))
				{
					return text;
				}
			}
			string text2 = Path.Combine(LoadPath, ((Object)coll).name, ((Object)val).name.Split(' ')[0], def.name + ".png");
			if (!File.Exists(text2))
			{
				return null;
			}
			return text2;
		}

		internal static bool HasSheetReplacement(string collectionName, int matId, string matnameAbbr)
		{
			if (!_fileIndexBuilt)
			{
				RebuildFileIndex();
			}
			if (_vanillaTexNames.TryGetValue(matId, out var value) && !string.IsNullOrEmpty(value) && _sheetFileIndex.ContainsKey(collectionName + "/" + value + ".png"))
			{
				return true;
			}
			return _sheetFileIndex.ContainsKey(collectionName + "/" + matnameAbbr + ".png");
		}

		private static void RebuildFileIndex()
		{
			ConflictTracker.ClearTypes("sprite", "sheet", "clip");
			_spriteFileIndex.Clear();
			_sheetFileIndex.Clear();
			_spriteAnchors.Clear();
			AppliqueLoader.ClearIndex();
			_fileIndexBuilt = true;
			FileIndexVersion++;
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				IndexDir(Path.Combine(pluginPackPath, "Sprites"), pluginPackPath, _spriteFileIndex, "sprite");
			}
			IndexDir(LoadPath, null, _spriteFileIndex, "sprite");
			foreach (string pluginPackPath2 in Plugin.PluginPackPaths)
			{
				IndexDir(PackLayout.SheetsRoot(pluginPackPath2), pluginPackPath2, _sheetFileIndex, "sheet");
			}
			IndexDir(AtlasLoadPath, null, _sheetFileIndex, "sheet");
			if (!_anchorsTxtWarned)
			{
				WarnIfLegacyAnchorsPresent();
			}
			_collectionsWithFiles.Clear();
			foreach (string key in _spriteFileIndex.Keys)
			{
				int num = key.IndexOf('/');
				if (num > 0)
				{
					_collectionsWithFiles.Add(key.Substring(0, num));
				}
			}
			foreach (string key2 in _sheetFileIndex.Keys)
			{
				int num2 = key2.IndexOf('/');
				if (num2 > 0)
				{
					_collectionsWithFiles.Add(key2.Substring(0, num2));
				}
			}
			int indexCount = AppliqueLoader.IndexCount;
			int indexPackCount = AppliqueLoader.IndexPackCount;
			Plugin.Logger.LogInfo((object)($"[SpriteLoader] Index rebuilt: {_spriteFileIndex.Count} sprite file(s), " + $"{_sheetFileIndex.Count} sheet file(s), {_collectionsWithFiles.Count} collection(s) with files, " + $"{indexCount} clip override(s) ({indexPackCount} from pack(s), {indexCount - indexPackCount} from root)."));
			static void IndexDir(string root, string sourcePack, Dictionary<string, (string, string)> index, string conflictType)
			{
				if (Directory.Exists(root))
				{
					string[] files = Directory.GetFiles(root, "*.png", SearchOption.AllDirectories);
					Array.Sort(files, (IComparer<string>?)StringComparer.OrdinalIgnoreCase);
					string[] array = files;
					foreach (string text in array)
					{
						string text2 = text.Substring(root.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).Replace('\\', '/');
						if (string.IsNullOrEmpty(Path.GetFileNameWithoutExtension(text)))
						{
							Plugin.Logger.LogWarning((object)("[SpriteLoader] Ignoring '" + text2 + "' — file has no name."));
						}
						else if ((!(conflictType == "sheet") || sourcePack == null || !text2.StartsWith("Texture2D/", StringComparison.OrdinalIgnoreCase) || !PackLayout.IsCustomizerPack(sourcePack)) && text2.IndexOf("_WIP/", StringComparison.OrdinalIgnoreCase) < 0 && !text2.StartsWith("T2D/", StringComparison.OrdinalIgnoreCase) && text2.IndexOf('/') >= 0)
						{
							if (conflictType == "sprite")
							{
								int num3 = text2.IndexOf('/');
								if (num3 > 0)
								{
									int num4 = text2.IndexOf('/', num3 + 1);
									if (num4 > num3 && string.Compare(text2, num3 + 1, "Clips", 0, num4 - num3 - 1, StringComparison.OrdinalIgnoreCase) == 0 && num4 - num3 - 1 == 5)
									{
										AppliqueLoader.IndexFile(text2, text, sourcePack);
										continue;
									}
								}
							}
							string text3 = null;
							if (conflictType == "sprite")
							{
								int num5 = text2.LastIndexOf('/');
								string obj = ((num5 >= 0) ? text2.Substring(0, num5 + 1) : "");
								string text4 = ((num5 >= 0) ? text2.Substring(num5 + 1) : text2);
								(string name, string anchor) tuple = IOUtil.ParseAnchorTag(text4.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ? text4.Substring(0, text4.Length - 4) : text4);
								string item = tuple.name;
								text3 = tuple.anchor;
								text2 = obj + item + ".png";
							}
							if (index.TryGetValue(text2, out var value))
							{
								if (!IOUtil.BenignDuplicate(value.Item1, text))
								{
									ConflictTracker.Record(conflictType, ConflictKey(conflictType, text2), value.Item2, sourcePack, Path.GetFileName(value.Item1) + " › " + Path.GetFileName(text), value.Item1, text);
								}
							}
							else
							{
								index[text2] = (text, sourcePack);
								if (text3 != null)
								{
									_spriteAnchors[text2] = text3;
								}
							}
						}
					}
				}
			}
		}

		private static string ConflictKey(string type, string rel)
		{
			string text = (rel.EndsWith(".png") ? rel.Substring(0, rel.Length - 4) : rel);
			string[] array = text.Split('/');
			if (!(type == "sprite") || array.Length < 3)
			{
				return type + ":" + text;
			}
			return "sprite:" + array[0] + "/" + array[2];
		}

		private static string FindSpritePath(string collectionName, int matId, string matnameAbbr, string spriteName)
		{
			if (!_fileIndexBuilt)
			{
				RebuildFileIndex();
			}
			if (_vanillaTexNames.TryGetValue(matId, out var value) && !string.IsNullOrEmpty(value))
			{
				string key = collectionName + "/" + value + "/" + spriteName + ".png";
				if (_spriteFileIndex.TryGetValue(key, out (string, string) value2))
				{
					return value2.Item1;
				}
			}
			string key2 = collectionName + "/" + matnameAbbr + "/" + spriteName + ".png";
			if (!_spriteFileIndex.TryGetValue(key2, out (string, string) value3))
			{
				return null;
			}
			return value3.Item1;
		}

		internal static bool HasSpriteReplacement(tk2dSpriteCollectionData coll, tk2dSpriteDefinition def)
		{
			if ((Object)(object)coll == (Object)null || def == null || string.IsNullOrEmpty(def.name))
			{
				return false;
			}
			Material val = null;
			if (coll.materials != null && def.materialId >= 0 && def.materialId < coll.materials.Length)
			{
				val = coll.materials[def.materialId];
			}
			if ((Object)(object)val == (Object)null)
			{
				val = def.material;
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			return FindSpritePath(((Object)coll).name, ((Object)val).GetInstanceID(), ((Object)val).name.Split(' ')[0], def.name) != null;
		}

		internal static ReplacementSource GetSpriteProvenance(tk2dSpriteCollectionData coll, tk2dSpriteDefinition def)
		{
			if ((Object)(object)coll == (Object)null || def == null || string.IsNullOrEmpty(def.name))
			{
				return ReplacementSource.None;
			}
			Material val = null;
			if (coll.materials != null && def.materialId >= 0 && def.materialId < coll.materials.Length)
			{
				val = coll.materials[def.materialId];
			}
			if ((Object)(object)val == (Object)null)
			{
				val = def.material;
			}
			if ((Object)(object)val == (Object)null)
			{
				return ReplacementSource.None;
			}
			if (!_fileIndexBuilt)
			{
				RebuildFileIndex();
			}
			int instanceID = ((Object)val).GetInstanceID();
			if (_vanillaTexNames.TryGetValue(instanceID, out var value) && !string.IsNullOrEmpty(value))
			{
				string key = ((Object)coll).name + "/" + value + "/" + def.name + ".png";
				if (_spriteFileIndex.TryGetValue(key, out (string, string) value2))
				{
					if (value2.Item2 == null)
					{
						return ReplacementSource.WorkingFolder;
					}
					return ReplacementSource.Pack;
				}
			}
			string key2 = ((Object)coll).name + "/" + ((Object)val).name.Split(' ')[0] + "/" + def.name + ".png";
			if (_spriteFileIndex.TryGetValue(key2, out (string, string) value3))
			{
				if (value3.Item2 == null)
				{
					return ReplacementSource.WorkingFolder;
				}
				return ReplacementSource.Pack;
			}
			return ReplacementSource.None;
		}

		private static string FindSpriteAnchor(string collectionName, int matId, string matnameAbbr, string spriteName)
		{
			if (!_fileIndexBuilt)
			{
				RebuildFileIndex();
			}
			if (_vanillaTexNames.TryGetValue(matId, out var value) && !string.IsNullOrEmpty(value))
			{
				string key = collectionName + "/" + value + "/" + spriteName + ".png";
				if (_spriteFileIndex.ContainsKey(key))
				{
					if (!_spriteAnchors.TryGetValue(key, out var value2))
					{
						return null;
					}
					return value2;
				}
			}
			string key2 = collectionName + "/" + matnameAbbr + "/" + spriteName + ".png";
			if (_spriteFileIndex.ContainsKey(key2))
			{
				if (!_spriteAnchors.TryGetValue(key2, out var value3))
				{
					return null;
				}
				return value3;
			}
			return null;
		}

		private static void WarnIfLegacyAnchorsPresent()
		{
			bool found = false;
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				Scan(Path.Combine(pluginPackPath, "Sprites"));
			}
			Scan(LoadPath);
			if (found)
			{
				_anchorsTxtWarned = true;
				Plugin.Logger.LogWarning((object)"[SpriteLoader] A legacy anchors.txt was found but is NO LONGER read. Anchors are now filename tags: name@t / @l / @r / @c (omit for bottom-center). Corners are no longer supported — pick an edge. Re-tag the affected PNGs.");
			}
			void Scan(string root)
			{
				if (!found && !string.IsNullOrEmpty(root) && Directory.Exists(root) && Directory.GetFiles(root, "anchors.txt", SearchOption.AllDirectories).Length != 0)
				{
					found = true;
				}
			}
		}

		private static Texture2D FindSprite(string collectionName, int matId, string matnameAbbr, string spriteName)
		{
			string text = FindSpritePath(collectionName, matId, matnameAbbr, spriteName);
			if (text == null)
			{
				return null;
			}
			return TexUtil.LoadFromPNG(text);
		}

		internal static Texture2D FindSpritesheetTex(tk2dSpriteCollectionData collection, int matId, string matnameAbbr)
		{
			if (!_fileIndexBuilt)
			{
				RebuildFileIndex();
			}
			string text = null;
			if (_vanillaTexNames.TryGetValue(matId, out var value) && !string.IsNullOrEmpty(value))
			{
				text = ((Object)collection).name + "/" + value + ".png";
				if (_sheetFileIndex.TryGetValue(text, out (string, string) value2))
				{
					Log.Verbose("[SpriteLoader] Sheet hit (instance-specific): " + text + " ← " + (value2.Item2 ?? "<root>"));
					return TexUtil.LoadFromPNG(value2.Item1);
				}
			}
			string text2 = ((Object)collection).name + "/" + matnameAbbr + ".png";
			if (_sheetFileIndex.TryGetValue(text2, out (string, string) value3))
			{
				Log.Verbose("[SpriteLoader] Sheet hit: " + text2 + " ← " + (value3.Item2 ?? "<root>"));
				return TexUtil.LoadFromPNG(value3.Item1);
			}
			Log.Verbose("[SpriteLoader] Sheet miss: tried '" + (text ?? "(no vanilla-tex key)") + "' " + $"and '{text2}' — {_sheetFileIndex.Count} sheet file(s) indexed");
			return null;
		}

		private static AtlasExpansionPlan PlanExpansion(tk2dSpriteCollectionData collection, int matIndex, int matId, string matnameAbbr, RenderTexture vanillaTex)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Invalid comparison between Unknown and I4
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			int width = ((Texture)vanillaTex).width;
			int height = ((Texture)vanillaTex).height;
			int num = width;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			AtlasExpansionPlan atlasExpansionPlan = null;
			tk2dSpriteDefinition[] spriteDefinitions = collection.spriteDefinitions;
			Rect value = default(Rect);
			foreach (tk2dSpriteDefinition val in spriteDefinitions)
			{
				if (val.materialId != matIndex || string.IsNullOrEmpty(val.name))
				{
					continue;
				}
				string text = FindSpritePath(((Object)collection).name, matId, matnameAbbr, val.name);
				if (text == null)
				{
					continue;
				}
				var (num5, num6) = IOUtil.ReadPngDimensions(text);
				if (num5 <= 0 || num6 <= 0)
				{
					continue;
				}
				Rect spriteRect = SpriteUtil.GetSpriteRect(val, (Texture)(object)vanillaTex);
				bool flag = (int)val.flipped > 0;
				int num7 = (flag ? ((int)((Rect)(ref spriteRect)).height) : ((int)((Rect)(ref spriteRect)).width));
				int num8 = (flag ? ((int)((Rect)(ref spriteRect)).width) : ((int)((Rect)(ref spriteRect)).height));
				if (num5 > num7 || num6 > num8)
				{
					if (atlasExpansionPlan == null)
					{
						atlasExpansionPlan = new AtlasExpansionPlan();
					}
					string text2 = FindSpriteAnchor(((Object)collection).name, matId, matnameAbbr, val.name) ?? "bottom-center";
					int num9 = (flag ? num6 : num5);
					int num10 = (flag ? num5 : num6);
					if (num9 > num)
					{
						num = num9;
					}
					if (num2 + num9 > num)
					{
						num4 += num3;
						num2 = 0;
						num3 = 0;
					}
					((Rect)(ref value))..ctor((float)num2, (float)(height + num4), (float)num9, (float)num10);
					num2 += num9;
					num3 = Math.Max(num3, num10);
					atlasExpansionPlan.AllocatedRects[val.name] = value;
					atlasExpansionPlan.VanillaRects[val.name] = spriteRect;
					atlasExpansionPlan.Anchors[val.name] = text2;
					atlasExpansionPlan.RepDimensions[val.name] = (num5, num6);
					Log.Verbose("[SpriteLoader] Expand: " + ((Object)collection).name + "/" + matnameAbbr + "/" + val.name + "  " + $"{(int)((Rect)(ref spriteRect)).width}×{(int)((Rect)(ref spriteRect)).height} → {num5}×{num6}  " + $"anchor={text2}  slot=({(int)((Rect)(ref value)).x},{(int)((Rect)(ref value)).y})");
				}
			}
			if (atlasExpansionPlan != null)
			{
				num4 += num3;
				atlasExpansionPlan.VanillaWidth = width;
				atlasExpansionPlan.VanillaHeight = height;
				atlasExpansionPlan.Width = num;
				atlasExpansionPlan.Height = height + num4;
			}
			return atlasExpansionPlan;
		}

		private static void ApplyExpansionPlan(tk2dSpriteCollectionData collection, AtlasExpansionPlan plan, int matId, int matIndex, int newW, int newH)
		{
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Invalid comparison between Unknown and I4
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0745: Unknown result type (might be due to invalid IL or missing references)
			//IL_074a: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)plan.VanillaHeight / (float)newH;
			float num2 = (float)plan.VanillaWidth / (float)newW;
			tk2dSpriteDefinition[] spriteDefinitions = collection.spriteDefinitions;
			foreach (tk2dSpriteDefinition val in spriteDefinitions)
			{
				if (val.materialId != matIndex || string.IsNullOrEmpty(val.name))
				{
					continue;
				}
				(int, string) key = (matId, val.name);
				bool flag = plan.AllocatedRects.ContainsKey(val.name);
				if (val.uvs != null && !_originalUVs.ContainsKey(key))
				{
					tk2dSpriteDefinition[] spriteDefinitions2 = collection.spriteDefinitions;
					foreach (tk2dSpriteDefinition val2 in spriteDefinitions2)
					{
						if (val2 != val && val2.uvs == val.uvs)
						{
							val.uvs = (Vector2[])val.uvs.Clone();
							break;
						}
					}
					_originalUVs[key] = (Vector2[])val.uvs.Clone();
				}
				if (val.uvs != null && _originalUVs.TryGetValue(key, out var value))
				{
					Rect value2;
					if (!flag)
					{
						for (int k = 0; k < val.uvs.Length && k < value.Length; k++)
						{
							val.uvs[k] = new Vector2(value[k].x * num2, value[k].y * num);
						}
					}
					else if (plan.AllocatedRects.TryGetValue(val.name, out value2))
					{
						float num3 = float.MaxValue;
						float num4 = float.MinValue;
						float num5 = float.MaxValue;
						float num6 = float.MinValue;
						Vector2[] array = value;
						foreach (Vector2 val3 in array)
						{
							if (val3.x < num3)
							{
								num3 = val3.x;
							}
							if (val3.x > num4)
							{
								num4 = val3.x;
							}
							if (val3.y < num5)
							{
								num5 = val3.y;
							}
							if (val3.y > num6)
							{
								num6 = val3.y;
							}
						}
						float num7 = ((Rect)(ref value2)).x / (float)newW;
						float num8 = (((Rect)(ref value2)).x + ((Rect)(ref value2)).width) / (float)newW;
						float num9 = ((Rect)(ref value2)).y / (float)newH;
						float num10 = (((Rect)(ref value2)).y + ((Rect)(ref value2)).height) / (float)newH;
						float num11 = num4 - num3;
						float num12 = num6 - num5;
						for (int l = 0; l < val.uvs.Length && l < value.Length; l++)
						{
							float num13 = ((num11 > 1E-06f) ? ((value[l].x - num3) / num11) : 0.5f);
							float num14 = ((num12 > 1E-06f) ? ((value[l].y - num5) / num12) : 0.5f);
							val.uvs[l] = new Vector2(num7 + num13 * (num8 - num7), num9 + num14 * (num10 - num9));
						}
					}
				}
				if (!flag || !plan.VanillaRects.TryGetValue(val.name, out var value3) || !plan.RepDimensions.TryGetValue(val.name, out (int, int) value4))
				{
					continue;
				}
				if (val.positions != null && !_originalPositions.ContainsKey(key))
				{
					tk2dSpriteDefinition[] spriteDefinitions2 = collection.spriteDefinitions;
					foreach (tk2dSpriteDefinition val4 in spriteDefinitions2)
					{
						if (val4 != val && val4.positions == val.positions)
						{
							val.positions = (Vector3[])val.positions.Clone();
							break;
						}
					}
					_originalPositions[key] = (Vector3[])val.positions.Clone();
				}
				if (val.positions == null || !_originalPositions.TryGetValue(key, out var value5) || val.positions.Length != value5.Length || value5.Length < 4)
				{
					continue;
				}
				float num15 = float.MaxValue;
				float num16 = float.MinValue;
				float num17 = float.MaxValue;
				float num18 = float.MinValue;
				Vector3[] array2 = value5;
				foreach (Vector3 val5 in array2)
				{
					if (val5.x < num15)
					{
						num15 = val5.x;
					}
					if (val5.x > num16)
					{
						num16 = val5.x;
					}
					if (val5.y < num17)
					{
						num17 = val5.y;
					}
					if (val5.y > num18)
					{
						num18 = val5.y;
					}
				}
				float num19 = num16 - num15;
				float num20 = num18 - num17;
				if (num19 < 1E-06f || num20 < 1E-06f)
				{
					continue;
				}
				bool flag2 = (int)val.flipped > 0;
				int num21 = (flag2 ? ((int)((Rect)(ref value3)).height) : ((int)((Rect)(ref value3)).width));
				int num22 = (flag2 ? ((int)((Rect)(ref value3)).width) : ((int)((Rect)(ref value3)).height));
				float num23 = num19 / (float)num21;
				float num24 = num20 / (float)num22;
				int num25 = value4.Item1 - num21;
				int num26 = value4.Item2 - num22;
				string valueOrDefault = plan.Anchors.GetValueOrDefault(val.name, "bottom-center");
				float num28;
				float num29;
				float num30;
				float num31;
				if (IOUtil.TryParsePivotAnchor(valueOrDefault, out var px, out var py))
				{
					int num27 = (flag2 ? (value4.Item1 - 1 - px) : px);
					num28 = (float)(-num27) * num23;
					num29 = (float)(value4.Item1 - num27) * num23;
					num30 = (float)(-py) * num24;
					num31 = (float)(value4.Item2 - py) * num24;
				}
				else
				{
					switch (valueOrDefault)
					{
					case "top-center":
						num28 = num15 - (float)num25 * 0.5f * num23;
						num29 = num16 + (float)num25 * 0.5f * num23;
						num31 = num18;
						num30 = num17 - (float)num26 * num24;
						break;
					case "left-center":
						num28 = num15;
						num29 = num16 + (float)num25 * num23;
						num30 = num17 - (float)num26 * 0.5f * num24;
						num31 = num18 + (float)num26 * 0.5f * num24;
						break;
					case "right-center":
						num29 = num16;
						num28 = num15 - (float)num25 * num23;
						num30 = num17 - (float)num26 * 0.5f * num24;
						num31 = num18 + (float)num26 * 0.5f * num24;
						break;
					case "center":
						num28 = num15 - (float)num25 * 0.5f * num23;
						num29 = num16 + (float)num25 * 0.5f * num23;
						num30 = num17 - (float)num26 * 0.5f * num24;
						num31 = num18 + (float)num26 * 0.5f * num24;
						break;
					default:
						num28 = num15 - (float)num25 * 0.5f * num23;
						num29 = num16 + (float)num25 * 0.5f * num23;
						num30 = num17;
						num31 = num18 + (float)num26 * num24;
						break;
					}
				}
				float num32 = num19;
				float num33 = num20;
				for (int m = 0; m < val.positions.Length && m < value5.Length; m++)
				{
					float num34 = (value5[m].x - num15) / num32;
					float num35 = (value5[m].y - num17) / num33;
					val.positions[m] = new Vector3(num28 + num34 * (num29 - num28), num30 + num35 * (num31 - num30), value5[m].z);
				}
			}
		}

		private static bool RestoreVanillaDefsForMat(tk2dSpriteCollectionData collection, int matId, int matIndex)
		{
			if (matIndex < 0)
			{
				return false;
			}
			bool result = false;
			tk2dSpriteDefinition[] spriteDefinitions = collection.spriteDefinitions;
			foreach (tk2dSpriteDefinition val in spriteDefinitions)
			{
				if (val.materialId == matIndex && !string.IsNullOrEmpty(val.name))
				{
					(int, string) key = (matId, val.name);
					if (_originalUVs.TryGetValue(key, out var value) && val.uvs != null && val.uvs.Length == value.Length)
					{
						Array.Copy(value, val.uvs, value.Length);
						result = true;
					}
					if (_originalPositions.TryGetValue(key, out var value2) && val.positions != null && val.positions.Length == value2.Length)
					{
						Array.Copy(value2, val.positions, value2.Length);
						result = true;
					}
				}
			}
			return result;
		}

		internal static bool WasSpriteDrawnThisCycle(string spriteName)
		{
			lock (LoadedSprites)
			{
				foreach (Dictionary<string, HashSet<string>> value in LoadedSprites.Values)
				{
					foreach (HashSet<string> value2 in value.Values)
					{
						if (value2.Contains(spriteName))
						{
							return true;
						}
					}
				}
			}
			return false;
		}

		public static void MarkReloadSprite(string collectionName, string atlasName, string spriteName)
		{
			lock (LoadedSprites)
			{
				foreach (string item in InstanceKeysForName(collectionName))
				{
					if (!LoadedSprites.TryGetValue(item, out var value))
					{
						continue;
					}
					foreach (KeyValuePair<string, HashSet<string>> item2 in value)
					{
						if (item2.Key.StartsWith(atlasName))
						{
							item2.Value.Remove(spriteName);
						}
					}
				}
			}
		}

		public static void MarkReloadAtlas(string collectionName, string atlasName)
		{
			lock (LoadedAtlases)
			{
				foreach (string item in InstanceKeysForName(collectionName))
				{
					if (LoadedAtlases.TryGetValue(item, out var value))
					{
						value.RemoveWhere((string a) => a.StartsWith(atlasName));
					}
					if (!LoadedSprites.TryGetValue(item, out var value2))
					{
						continue;
					}
					foreach (KeyValuePair<string, HashSet<string>> item2 in value2)
					{
						if (item2.Key.StartsWith(atlasName))
						{
							item2.Value.Clear();
						}
					}
				}
			}
		}

		private static IEnumerable<string> InstanceKeysForName(string collectionName)
		{
			foreach (KeyValuePair<string, string> item in _instanceKeyToName)
			{
				if (string.Equals(item.Value, collectionName, StringComparison.Ordinal))
				{
					yield return item.Key;
				}
			}
		}

		public static void Reload()
		{
			_reloadGen++;
			IsReloadingSliced = false;
			_rerunRequested = false;
			ReloadBegin();
			foreach (tk2dSpriteCollectionData item in SnapshotCollections())
			{
				LoadCollection(item);
			}
			ReloadFinish();
		}

		public static void RequestSlicedReload()
		{
			if (IsReloadingSliced)
			{
				_rerunRequested = true;
			}
			else
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(ReloadSlicedRoutine());
			}
		}

		private static IEnumerator ReloadSlicedRoutine()
		{
			int myGen = ++_reloadGen;
			IsReloadingSliced = true;
			SlicedStartedAt = Time.realtimeSinceStartup;
			SlicedCurrent = "";
			Scene activeScene = SceneManager.GetActiveScene();
			int sceneAtStart = ((Scene)(ref activeScene)).handle;
			Stopwatch work = new Stopwatch();
			Stopwatch slice = new Stopwatch();
			int frames = 1;
			FileCache.BeginCycle();
			try
			{
				work.Start();
				slice.Start();
				ReloadBegin();
				List<tk2dSpriteCollectionData> list = SnapshotCollections();
				SlicedTotal = list.Count;
				SlicedProcessed = 0;
				foreach (tk2dSpriteCollectionData collection in list)
				{
					if (slice.ElapsedMilliseconds >= 12)
					{
						work.Stop();
						yield return null;
						frames++;
						if (_reloadGen != myGen)
						{
							yield break;
						}
						activeScene = SceneManager.GetActiveScene();
						if (((Scene)(ref activeScene)).handle != sceneAtStart)
						{
							IsReloadingSliced = false;
							SpriteFileWatcher.ReloadSprites = true;
							Plugin.Logger.LogInfo((object)$"[SpriteLoader] Sliced reload restarted by scene change at {SlicedProcessed}/{SlicedTotal}.");
							yield break;
						}
						work.Start();
						slice.Restart();
					}
					if ((Object)(object)collection == (Object)null)
					{
						SlicedProcessed++;
						continue;
					}
					SlicedCurrent = ((Object)collection).name;
					LoadCollection(collection);
					SlicedProcessed++;
				}
				ReloadFinish();
				work.Stop();
				Plugin.Logger.LogInfo((object)($"[ReloadTiming] Sliced sprite reload: {work.ElapsedMilliseconds} ms work across {frames} frame(s), " + $"span {Time.realtimeSinceStartup - SlicedStartedAt:F1} s."));
				IsReloadingSliced = false;
				if (_rerunRequested)
				{
					_rerunRequested = false;
					SpriteFileWatcher.ReloadSprites = true;
				}
			}
			finally
			{
				FileCache.EndCycle();
			}
		}

		private static List<tk2dSpriteCollectionData> SnapshotCollections()
		{
			tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			List<tk2dSpriteCollectionData> list = new List<tk2dSpriteCollectionData>(array.Length);
			tk2dSpriteCollectionData[] array2 = array;
			foreach (tk2dSpriteCollectionData val in array2)
			{
				if (!((Object)val).name.StartsWith("Stitchwork_Shadow", StringComparison.Ordinal))
				{
					list.Add(val);
				}
			}
			return list;
		}

		private static void ReloadBegin()
		{
			RebuildFileIndex();
			LoadedAtlases.Clear();
			LoadedSprites.Clear();
			_loadedSpriteCount = 0;
			_spriteDefsWalked = 0;
			_rotatedReplacements = 0;
			_instanceKeyToName.Clear();
			_nameInstanceCount.Clear();
			_collectionsExpandedThisReload.Clear();
			_collectionsRevertedThisReload.Clear();
			_perCollectionReplacements.Clear();
		}

		private static void ReloadFinish()
		{
			if (_collectionsWithFiles.Count == 0 && _originalTextures.Count > 0)
			{
				int num = 0;
				Material[] array = Resources.FindObjectsOfTypeAll<Material>();
				foreach (Material val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						int instanceID = ((Object)val).GetInstanceID();
						if (_originalTextures.TryGetValue(instanceID, out var value) && (Object)(object)value != (Object)null && value.IsCreated() && (Object)(object)val.mainTexture != (Object)(object)value)
						{
							val.mainTexture = (Texture)(object)value;
							UnregisterBinding(val);
							num++;
						}
					}
				}
				if (num > 0)
				{
					Plugin.Logger.LogInfo((object)($"[SpriteLoader] Reverted {num} orphaned material(s) " + "missed by collection sweep"));
				}
			}
			HashSet<tk2dSpriteCollectionData> hashSet = new HashSet<tk2dSpriteCollectionData>(_collectionsExpandedThisReload);
			hashSet.UnionWith(_collectionsRevertedThisReload);
			if (hashSet.Count > 0)
			{
				int num2 = 0;
				tk2dBaseSprite[] array2 = Resources.FindObjectsOfTypeAll<tk2dBaseSprite>();
				foreach (tk2dBaseSprite val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null) && hashSet.Contains(val2.Collection))
					{
						val2.ForceBuild();
						num2++;
					}
				}
				if (num2 > 0)
				{
					Plugin.Logger.LogDebug((object)$"[SpriteLoader] ForceBuild on {num2} sprite instance(s) after def changes");
				}
			}
			string arg = "";
			if (_perCollectionReplacements.Count > 0)
			{
				List<KeyValuePair<string, int>> list = new List<KeyValuePair<string, int>>(_perCollectionReplacements);
				list.Sort((KeyValuePair<string, int> a, KeyValuePair<string, int> b) => b.Value.CompareTo(a.Value));
				StringBuilder stringBuilder = new StringBuilder(" — ");
				int num3 = 0;
				for (int num4 = 0; num4 < list.Count; num4++)
				{
					if (num3 >= 8)
					{
						break;
					}
					if (num3 > 0)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append(list[num4].Key).Append('=').Append(list[num4].Value);
					num3++;
				}
				if (list.Count > num3)
				{
					stringBuilder.Append(", +").Append(list.Count - num3).Append(" more");
				}
				arg = stringBuilder.ToString();
			}
			Plugin.Logger.LogInfo((object)($"[SpriteLoader] Reload complete: {LoadedSpriteCount} replacement(s) drawn across " + $"{LoadedAtlases.Count} atlas(es) ({_spriteDefsWalked} sprite def(s) walked)" + $"{arg} — {_rotatedReplacements} rotated — " + $"atlas VRAM {AtlasRTCount} RT/{AtlasVramBytes >> 20} MB"));
			AppliqueLoader.Apply();
		}
	}
	public static class T2DDumper
	{
		public static string DumpPath => Path.Combine(SpriteDumper.DumpPath, "T2D");

		public static void DumpAllT2DSprites()
		{
			HashSet<int> hashSet = new HashSet<int>();
			HashSet<int> hashSet2 = new HashSet<int>();
			HashSet<string> hashSet3 = new HashSet<string>();
			HashSet<string> hashSet4 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
			foreach (Sprite val in array)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.texture == (Object)null)
				{
					continue;
				}
				hashSet.Add(((Object)val.texture).GetInstanceID());
				if (string.IsNullOrEmpty(((Object)val).name) || string.IsNullOrEmpty(((Object)val.texture).name))
				{
					continue;
				}
				if (T2DUtil.IsT2DTexture(((Object)val.texture).name))
				{
					string item = T2DUtil.SpriteKey(T2DUtil.CleanTextureName(((Object)val.texture).name), ((Object)val).name);
					if (hashSet3.Add(item))
					{
						hashSet4.Add(((Object)val).name);
						HandleDump(val);
					}
				}
				else if (hashSet2.Add(((Object)val.texture).GetInstanceID()))
				{
					HandleDump(val);
				}
			}
			DumpStandaloneTextures(hashSet, hashSet4);
		}

		private static void DumpStandaloneTextures(HashSet<int> spriteTextureIds, HashSet<string> atlasDumpedNames)
		{
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(DumpPath, "_standalone");
			bool flag = false;
			int num = 0;
			HashSet<int> hashSet = new HashSet<int>();
			tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val in array)
			{
				if ((Object)(object)val == (Object)null || val.materials == null)
				{
					continue;
				}
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					if ((Object)(object)val2 != (Object)null && (Object)(object)val2.mainTexture != (Object)null)
					{
						hashSet.Add(((Object)val2.mainTexture).GetInstanceID());
					}
				}
			}
			Texture2D[] array2 = Resources.FindObjectsOfTypeAll<Texture2D>();
			foreach (Texture2D val3 in array2)
			{
				if ((Object)(object)val3 == (Object)null || string.IsNullOrEmpty(((Object)val3).name) || T2DUtil.IsT2DTexture(((Object)val3).name) || hashSet.Contains(((Object)val3).GetInstanceID()) || spriteTextureIds.Contains(((Object)val3).GetInstanceID()) || ((Object)val3).name.StartsWith("unity_") || ((Object)val3).name.StartsWith("UI") || atlasDumpedNames.Contains(((Object)val3).name))
				{
					continue;
				}
				string text2 = T2DUtil.SanitizeForFilesystem(((Object)val3).name);
				string path = Path.Combine(text, text2 + ".png");
				if (File.Exists(path))
				{
					continue;
				}
				if (T2DLoader.TryGetOriginalPngBytes(((Object)val3).name, out var png))
				{
					if (!flag)
					{
						IOUtil.EnsureDirectoryExists(text);
						flag = true;
					}
					File.WriteAllBytes(IOUtil.LongSafe(path), png);
					num++;
					continue;
				}
				RenderTexture temporary = RenderTexture.GetTemporary(((Texture)val3).width, ((Texture)val3).height, 0, (RenderTextureFormat)0);
				RenderTexture active = RenderTexture.active;
				Texture2D val4 = null;
				try
				{
					Graphics.Blit((Texture)(object)val3, temporary);
					RenderTexture.active = temporary;
					val4 = new Texture2D(((Texture)val3).width, ((Texture)val3).height, (TextureFormat)4, false);
					val4.ReadPixels(new Rect(0f, 0f, (float)((Texture)val3).width, (float)((Texture)val3).height), 0, 0);
					val4.Apply();
					if (!flag)
					{
						IOUtil.EnsureDirectoryExists(text);
						flag = true;
					}
					File.WriteAllBytes(IOUtil.LongSafe(path), ImageConversion.EncodeToPNG(val4));
					num++;
				}
				finally
				{
					RenderTexture.active = active;
					RenderTexture.ReleaseTemporary(temporary);
					if ((Object)(object)val4 != (Object)null)
					{
						Object.Destroy((Object)(object)val4);
					}
				}
			}
			if (num > 0)
			{
				Plugin.Logger.LogDebug((object)$"[T2D] Dumped {num} standalone textures to {text}");
			}
		}

		public static void DumpAtlasTexture(Texture2D tex)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			string text = T2DUtil.CleanTextureName(((Object)tex).name);
			string text2 = Path.Combine(DumpPath, text);
			string path = Path.Combine(text2, $"_atlas_{((Texture)tex).width}x{((Texture)tex).height}.png");
			if (File.Exists(path))
			{
				return;
			}
			if (T2DLoader.TryGetOriginalPngBytes(((Object)tex).name, out var png))
			{
				IOUtil.EnsureDirectoryExists(text2);
				File.WriteAllBytes(IOUtil.LongSafe(path), png);
			}
			else
			{
				RenderTexture temporary = RenderTexture.GetTemporary(((Texture)tex).width, ((Texture)tex).height, 0, (RenderTextureFormat)0);
				RenderTexture active = RenderTexture.active;
				Texture2D val = null;
				try
				{
					Graphics.Blit((Texture)(object)tex, temporary);
					RenderTexture.active = temporary;
					val = new Texture2D(((Texture)tex).width, ((Texture)tex).height, (TextureFormat)4, false);
					val.ReadPixels(new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), 0, 0);
					val.Apply();
					IOUtil.EnsureDirectoryExists(text2);
					File.WriteAllBytes(IOUtil.LongSafe(path), ImageConversion.EncodeToPNG(val));
					Plugin.Logger.LogDebug((object)$"[T2D] Dumped particle atlas: '{text}' ({((Texture)tex).width}x{((Texture)tex).height})");
				}
				finally
				{
					RenderTexture.active = active;
					RenderTexture.ReleaseTemporary(temporary);
					if ((Object)(object)val != (Object)null)
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
			Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
			foreach (Sprite val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.texture == (Object)null) && ((Object)val2.texture).GetInstanceID() == ((Object)tex).GetInstanceID() && !string.IsNullOrEmpty(((Object)val2).name))
				{
					HandleDump(val2);
				}
			}
		}

		public static void HandleDump(Sprite sprite)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Expected O, but got Unknown
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Invalid comparison between Unknown and I4
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Expected O, but got Unknown
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			if (T2DUtil.IsT2DTexture(((Object)sprite.texture).name))
			{
				if (string.IsNullOrEmpty(((Object)sprite).name))
				{
					return;
				}
				string path = T2DUtil.CleanTextureName(((Object)sprite.texture).name);
				string text = Path.Combine(DumpPath, path);
				IOUtil.EnsureDirectoryExists(text);
				string path2 = Path.Combine(text, ((Object)sprite).name + ".png");
				if (File.Exists(path2))
				{
					return;
				}
				Rect rect = sprite.rect;
				int num = (int)((Rect)(ref rect)).width;
				rect = sprite.rect;
				int num2 = (int)((Rect)(ref rect)).height;
				int num3 = 31;
				GameObject val = new GameObject("TempSpriteRenderer");
				SpriteRenderer val2 = null;
				GameObject val3 = null;
				Camera val4 = null;
				RenderTexture val5 = null;
				Texture2D val6 = null;
				Texture2D val7 = null;
				Sprite val8 = null;
				try
				{
					Sprite sprite2 = sprite;
					if (T2DLoader.TryGetOriginalPngBytes(((Object)sprite.texture).name, out var png))
					{
						Rect val9 = sprite.rect;
						bool flag = true;
						if (sprite.packed)
						{
							if ((int)sprite.packingMode == 1)
							{
								val9 = sprite.textureRect;
							}
							else
							{
								flag = false;
							}
						}
						if (flag)
						{
							val7 = new Texture2D(2, 2, (TextureFormat)4, false);
							if (ImageConversion.LoadImage(val7, png) && ((Texture)val7).width == ((Texture)sprite.texture).width && ((Texture)val7).height == ((Texture)sprite.texture).height)
							{
								Texture2D obj = val7;
								Rect val10 = val9;
								float x = sprite.pivot.x;
								rect = sprite.rect;
								float num4 = x / ((Rect)(ref rect)).width;
								float y = sprite.pivot.y;
								rect = sprite.rect;
								val8 = Sprite.Create(obj, val10, new Vector2(num4, y / ((Rect)(ref rect)).height), sprite.pixelsPerUnit);
								sprite2 = val8;
							}
						}
						else
						{
							Plugin.Logger.LogWarning((object)("[T2D] DumpSingle '" + ((Object)sprite).name + "': atlas is tight-packed — no axis-aligned vanilla rect exists; dumping the LIVE sprite (may contain replaced sheet art)."));
						}
					}
					val2 = val.AddComponent<SpriteRenderer>();
					T2DLoader.SetInternalAssignmentGuard(on: true);
					try
					{
						val2.sprite = sprite2;
					}
					finally
					{
						T2DLoader.SetInternalAssignmentGuard(on: false);
					}
					val.layer = num3;
					Transform transform = val.transform;
					float x2 = sprite.pivot.x;
					rect = sprite.rect;
					float num5 = 10000f + (x2 - ((Rect)(ref rect)).width / 2f) / sprite.pixelsPerUnit;
					float y2 = sprite.pivot.y;
					rect = sprite.rect;
					transform.position = new Vector3(num5, 10000f + (y2 - ((Rect)(ref rect)).height / 2f) / sprite.pixelsPerUnit, 0f);
					val3 = new GameObject("TempCamera");
					val4 = val3.AddComponent<Camera>();
					val4.clearFlags = (CameraClearFlags)2;
					val4.backgroundColor = new Color(0f, 0f, 0f, 0f);
					val4.orthographic = true;
					val4.cullingMask = 1 << num3;
					val4.orthographicSize = (float)num2 / sprite.pixelsPerUnit / 2f;
					((Component)val4).transform.position = new Vector3(10000f, 10000f, -10f);
					Plugin.Logger.LogDebug((object)$"[T2D] DumpSingle '{((Object)sprite).name}' rect={num}x{num2} tex='{((Object)sprite.texture).name}' vanillaClone={(Object)(object)val8 != (Object)null}");
					val5 = new RenderTexture(num, num2, 0, (RenderTextureFormat)0);
					((Texture)val5).filterMode = (FilterMode)0;
					val4.targetTexture = val5;
					val4.Render();
					RenderTexture active = RenderTexture.active;
					RenderTexture.active = val5;
					val6 = new Texture2D(num, num2, (TextureFormat)5, false);
					val6.ReadPixels(new Rect(0f, 0f, (float)num, (float)num2), 0, 0);
					val6.Apply();
					RenderTexture.active = active;
					File.WriteAllBytes(IOUtil.LongSafe(path2), ImageConversion.EncodeToPNG(val6));
					return;
				}
				finally
				{
					if ((Object)(object)val4 != (Object)null)
					{
						val4.targetTexture = null;
					}
					if ((Object)(object)val != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val);
					}
					if ((Object)(object)val3 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val3);
					}
					if ((Object)(object)val5 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val5);
					}
					if ((Object)(object)val6 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val6);
					}
					if ((Object)(object)val8 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val8);
					}
					if ((Object)(object)val7 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val7);
					}
				}
			}
			string text2 = T2DUtil.SanitizeForFilesystem(((Object)sprite.texture).name);
			if (string.IsNullOrEmpty(text2))
			{
				return;
			}
			string path3 = Path.Combine(DumpPath, text2 + ".png");
			if (File.Exists(path3))
			{
				return;
			}
			if (T2DLoader.TryGetOriginalPngBytes(((Object)sprite.texture).name, out var png2))
			{
				File.WriteAllBytes(IOUtil.LongSafe(path3), png2);
				return;
			}
			Plugin.Logger.LogDebug((object)("[T2D] Dumping non-atlas texture: '" + ((Object)sprite.texture).name + "' -> " + text2 + ".png"));
			RenderTexture val11 = null;
			Texture2D val12 = null;
			try
			{
				val11 = TexUtil.GetReadable((Texture)(object)sprite.texture);
				val12 = new Texture2D(((Texture)val11).width, ((Texture)val11).height, (TextureFormat)5, false);
				RenderTexture active2 = RenderTexture.active;
				RenderTexture.active = val11;
				val12.ReadPixels(new Rect(0f, 0f, (float)((Texture)val11).width, (float)((Texture)val11).height), 0, 0);
				val12.Apply();
				RenderTexture.active = active2;
				File.WriteAllBytes(IOUtil.LongSafe(path3), ImageConversion.EncodeToPNG(val12));
			}
			finally
			{
				if ((Object)(object)val11 != (Object)null)
				{
					RenderTexture.ReleaseTemporary(val11);
				}
				if ((Object)(object)val12 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val12);
				}
			}
		}
	}
	[HarmonyPatch]
	public static class T2DHandler
	{
		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void SetSpritePostfix(SpriteRenderer __instance, Sprite value)
		{
			if (T2DLoader.IsHandlingOrEnforcing || (Object)(object)__instance == (Object)null || (Object)(object)value == (Object)null || ((Object)((Component)__instance).gameObject).name == "TempSpriteRenderer")
			{
				return;
			}
			bool flag = Plugin.ShowDevHub || Plugin.Config.DumpSprites || T2DLoader.IsT2DLogActive;
			if (!T2DLoader.HasT2DReplacements && !flag)
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				T2DLoader.NotifySetterCall();
				if (Plugin.Config.DumpSprites && !string.IsNullOrEmpty(((Object)value).name) && (Object)(object)value.texture != (Object)null && !string.IsNullOrEmpty(((Object)value.texture).name))
				{
					T2DDumper.HandleDump(value);
				}
				if (Plugin.ShowDevHub)
				{
					T2DLoader.TrackRenderer(__instance);
				}
				if (T2DLoader.IsT2DLogActive && (Object)(object)value.texture != (Object)null)
				{
					T2DLoader.RaiseT2DTrigger(((Object)value.texture).name, T2DUtil.CleanTextureName(((Object)value.texture).name), ((Object)value).name);
				}
				if (T2DLoader.HasT2DReplacements)
				{
					T2DLoader.OnSpriteSet(__instance, value);
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.SR.sprite", heapBefore);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void SetImageSpritePostfix(Image __instance, Sprite value)
		{
			if (T2DLoader.IsHandlingOrEnforcing || (Object)(object)__instance == (Object)null || (Object)(object)value == (Object)null)
			{
				return;
			}
			bool flag = Plugin.ShowDevHub || Plugin.Config.DumpSprites || T2DLoader.IsT2DLogActive;
			if (!T2DLoader.HasT2DReplacements && !flag)
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				T2DLoader.NotifySetterCall();
				if (Plugin.Config.DumpSprites && !string.IsNullOrEmpty(((Object)value).name) && (Object)(object)value.texture != (Object)null && !string.IsNullOrEmpty(((Object)value.texture).name))
				{
					T2DDumper.HandleDump(value);
				}
				if (Plugin.ShowDevHub)
				{
					T2DLoader.TrackImage(__instance);
				}
				if (T2DLoader.IsT2DLogActive && (Object)(object)value.texture != (Object)null)
				{
					T2DLoader.RaiseT2DTrigger(((Object)value.texture).name, T2DUtil.CleanTextureName(((Object)value.texture).name), ((Object)value).name);
				}
				if (T2DLoader.HasT2DReplacements)
				{
					T2DLoader.OnSpriteSet(__instance, value);
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Img.sprite", heapBefore);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void SetMaterialTexturePostfix(Texture value)
		{
			Texture2D val = (Texture2D)(object)((value is Texture2D) ? value : null);
			if (val == null)
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				if (T2DLoader.IsT2DLogActive && T2DUtil.IsT2DTexture(((Object)val).name))
				{
					T2DLoader.RaiseT2DTrigger(((Object)val).name, T2DUtil.CleanTextureName(((Object)val).name), "");
				}
				if (T2DLoader.HasT2DReplacements)
				{
					T2DLoader.TrySwapTexture(val);
					if (Plugin.Config.DumpSprites && T2DUtil.IsT2DTexture(((Object)val).name))
					{
						T2DDumper.DumpAtlasTexture(val);
					}
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Mat.mainTexture", heapBefore);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Cursor), "SetCursor", new Type[]
		{
			typeof(Texture2D),
			typeof(Vector2),
			typeof(CursorMode)
		})]
		public static void CursorSetCursorPrefix(ref Texture2D texture, Vector2 hotspot, CursorMode cursorMode)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null))
			{
				T2DLoader.RememberCursorCall(texture, hotspot, cursorMode);
				if (T2DLoader.HasT2DReplacements && T2DLoader.TryGetStandaloneReplacement(((Object)texture).name, out var replacement))
				{
					texture = replacement;
					T2DLoader.MarkCursorSubstituted();
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Material), "SetTexture", new Type[]
		{
			typeof(string),
			typeof(Texture)
		})]
		public static void SetTextureStringPostfix(Texture value)
		{
			Texture2D val = (Texture2D)(object)((value is Texture2D) ? value : null);
			if (val == null)
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				if (T2DLoader.IsT2DLogActive && T2DUtil.IsT2DTexture(((Object)val).name))
				{
					T2DLoader.RaiseT2DTrigger(((Object)val).name, T2DUtil.CleanTextureName(((Object)val).name), "");
				}
				if (T2DLoader.HasT2DReplacements)
				{
					T2DLoader.TrySwapTexture(val);
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Mat.SetTexture", heapBefore);
			}
		}
	}
	internal static class SpriteAtlasBridge
	{
		private static bool _init;

		private static Type _atlasType;

		private static Type _atlasManagerType;

		private static EventInfo _evAtlasRegistered;

		private static MethodInfo _miGetSpritesArray;

		private static Delegate _subscribedHandler;

		public static void Init()
		{
			if (_init)
			{
				return;
			}
			_init = true;
			_atlasType = Type.GetType("UnityEngine.U2D.SpriteAtlas, UnityEngine.U2DModule", throwOnError: false);
			_atlasManagerType = Type.GetType("UnityEngine.U2D.SpriteAtlasManager, UnityEngine.U2DModule", throwOnError: false);
			if (!(_atlasType == null) && !(_atlasManagerType == null))
			{
				_evAtlasRegistered = _atlasManagerType.GetEvent("atlasRegistered", BindingFlags.Static | BindingFlags.Public);
				_miGetSpritesArray = _atlasType.GetMethod("GetSprites", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(Sprite[]) }, null);
				if (!(_evAtlasRegistered == null) && !(_miGetSpritesArray == null))
				{
					MethodInfo method = typeof(SpriteAtlasBridge).GetMethod("OnAtlasRegistered", BindingFlags.Static | BindingFlags.NonPublic);
					_subscribedHandler = Delegate.CreateDelegate(typeof(Action<>).MakeGenericType(_atlasType), method);
					_evAtlasRegistered.GetAddMethod().Invoke(null, new object[1] { _subscribedHandler });
					Plugin.Logger.LogDebug((object)"[SpriteAtlasBridge] subscribed to SpriteAtlasManager.atlasRegistered");
				}
			}
		}

		private static void OnAtlasRegistered(object atlas)
		{
			if (atlas == null || _miGetSpritesArray == null || !T2DLoader.HasT2DReplacements)
			{
				return;
			}
			Sprite[] array;
			int num;
			try
			{
				array = (Sprite[])(object)new Sprite[1024];
				num = (int)_miGetSpritesArray.Invoke(atlas, new object[1] { array });
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)$"[SpriteAtlasBridge] GetSprites threw: {(ex as TargetInvocationException)?.InnerException ?? ex}");
				return;
			}
			for (int i = 0; i < num && i < array.Length; i++)
			{
				Sprite val = array[i];
				if ((Object)(object)val != (Object)null && (Object)(object)val.texture != (Object)null)
				{
					T2DLoader.TrySwapTexture(val.texture);
				}
			}
		}
	}
	public static class T2DLoader
	{
		private static readonly Dictionary<string, Sprite> _loadedSprites = new Dictionary<string, Sprite>();

		private static readonly Dictionary<string, string> _spriteNameToKey = new Dictionary<string, string>();

		private static readonly Dictionary<string, string> _t2dProviders = new Dictionary<string, string>();

		private static readonly Dictionary<string, string> _t2dSourceFiles = new Dictionary<string, string>();

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

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

		private static string _lastCursorName;

		private static Vector2 _lastCursorHotspot;

		private static CursorMode _lastCursorMode;

		private static readonly HashSet<SpriteRenderer> _knownRenderers = new HashSet<SpriteRenderer>();

		private static readonly HashSet<Image> _knownImages = new HashSet<Image>();

		private static readonly HashSet<SpriteRenderer> _replacedSrs = new HashSet<SpriteRenderer>();

		private static readonly HashSet<Image> _replacedImgs = new HashSet<Image>();

		private static readonly ConditionalWeakTable<Sprite, string> _spriteKeyCache = new ConditionalWeakTable<Sprite, string>();

		private static readonly ConditionalWeakTable<Sprite, string>.CreateValueCallback _spriteKeyCreator = (Sprite s) => T2DUtil.SpriteKey(T2DUtil.CleanTextureName(((Object)s.texture).name), ((Object)s).name);

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

		private static readonly List<Sprite> _retiredSprites = new List<Sprite>();

		private static readonly Predicate<SpriteRenderer> _srNull = (SpriteRenderer sr) => (Object)(object)sr == (Object)null;

		private static readonly Predicate<Image> _imgNull = (Image img) => (Object)(object)img == (Object)null;

		private static bool _enforcing;

		private static bool _handling;

		public static bool IsT2DLogActive;

		private static Sprite[] _seededSprites = Array.Empty<Sprite>();

		private static readonly Dictionary<string, Sprite> _spriteHighlightCache = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static Texture2D _lastCursorVanillaTex;

		private static bool _cursorSubstituted;

		private static float _diagNextTime;

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

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

		private static SpriteRenderer[] _cachedSrArray = Array.Empty<SpriteRenderer>();

		private static Image[] _cachedImgArray = Array.Empty<Image>();

		private static float _nextCacheRefreshTime;

		private static bool _cacheInvalidated = true;

		private const float DefaultCacheRefreshSeconds = 0.3f;

		private static int _setterCallsThisFrame;

		private static int _prevFrameSetterCalls;

		private static readonly Dictionary<int, int> _lastLoggedSpriteIdSr = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> _lastLoggedSpriteIdImg = new Dictionary<int, int>();

		private static int _enforcePruneCounter;

		private static readonly Dictionary<int, int> _lastSeenSpriteIdSr = new Dictionary<int, int>();

		private static readonly Dictionary<int, int> _lastSeenSpriteIdImg = new Dictionary<int, int>();

		private static readonly Dictionary<string, (byte[] PngData, int Width, int Height)> SpritesheetOverrides = new Dictionary<string, (byte[], int, int)>(StringComparer.OrdinalIgnoreCase);

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

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

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

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

		private static Type _tmpFontAssetType;

		private static MemberInfo _fontAssetAtlasMember;

		private static MemberInfo _fontAssetAtlasTexturesMember;

		private static MemberInfo _fontAssetFallbackTableMember;

		private static bool _fontBridgeInit;

		private static Type _ppProfileType;

		private static FieldInfo _ppProfileSettingsField;

		private static Type _ppParamOverrideType;

		private static bool _ppBridgeInit;

		private const int TrackingSetCap = 16384;

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

		private static readonly Dictionary<string, byte[]> _originalTextureData = new Dictionary<string, byte[]>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, string> _sheetProviders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		public static string AtlasLoadPath => Path.Combine(SpriteLoader.AtlasLoadPath, "T2D");

		public static int ReplacedRendererCount => _replacedSrs.Count + _replacedImgs.Count;

		public static bool HasT2DReplacements
		{
			get
			{
				if (SpritesheetOverrides.Count <= 0)
				{
					return _loadedSprites.Count > 0;
				}
				return true;
			}
		}

		public static bool IsHandlingOrEnforcing
		{
			get
			{
				if (!_handling)
				{
					return _enforcing;
				}
				return true;
			}
		}

		public static int SpritesheetOverrideCount => SpritesheetOverrides.Count;

		public static int LoadedT2DSpriteCount => _loadedSprites.Count;

		public static IEnumerable<string> LoadedT2DSpriteNames => _loadedSprites.Keys;

		public static IEnumerable<string> SpritesheetOverrideNames => SpritesheetOverrides.Keys;

		private static float UninitRefreshSeconds => Mathf.Clamp(Plugin.Config?.UninitCheckCacheRefreshSeconds ?? 0.3f, 0.01f, 10f);

		public static int PrevFrameSetterCalls => _prevFrameSetterCalls;

		internal static bool HasStoredOriginals => _originalTextureData.Count > 0;

		internal static long SpritesheetOverrideBytes
		{
			get
			{
				long num = 0L;
				foreach (var value in SpritesheetOverrides.Values)
				{
					if (value.PngData != null)
					{
						num += value.PngData.Length;
					}
				}
				return num;
			}
		}

		internal static long OriginalTextureDataBytes
		{
			get
			{
				long num = 0L;
				foreach (byte[] value in _originalTextureData.Values)
				{
					num += value.Length;
				}
				return num;
			}
		}

		public static event Action<string, string, string> OnT2DTrigger;

		public static Dictionary<string, int> CountActiveRenderersByPack()
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (SpriteRenderer replacedSr in _replacedSrs)
			{
				if ((Object)(object)replacedSr != (Object)null)
				{
					TallyRendererPack(replacedSr.sprite, dictionary);
				}
			}
			foreach (Image replacedImg in _replacedImgs)
			{
				if ((Object)(object)replacedImg != (Object)null)
				{
					TallyRendererPack(replacedImg.sprite, dictionary);
				}
			}
			return dictionary;
		}

		private static void TallyRendererPack(Sprite sprite, Dictionary<string, int> counts)
		{
			if ((Object)(object)sprite == (Object)null || (Object)(object)sprite.texture == (Object)null)
			{
				return;
			}
			string name = ((Object)sprite.texture).name;
			if (string.IsNullOrEmpty(name))
			{
				return;
			}
			if (!_sheetProviders.TryGetValue(name, out var value))
			{
				string key = T2DUtil.CleanTextureName(name);
				if (!_sheetProviders.TryGetValue(key, out value))
				{
					return;
				}
			}
			if (!string.IsNullOrEmpty(value))
			{
				counts[value] = (counts.TryGetValue(value, out var value2) ? value2 : 0) + 1;
			}
		}

		internal static void SetInternalAssignmentGuard(bool on)
		{
			_enforcing = on;
		}

		public static void RaiseT2DTrigger(string rawTexName, string cleanTexName, string spriteName)
		{
			T2DLoader.OnT2DTrigger?.Invoke(rawTexName, cleanTexName, spriteName);
		}

		public static void TrackRenderer(SpriteRenderer sr)
		{
			if ((Object)(object)sr != (Object)null)
			{
				_knownRenderers.Add(sr);
			}
		}

		public static void TrackImage(Image img)
		{
			if ((Object)(object)img != (Object)null)
			{
				_knownImages.Add(img);
			}
		}

		internal static void InvalidateSpriteLookupCache()
		{
			_spriteHighlightCache.Clear();
		}

		public static void ResetSceneSeed()
		{
			_seededSprites = Array.Empty<Sprite>();
			_spriteHighlightCache.Clear();
			_knownRenderers.RemoveWhere(_srNull);
			_knownImages.RemoveWhere(_imgNull);
		}

		public static List<T2DSceneEntry> GetSceneTextureEntries()
		{
			Dictionary<int, HashSet<string>> spritesByTexId = new Dictionary<int, HashSet<string>>();
			Dictionary<int, Texture> texById = new Dictionary<int, Texture>();
			_seededSprites = Resources.FindObjectsOfTypeAll<Sprite>();
			Sprite[] seededSprites = _seededSprites;
			for (int i = 0; i < seededSprites.Length; i++)
			{
				Accumulate(seededSprites[i]);
			}
			foreach (SpriteRenderer knownRenderer in _knownRenderers)
			{
				if (!((Object)(object)knownRenderer == (Object)null))
				{
					Sprite sprite = knownRenderer.sprite;
					if ((Object)(object)sprite != (Object)null)
					{
						Accumulate(sprite);
					}
				}
			}
			foreach (Image knownImage in _knownImages)
			{
				if (!((Object)(object)knownImage == (Object)null))
				{
					Sprite sprite2 = knownImage.sprite;
					if ((Object)(object)sprite2 != (Object)null)
					{
						Accumulate(sprite2);
					}
				}
			}
			ParticleSystemRenderer[] array = Resources.FindObjectsOfTypeAll<ParticleSystemRenderer>();
			foreach (ParticleSystemRenderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Material sharedMaterial = ((Renderer)val).sharedMaterial;
				if ((Object)(object)sharedMaterial == (Object)null)
				{
					continue;
				}
				Texture mainTexture = sharedMaterial.mainTexture;
				if (!((Object)(object)mainTexture == (Object)null) && !string.IsNullOrEmpty(((Object)mainTexture).name))
				{
					int instanceID = ((Object)mainTexture).GetInstanceID();
					if (!spritesByTexId.ContainsKey(instanceID))
					{
						spritesByTexId[instanceID] = new HashSet<string>(StringComparer.Ordinal);
						texById[instanceID] = mainTexture;
					}
				}
			}
			Dictionary<string, (Texture, string, string, HashSet<string>, bool, int)> dictionary = new Dictionary<string, (Texture, string, string, HashSet<string>, bool, int)>(StringComparer.Ordinal);
			foreach (KeyValuePair<int, Texture> item9 in texById)
			{
				Texture value = item9.Value;
				bool flag = T2DUtil.IsT2DTexture(((Object)value).name);
				string item = (flag ? T2DUtil.CleanTextureName(((Object)value).name) : ((Object)value).name);
				int item2 = (flag ? T2DUtil.AtlasIndexFromRaw(((Object)value).name) : (-1));
				HashSet<string> hashSet = spritesByTexId[item9.Key];
				if (dictionary.TryGetValue(((Object)value).name, out var value2))
				{
					value2.Item4.UnionWith(hashSet);
					if (value.width * value.height > value2.Item1.width * value2.Item1.height)
					{
						dictionary[((Object)value).name] = (value, ((Object)value).name, item, value2.Item4, flag, item2);
					}
				}
				else
				{
					dictionary[((Object)value).name] = (value, ((Object)value).name, item, hashSet, flag, item2);
				}
			}
			tk2dSpriteCollectionData[] array2 = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val2 in array2)
			{
				if (val2?.spriteDefinitions == null)
				{
					continue;
				}
				tk2dSpriteDefinition[] spriteDefinitions = val2.spriteDefinitions;
				foreach (tk2dSpriteDefinition val3 in spriteDefinitions)
				{
					if (val3 != null && !((Object)(object)val3.material == (Object)null) && !((Object)(object)val3.material.mainTexture == (Object)null) && !string.IsNullOrEmpty(val3.name))
					{
						string name = ((Object)val3.material.mainTexture).name;
						if (dictionary.TryGetValue(name, out var value3))
						{
							value3.Item4.Add(val3.name);
						}
					}
				}
			}
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (var value8 in dictionary.Values)
			{
				dictionary2.TryGetValue(value8.Item3, out var value4);
				dictionary2[value8.Item3] = value4 + 1;
			}
			List<T2DSceneEntry> list = new List<T2DSceneEntry>(dictionary.Count);
			foreach (KeyValuePair<string, (Texture, string, string, HashSet<string>, bool, int)> item10 in dictionary)
			{
				(Texture, string, string, HashSet<string>, bool, int) value5 = item10.Value;
				Texture item3 = value5.Item1;
				string item4 = value5.Item2;
				string item5 = value5.Item3;
				HashSet<string> item6 = value5.Item4;
				bool item7 = value5.Item5;
				int item8 = value5.Item6;
				bool hasOverride = SpritesheetOverrides.ContainsKey(item4) || SpritesheetOverrides.ContainsKey(item5);
				string value6 = item5 + "/";
				int num = 0;
				foreach (string key in _loadedSprites.Keys)
				{
					if (key.StartsWith(value6, StringComparison.OrdinalIgnoreCase))
					{
						num++;
					}
				}
				string displayName = ((dictionary2[item5] > 1 && item8 >= 0) ? $"{item5}-{item8}" : item5);
				list.Add(new T2DSceneEntry(item5, item4, item3, item7, new List<string>(item6), hasOverride, num, item8, displayName));
			}
			list.Sort((T2DSceneEntry a, T2DSceneEntry b) => (a.IsT2D != b.IsT2D) ? ((!a.IsT2D) ? 1 : (-1)) : string.Compare(a.DisplayName, b.DisplayName, StringComparison.OrdinalIgnoreCase));
			return list;
			void Accumulate(Sprite val4)
			{
				if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.texture == (Object)null))
				{
					Texture2D texture = val4.texture;
					int instanceID2 = ((Object)texture).GetInstanceID();
					if (!spritesByTexId.TryGetValue(instanceID2, out var value7))
					{
						value7 = new HashSet<string>(StringComparer.Ordinal);
						spritesByTexId[instanceID2] = value7;
						texById[instanceID2] = (Texture)(object)texture;
					}
					if (!string.IsNullOrEmpty(((Object)val4).name))
					{
						value7.Add(((Object)val4).name);
					}
				}
			}
		}

		public static Sprite FindSceneSprite(string rawTexName, string spriteName)
		{
			string key = rawTexName + "/" + spriteName;
			if (_spriteHighlightCache.TryGetValue(key, out var value))
			{
				return value;
			}
			foreach (SpriteRenderer knownRenderer in _knownRenderers)
			{
				if (!((Object)(object)knownRenderer == (Object)null))
				{
					Sprite sprite = knownRenderer.sprite;
					if (!((Object)(object)sprite == (Object)null) && !((Object)(object)sprite.texture == (Object)null) && ((Object)sprite).name == spriteName && ((Object)sprite.texture).name == rawTexName)
					{
						_spriteHighlightCache[key] = sprite;
						return sprite;
					}
				}
			}
			foreach (Image knownImage in _knownImages)
			{
				if (!((Object)(object)knownImage == (Object)null))
				{
					Sprite sprite2 = knownImage.sprite;
					if (!((Object)(object)sprite2 == (Object)null) && !((Object)(object)sprite2.texture == (Object)null) && ((Object)sprite2).name == spriteName && ((Object)sprite2.texture).name == rawTexName)
					{
						_spriteHighlightCache[key] = sprite2;
						return sprite2;
					}
				}
			}
			Sprite[] seededSprites = _seededSprites;
			foreach (Sprite val in seededSprites)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.texture == (Object)null) && ((Object)val).name == spriteName && ((Object)val.texture).name == rawTexName)
				{
					_spriteHighlightCache[key] = val;
					return val;
				}
			}
			return null;
		}

		public static void OnSpriteSet(SpriteRenderer sr, Sprite value)
		{
			if ((Object)(object)value.texture != (Object)null && !HasIndividualReplacement(value))
			{
				TrySwapTexture(value.texture);
			}
			HandleLoad(sr, value);
		}

		public static void OnSpriteSet(Image img, Sprite value)
		{
			if ((Object)(object)value.texture != (Object)null && !HasIndividualReplacement(value))
			{
				TrySwapTexture(value.texture);
			}
			HandleLoad(img, value);
		}

		private static bool HasIndividualReplacement(Sprite sprite)
		{
			if ((Object)(object)sprite.texture == (Object)null || !T2DUtil.IsT2DTexture(((Object)sprite.texture).name))
			{
				return false;
			}
			return _loadedSprites.ContainsKey(KeyForSprite(sprite));
		}

		public static void ApplyReplacementsInScene()
		{
			InvalidateSpriteLookupCache();
			RegisterFontAtlasIds();
			RegisterPostProcessTextureIds();
			if (SpritesheetOverrides.Count > 0)
			{
				Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
				foreach (Texture2D val in array)
				{
					if ((Object)(object)val != (Object)null)
					{
						TrySwapTexture(val);
					}
				}
			}
			if (!HasT2DReplacements)
			{
				return;
			}
			SpriteRenderer[] array2 = Resources.FindObjectsOfTypeAll<SpriteRenderer>();
			foreach (SpriteRenderer val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.sprite == (Object)null))
				{
					HandleLoad(val2, val2.sprite);
				}
			}
			Image[] array3 = Resources.FindObjectsOfTypeAll<Image>();
			foreach (Image val3 in array3)
			{
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.sprite == (Object)null))
				{
					HandleLoad(val3, val3.sprite);
				}
			}
			PreCorrectAllPPU();
			RefreshSubstitutedCursor();
		}

		public static void PreloadAllTextures()
		{
			ConflictTracker.ClearTypes("t2d-sprite", "t2d-sheet");
			BuildSpritesheetOverrides();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				ScanDirectory(Path.Combine(pluginPackPath, "Sprites", "T2D"), pluginPackPath);
			}
			ScanDirectory(Path.Combine(SpriteLoader.LoadPath, "T2D"), null);
			if (Plugin.Config.LogT2DLookupMisses)
			{
				DumpKeysToSideFile();
			}
			static void ScanDirectory(string t2dRoot, string sourcePack)
			{
				if (Directory.Exists(t2dRoot))
				{
					string[] directories = Directory.GetDirectories(t2dRoot);
					foreach (string path in directories)
					{
						string fileName = Path.GetFileName(path);
						bool flag = fileName.Equals("_standalone", StringComparison.OrdinalIgnoreCase);
						bool flag2 = false;
						string[] files = Directory.GetFiles(path, "*.png");
						foreach (string text in files)
						{
							string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
							if ((Object)(object)CreateAndStore(flag ? fileNameWithoutExtension : T2DUtil.SpriteKey(fileName, fileNameWithoutExtension), fileNameWithoutExtension, text, flag) != (Object)null)
							{
								flag2 = true;
							}
							if (flag)
							{
								RegisterStandaloneSpritesheet(fileNameWithoutExtension, text, sourcePack);
							}
						}
						if (flag2 && !flag)
						{
							_coveredCleanNames.Add(fileName);
						}
					}
					directories = Directory.GetFiles(t2dRoot, "*.png");
					foreach (string text2 in directories)
					{
						string? fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(text2);
						CreateAndStore(fileNameWithoutExtension2, fileNameWithoutExtension2, text2, keepReadable: true);
					}
				}
				Sprite CreateAndStore(string key, string spriteName, string file, bool keepReadable)
				{
					//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
					if (string.IsNullOrEmpty(spriteName))
					{
						Plugin.Logger.LogWarning((object)("[T2D] Ignoring '" + file + "' — file has no name."));
						return null;
					}
					if (_loadedSprites.ContainsKey(key))
					{
						if (!IOUtil.BenignDuplicate(_t2dSourceFiles.GetValueOrDefault(key), file))
						{
							ConflictTracker.Record("t2d-sprite", key, _t2dProviders.GetValueOrDefault(key), sourcePack, "Sprites/T2D/_standalone › Sprites/T2D", _t2dSourceFiles.GetValueOrDefault(key), file);
						}
						return null;
					}
					byte[] array = FileCache.ReadBytes(file);
					if (array == null)
					{
						return null;
					}
					Texture2D val = TexUtil.CreateTextureFromBytes(array, !keepReadable);
					if ((Object)(object)val == (Object)null)
					{
						return null;
					}
					SkippedTextureIds.Add(((Object)val).GetInstanceID());
					Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
					((Object)val2).name = spriteName;
					((Object)val2).hideFlags = (HideFlags)32;
					_ourSpriteIds.Add(((Object)val2).GetInstanceID());
					_loadedSprites[key] = val2;
					_t2dProviders[key] = sourcePack;
					_t2dSourceFiles[key] = file;
					if (!_spriteNameToKey.ContainsKey(spriteName))
					{
						_spriteNameToKey[spriteName] = key;
					}
					return val2;
				}
			}
		}

		private static void DumpKeysToSideFile()
		{
			try
			{
				string basePath = Plugin.BasePath;
				IOUtil.EnsureDirectoryExists(basePath);
				string text = Path.Combine(basePath, "diagnostic-t2d-keys.txt");
				using StreamWriter streamWriter = new StreamWriter(text, append: false);
				streamWriter.WriteLine($"# Stitchwork T2D diagnostic dump — generated {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
				streamWriter.WriteLine($"# _loadedSprites: {_loadedSprites.Count} entries");
				streamWriter.WriteLine($"# _spriteNameToKey: {_spriteNameToKey.Count} entries (reverse index)");
				streamWriter.WriteLine($"# _coveredCleanNames: {_coveredCleanNames.Count} atlases");
				streamWriter.WriteLine();
				streamWriter.WriteLine("[loadedSprites]");
				foreach (string key in _loadedSprites.Keys)
				{
					streamWriter.WriteLine(key);
				}
				streamWriter.WriteLine();
				streamWriter.WriteLine("[coveredCleanNames]");
				foreach (string coveredCleanName in _coveredCleanNames)
				{
					streamWriter.WriteLine(coveredCleanName);
				}
				Plugin.Logger.LogInfo((object)$"[T2D-Keys] Dumped {_loadedSprites.Count} key(s) to {text}");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[T2D-Keys] Failed to write side file: " + ex.Message));
			}
		}

		private static Sprite EnsurePPU(string key, Sprite cached, float targetPPU, string vanillaTextureName = null, Sprite vanilla = null)
		{
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			Rect rect;
			Rect val = default(Rect);
			Vector2 val2 = default(Vector2);
			float num8;
			if ((Object)(object)vanilla != (Object)null && (Object)(object)vanilla.texture != (Object)null && ((Texture)vanilla.texture).width > 0 && ((Texture)vanilla.texture).height > 0 && !T2DUtil.IsT2DTexture(((Object)vanilla.texture).name))
			{
				float num = (float)((Texture)cached.texture).width / (float)((Texture)vanilla.texture).width;
				float num2 = (float)((Texture)cached.texture).height / (float)((Texture)vanilla.texture).height;
				rect = vanilla.rect;
				float num3 = ((Rect)(ref rect)).x * num;
				rect = vanilla.rect;
				float num4 = ((Rect)(ref rect)).y * num2;
				rect = vanilla.rect;
				float num5 = ((Rect)(ref rect)).width * num;
				rect = vanilla.rect;
				((Rect)(ref val))..ctor(num3, num4, num5, ((Rect)(ref rect)).height * num2);
				((Rect)(ref val)).width = Mathf.Min(((Rect)(ref val)).width, (float)((Texture)cached.texture).width - ((Rect)(ref val)).x);
				((Rect)(ref val)).height = Mathf.Min(((Rect)(ref val)).height, (float)((Texture)cached.texture).height - ((Rect)(ref val)).y);
				rect = vanilla.rect;
				float num6;
				if (!(((Rect)(ref rect)).width > 0f))
				{
					num6 = 0.5f;
				}
				else
				{
					float x = vanilla.pivot.x;
					rect = vanilla.rect;
					num6 = x / ((Rect)(ref rect)).width;
				}
				rect = vanilla.rect;
				float num7;
				if (!(((Rect)(ref rect)).height > 0f))
				{
					num7 = 0.5f;
				}
				else
				{
					float y = vanilla.pivot.y;
					rect = vanilla.rect;
					num7 = y / ((Rect)(ref rect)).height;
				}
				((Vector2)(ref val2))..ctor(num6, num7);
				num8 = targetPPU * num;
				goto IL_026d;
			}
			((Rect)(ref val))..ctor(0f, 0f, (float)((Texture)cached.texture).width, (float)((Texture)cached.texture).height);
			Vector2 val3;
			if ((Object)(object)vanilla != (Object)null)
			{
				rect = vanilla.rect;
				if (((Rect)(ref rect)).width > 0f)
				{
					rect = vanilla.rect;
					if (((Rect)(ref rect)).height > 0f)
					{
						float x2 = vanilla.pivot.x;
						rect = vanilla.rect;
						float num9 = x2 / ((Rect)(ref rect)).width;
						float y2 = vanilla.pivot.y;
						rect = vanilla.rect;
						val3 = new Vector2(num9, y2 / ((Rect)(ref rect)).height);
						goto IL_026a;
					}
				}
			}
			val3 = new Vector2(0.5f, 0.5f);
			goto IL_026a;
			IL_026d:
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor(val2.x * ((Rect)(ref val)).width, val2.y * ((Rect)(ref val)).height);
			Sprite val5;
			if (Math.Abs(cached.pixelsPerUnit - num8) <= 0.5f && cached.rect == val && Mathf.Abs(cached.pivot.x - val4.x) <= 0.5f && Mathf.Abs(cached.pivot.y - val4.y) <= 0.5f)
			{
				val5 = cached;
			}
			else
			{
				Sprite val6 = Sprite.Create(cached.texture, val, val2, num8, 0u, (SpriteMeshType)0);
				((Object)val6).name = ((Object)cached).name;
				((Object)val6).hideFlags = (HideFlags)32;
				_ourSpriteIds.Add(((Object)val6).GetInstanceID());
				_retiredSprites.Add(cached);
				_loadedSprites[key] = val6;
				val5 = val6;
			}
			if (vanillaTextureName != null && (Object)(object)val5.texture != (Object)null && string.IsNullOrEmpty(((Object)val5.texture).name))
			{
				((Object)val5.texture).name = vanillaTextureName;
			}
			return val5;
			IL_026a:
			val2 = val3;
			num8 = targetPPU;
			goto IL_026d;
		}

		private static void PreCorrectAllPPU()
		{
			if (_loadedSprites.Count == 0)
			{
				return;
			}
			Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
			foreach (Sprite val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.texture == (Object)null) && !_ourSpriteIds.Contains(((Object)val).GetInstanceID()) && T2DUtil.IsT2DTexture(((Object)val.texture).name))
				{
					string key = T2DUtil.SpriteKey(T2DUtil.CleanTextureName(((Object)val.texture).name), ((Object)val).name);
					if (_loadedSprites.TryGetValue(key, out var value) && !((Object)(object)value == (Object)null))
					{
						EnsurePPU(key, value, val.pixelsPerUnit, ((Object)val.texture).name, val);
					}
				}
			}
		}

		internal static void HandleLoad(object spriteContainer, Sprite sprite)
		{
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			if (_handling || !HasT2DReplacements || (Object)(object)sprite == (Object)null || (Object)(object)sprite.texture == (Object)null)
			{
				return;
			}
			_handling = true;
			try
			{
				Sprite val = null;
				bool flag = false;
				if (T2DUtil.IsT2DTexture(((Object)sprite.texture).name))
				{
					string text = KeyForSprite(sprite);
					string text2 = T2DUtil.CleanTextureName(((Object)sprite.texture).name);
					flag = _coveredCleanNames.Contains(text2);
					if (_loadedSprites.TryGetValue(text, out var value) && (Object)(object)value != (Object)null && (Object)(object)value.texture != (Object)null)
					{
						val = EnsurePPU(text, value, sprite.pixelsPerUnit, ((Object)sprite.texture).name, sprite);
					}
					else if (Plugin.Config.LogT2DLookupMisses && _emittedMissKeys.Add(text))
					{
						Plugin.Logger.LogWarning((object)("[T2D-Miss] PRIMARY: spriteName='" + ((Object)sprite).name + "' rawTex='" + ((Object)sprite.texture).name + "' cleanTex='" + text2 + "' " + $"key='{text}' covered={flag} " + $"fallbackHasName={_spriteNameToKey.ContainsKey(((Object)sprite).name)}"));
					}
				}
				if ((Object)(object)val == (Object)null && !string.IsNullOrEmpty(((Object)sprite).name) && _spriteNameToKey.TryGetValue(((Object)sprite).name, out var value2) && _loadedSprites.TryGetValue(value2, out var value3) && (Object)(object)value3 != (Object)null && (Object)(object)value3.texture != (Object)null)
				{
					val = EnsurePPU(value2, value3, sprite.pixelsPerUnit, ((Object)sprite.texture).name, sprite);
				}
				if ((Object)(object)val != (Object)null)
				{
					if ((Object)(object)val != (Object)(object)sprite)
					{
						((Object)sprite).hideFlags = (HideFlags)(((Object)sprite).hideFlags | 0x20);
						if ((Object)(object)sprite.texture != (Object)null)
						{
							Texture2D texture = sprite.texture;
							((Object)texture).hideFlags = (HideFlags)(((Object)texture).hideFlags | 0x20);
						}
						if (Plugin.Config.LogTextureSwaps)
						{
							Component val2 = (Component)((spriteContainer is Component) ? spriteContainer : null);
							string text3 = (((Object)(object)val2 != (Object)null) ? ((Object)val2.gameObject).name : "?");
							Vector3 val3 = (((Object)(object)val2 != (Object)null) ? val2.transform.lossyScale : Vector3.one);
							string arg = "";
							Image val4 = (Image)((spriteContainer is Image) ? spriteContainer : null);
							if (val4 != null)
							{
								Rect rect = ((Graphic)val4).rectTransform.rect;
								arg = $" image(type={val4.type} preserveAspect={val4.preserveAspect} " + $"rt={((Rect)(ref rect)).width:F0}x{((Rect)(ref rect)).height:F0})";
							}
							ManualLogSource logger = Plugin.Logger;
							string[] obj = new string[13]
							{
								"[T2D-Size] '",
								((Object)sprite).name,
								"' on '",
								text3,
								"': vanilla ",
								null,
								null,
								null,
								null,
								null,
								null,
								null,
								null
							};
							Rect rect2 = sprite.rect;
							object arg2 = ((Rect)(ref rect2)).width;
							rect2 = sprite.rect;
							obj[5] = $"rect={arg2}x{((Rect)(ref rect2)).height} ppu={sprite.pixelsPerUnit} ";
							obj[6] = $"pivotPx=({sprite.pivot.x:F1},{sprite.pivot.y:F1}) ";
							Bounds bounds = sprite.bounds;
							object arg3 = ((Bounds)(ref bounds)).size.x;
							bounds = sprite.bounds;
							obj[7] = $"bounds={arg3:F2}x{((Bounds)(ref bounds)).size.y:F2} ";
							obj[8] = $"tex={((Texture)sprite.texture).width}x{((Texture)sprite.texture).height} → repl ";
							rect2 = val.rect;
							object arg4 = ((Rect)(ref rect2)).width;
							rect2 = val.rect;
							obj[9] = $"rect={arg4}x{((Rect)(ref rect2)).height} ";
							obj[10] = $"ppu={val.pixelsPerUnit} ";
							bounds = val.bounds;
							object arg5 = ((Bounds)(ref bounds)).size.x;
							bounds = val.bounds;
							obj[11] = $"bounds={arg5:F2}x{((Bounds)(ref bounds)).size.y:F2} ";
							obj[12] = $"scale=({val3.x:F2},{val3.y:F2}){arg}";
							logger.LogInfo((object)string.Concat(obj));
						}
					}
					SetSprite(spriteContainer, val);
					TrackContainer(spriteContainer);
				}
				else if (flag)
				{
					TrackContainer(spriteContainer);
				}
			}
			finally
			{
				_handling = false;
			}
		}

		private static void SetSprite(object container, Sprite sprite)
		{
			SpriteRenderer val = (SpriteRenderer)((container is SpriteRenderer) ? container : null);
			if (val != null)
			{
				val.sprite = sprite;
				return;
			}
			Image val2 = (Image)((container is Image) ? container : null);
			if (val2 != null)
			{
				val2.sprite = sprite;
			}
		}

		private static void TrackContainer(object container)
		{
			SpriteRenderer val = (SpriteRenderer)((container is SpriteRenderer) ? container : null);
			if (val != null)
			{
				if (Plugin.ShowDevHub)
				{
					_knownRenderers.Add(val);
				}
				_replacedSrs.Add(val);
				return;
			}
			Image val2 = (Image)((container is Image) ? container : null);
			if (val2 != null)
			{
				if (Plugin.ShowDevHub)
				{
					_knownImages.Add(val2);
				}
				_replacedImgs.Add(val2);
			}
		}

		internal static string KeyForSprite(Sprite sprite)
		{
			if ((Object)(object)sprite.texture == (Object)null || !T2DUtil.IsT2DTexture(((Object)sprite.texture).name))
			{
				return ((Object)sprite).name;
			}
			return _spriteKeyCache.GetValue(sprite, _spriteKeyCreator);
		}

		internal static bool TryGetStandaloneReplacement(string textureName, out Texture2D replacement)
		{
			replacement = null;
			if (string.IsNullOrEmpty(textureName))
			{
				return false;
			}
			if (_loadedSprites.TryGetValue(textureName, out var value) && (Object)(object)value != (Object)null && (Object)(object)value.texture != (Object)null)
			{
				replacement = value.texture;
				return true;
			}
			return false;
		}

		internal static void RememberCursorCall(Texture2D texture, Vector2 hotspot, CursorMode mode)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)texture == (Object)null) && !string.IsNullOrWhiteSpace(((Object)texture).name))
			{
				_lastCursorName = ((Object)texture).name;
				_lastCursorHotspot = hotspot;
				_lastCursorMode = mode;
				_lastCursorVanillaTex = texture;
				((Object)texture).hideFlags = (HideFlags)(((Object)texture).hideFlags | 0x20);
				_cursorSubstituted = false;
			}
		}

		internal static void MarkCursorSubstituted()
		{
			_cursorSubstituted = true;
		}

		public static void RefreshSubstitutedCursor()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			string text = ((!string.IsNullOrEmpty(_lastCursorName)) ? _lastCursorName : "Cursor");
			if (TryGetStandaloneReplacement(text, out var replacement))
			{
				Cursor.SetCursor(replacement, _lastCursorHotspot, _lastCursorMode);
				_cursorSubstituted = true;
				Plugin.Logger.LogDebug((object)("[T2D-Cursor] Pushed replacement '" + text + "' to OS cursor " + $"({((Texture)replacement).width}x{((Texture)replacement).height}, " + $"hotspot={_lastCursorHotspot}, mode={_lastCursorMode})"));
			}
			else
			{
				if (!_cursorSubstituted)
				{
					return;
				}
				Texture2D val = _lastCursorVanillaTex;
				if ((Object)(object)val == (Object)null && !string.IsNullOrEmpty(_lastCursorName))
				{
					Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
					foreach (Texture2D val2 in array)
					{
						if ((Object)(object)val2 != (Object)null && ((Object)val2).name == _lastCursorName)
						{
							val = val2;
							break;
						}
					}
				}
				Cursor.SetCursor(val, _lastCursorHotspot, _lastCursorMode);
				_cursorSubstituted = false;
				Plugin.Logger.LogInfo((object)("[T2D-Cursor] Reverted OS cursor to " + (((Object)(object)val != (Object)null) ? ("vanilla '" + ((Object)val).name + "'") : "system default") + " (no cursor replacement in the active pack set)"));
			}
		}

		public static void RunWatchedSpriteDiagnostic(string watchName)
		{
			if (Time.realtimeSinceStartup < _diagNextTime)
			{
				return;
			}
			_diagNextTime = Time.realtimeSinceStartup + 1f;
			SpriteRenderer[] array = Resources.FindObjectsOfTypeAll<SpriteRenderer>();
			foreach (SpriteRenderer val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Sprite sprite = val.sprite;
					if (Match(((Object)val).name) || ((Object)(object)sprite != (Object)null && (Match(((Object)sprite).name) || ((Object)(object)sprite.texture != (Object)null && Match(((Object)sprite.texture).name)))))
					{
						EmitSpriteState("SpriteRenderer", ((Object)val).name, ((Component)val).gameObject.activeInHierarchy, sprite, _replacedSrs.Contains(val));
					}
				}
			}
			Image[] array2 = Resources.FindObjectsOfTypeAll<Image>();
			foreach (Image val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Sprite sprite2 = val2.sprite;
					if (Match(((Object)val2).name) || ((Object)(object)sprite2 != (Object)null && (Match(((Object)sprite2).name) || ((Object)(object)sprite2.texture != (Object)null && Match(((Object)sprite2.texture).name)))))
					{
						EmitSpriteState("Image", ((Object)val2).name, ((Component)val2).gameObject.activeInHierarchy, sprite2, _replacedImgs.Contains(val2));
					}
				}
			}
			Renderer[] array3 = Resources.FindObjectsOfTypeAll<Renderer>();
			foreach (Renderer val3 in array3)
			{
				if ((Object)(object)val3 == (Object)null || val3 is SpriteRenderer)
				{
					continue;
				}
				Material sharedMaterial = val3.sharedMaterial;
				Texture val4 = (((Object)(object)sharedMaterial != (Object)null) ? sharedMaterial.mainTexture : null);
				if (!((Object)(object)val4 == (Object)null) && Match(((Object)val4).name))
				{
					string item = "mat:" + ((Object)val3).name + ":" + ((Object)val4).name;
					if (_diagSeen.Add(item))
					{
						Plugin.Logger.LogInfo((object)($"[T2D-Diag] path=MATERIAL renderer='{((Object)val3).name}' active={((Component)val3).gameObject.activeInHierarchy} " + "shader='" + (((Object)(object)sharedMaterial.shader != (Object)null) ? ((Object)sharedMaterial.shader).name : "?") + "' tex='" + ((Object)val4).name + "' — material/standalone path; AssetBundle.Unload would drop this and DontUnloadUnusedAsset does NOT protect against it (Memory Rule #3)."));
					}
				}
			}
			EmitEnrolledFakeNulls();
			bool Match(string n)
			{
				if (!string.IsNullOrEmpty(n))
				{
					return n.IndexOf(watchName, StringComparison.OrdinalIgnoreCase) >= 0;
				}
				return false;
			}
		}

		private static void EmitEnrolledFakeNulls()
		{
			foreach (SpriteRenderer replacedSr in _replacedSrs)
			{
				if (!((Object)(object)replacedSr == (Object)null) && !((Object)(object)replacedSr.sprite != (Object)null) && ((Component)replacedSr).gameObject.activeInHierarchy && _diagSeen.Add($"enrnull:SR:{((Object)replacedSr).GetInstanceID()}"))
				{
					Plugin.Logger.LogInfo((object)("[T2D-Diag] path=ENROLLED-FAKENULL kind=SpriteRenderer obj='" + ((Object)replacedSr).name + "' active=True enrolled=True sprite=<fake-null> — a SpriteRenderer we replaced now holds a null sprite while on-screen (TRANSPARENT). This is the exact failure the name-match sweeps cannot see. Set T2DDiagWatchName to this GO name to also capture the pre-break sprite/texture/cachedRepl state."));
				}
			}
			foreach (Image replacedImg in _replacedImgs)
			{
				if (!((Object)(object)replacedImg == (Object)null) && !((Object)(object)replacedImg.sprite != (Object)null) && ((Component)replacedImg).gameObject.activeInHierarchy && _diagSeen.Add($"enrnull:IMG:{((Object)replacedImg).GetInstanceID()}"))
				{
					Plugin.Logger.LogInfo((object)("[T2D-Diag] path=ENROLLED-FAKENULL kind=Image obj='" + ((Object)replacedImg).name + "' active=True enrolled=True sprite=<fake-null> — an Image we replaced now holds a null sprite while on-screen (TRANSPARENT)."));
				}
			}
		}

		private static void EmitSpriteState(string kind, string objName, bool active, Sprite sprite, bool enrolled)
		{
			bool flag = (Object)(object)sprite == (Object)null;
			string text = (flag ? "<fake-null>" : ((Object)sprite).name);
			bool flag2 = flag || (Object)(object)sprite.texture == (Object)null;
			string text2 = (flag2 ? "<fake-null>" : ((Object)sprite.texture).name);
			string text3 = "n/a";
			if (!flag)
			{
				string key = KeyForSprite(sprite);
				text3 = (_loadedSprites.TryGetValue(key, out var value) ? (((Object)(object)value == (Object)null) ? "FAKE-NULL" : "alive") : ((!_spriteNameToKey.TryGetValue(((Object)sprite).name, out var value2) || !_loadedSprites.TryGetValue(value2, out var value3)) ? "no-key" : (((Object)(object)value3 == (Object)null) ? "FAKE-NULL(fallback)" : "alive(fallback)")));
			}
			bool flag3 = !flag2 && T2DUtil.IsT2DTexture(text2);
			string item = $"{kind}:{objName}:{text}:{flag}:{flag2}:{enrolled}:{text3}";
			if (_diagSeen.Add(item))
			{
				Plugin.Logger.LogInfo((object)($"[T2D-Diag] path=SPRITE kind={kind} obj='{objName}' active={active} " + $"enrolled={enrolled} sprite='{text}' spriteFakeNull={flag} " + $"tex='{text2}' texFakeNull={flag2} t2dName={flag3} cachedRepl={text3}"));
			}
		}

		internal static Sprite RebuildLoadedSprite(string key, float ppu)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			string text = ResolveSourceFile(key);
			if (text == null)
			{
				return null;
			}
			byte[] array = FileCache.ReadBytes(text);
			if (array == null)
			{
				Plugin.Logger.LogWarning((object)("[T2D-Recovery] '" + key + "' fake-null and source re-read failed (" + text + ")."));
				return null;
			}
			Texture2D val = TexUtil.CreateTextureFromBytes(array, markNonReadable: false);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Object)val).hideFlags = (HideFlags)(((Object)val).hideFlags | 0x20);
			SkippedTextureIds.Add(((Object)val).GetInstanceID());
			int num = key.LastIndexOf('/');
			string name = ((num >= 0) ? key.Substring(num + 1) : key);
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), (ppu > 0.5f) ? ppu : 100f);
			((Object)val2).name = name;
			((Object)val2).hideFlags = (HideFlags)32;
			_ourSpriteIds.Add(((Object)val2).GetInstanceID());
			_loadedSprites[key] = val2;
			Plugin.Logger.LogInfo((object)("[T2D-Recovery] Rebuilt fake-null replacement '" + key + "' from disk."));
			return val2;
		}

		private static string ResolveSourceFile(string key)
		{
			if (!_t2dProviders.TryGetValue(key, out var value))
			{
				return null;
			}
			string path = ((value != null) ? Path.Combine(value, "Sprites", "T2D") : Path.Combine(SpriteLoader.LoadPath, "T2D"));
			int num = key.IndexOf('/');
			if (num >= 0)
			{
				string path2 = key.Substring(0, num);
				string text = key.Substring(num + 1);
				string text2 = Path.Combine(path, path2, text + ".png");
				if (!File.Exists(text2))
				{
					return null;
				}
				return text2;
			}
			string text3 = Path.Combine(path, "_standalone", key + ".png");
			if (File.Exists(text3))
			{
				return text3;
			}
			string text4 = Path.Combine(path, key + ".png");
			if (!File.Exists(text4))
			{
				return null;
			}
			return text4;
		}

		public static void PruneSceneState()
		{
			ReplacedTextureIds.Clear();
			SkippedTextureIds.Clear();
			ClearSoftSkips();
			foreach (Sprite value in _loadedSprites.Values)
			{
				if ((Object)(object)value != (Object)null && (Object)(object)value.texture != (Object)null)
				{
					SkippedTextureIds.Add(((Object)value.texture).GetInstanceID());
				}
			}
			InitializedSpriteRenderers.Clear();
			InvalidateUninitCache();
			_replacedSrs.Clear();
			_replacedImgs.Clear();
		}

		public static void ReloadSpritesInScene()
		{
			InvalidateSpriteLookupCache();
			List<Sprite> list = new List<Sprite>(_loadedSprites.Values);
			list.AddRange(_retiredSprites);
			_retiredSprites.Clear();
			HashSet<Sprite> hashSet = new HashSet<Sprite>(list);
			_loadedSprites.Clear();
			_spriteNameToKey.Clear();
			_t2dProviders.Clear();
			_t2dSourceFiles.Clear();
			_coveredCleanNames.Clear();
			_emittedMissKeys.Clear();
			ReplacedTextureIds.Clear();
			SkippedTextureIds.Clear();
			ClearSoftSkips();
			_restoredNames.Clear();
			T2DUtil.ClearCleanNameCache();
			foreach (Sprite item in list)
			{
				if ((Object)(object)item != (Object)null && (Object)(object)item.texture != (Object)null)
				{
					SkippedTextureIds.Add(((Object)item.texture).GetInstanceID());
				}
			}
			_knownRenderers.Clear();
			_knownImages.Clear();
			InitializedSpriteRenderers.Clear();
			InvalidateUninitCache();
			_replacedSrs.Clear();
			_replacedImgs.Clear();
			_lastSeenSpriteIdSr.Clear();
			_lastSeenSpriteIdImg.Clear();
			_lastLoggedSpriteIdSr.Clear();
			_lastLoggedSpriteIdImg.Clear();
			_ourSpriteIds.Clear();
			PreloadAllTextures();
			RegisterFontAtlasIds();
			RegisterPostProcessTextureIds();
			if (SpritesheetOverrides.Count > 0 || HasStoredOriginals)
			{
				Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
				foreach (Texture2D val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						bool flag = SkippedTextureIds.Contains(((Object)val).GetInstanceID());
						if (!TrySwapTexture(val) && !flag)
						{
							TryRestoreTexture(val);
						}
					}
				}
			}
			SpriteRenderer[] array2 = Resources.FindObjectsOfTypeAll<SpriteRenderer>();
			Image[] array3 = Resources.FindObjectsOfTypeAll<Image>();
			SpriteRenderer[] array4 = array2;
			foreach (SpriteRenderer val2 in array4)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.sprite == (Object)null) && !((Object)(object)val2.sprite.texture == (Object)null))
				{
					HandleLoad(val2, val2.sprite);
				}
			}
			Image[] array5 = array3;
			foreach (Image val3 in array5)
			{
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.sprite == (Object)null) && !((Object)(object)val3.sprite.texture == (Object)null))
				{
					HandleLoad(val3, val3.sprite);
				}
			}
			PreCorrectAllPPU();
			Dictionary<string, Sprite> vanillaByQual;
			Dictionary<string, Sprite> vanillaByName;
			HashSet<string> ambiguousNames;
			if (list.Count > 0)
			{
				vanillaByQual = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);
				vanillaByName = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);
				ambiguousNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				Sprite[] array6 = Resources.FindObjectsOfTypeAll<Sprite>();
				foreach (Sprite val4 in array6)
				{
					if ((Object)(object)val4 == (Object)null || hashSet.Contains(val4))
					{
						continue;
					}
					if ((Object)(object)val4.texture != (Object)null)
					{
						string key = ((Object)val4.texture).name + "/" + ((Object)val4).name;
						if (!vanillaByQual.ContainsKey(key))
						{
							vanillaByQual[key] = val4;
						}
					}
					if (!vanillaByName.ContainsKey(((Object)val4).name))
					{
						vanillaByName[((Object)val4).name] = val4;
					}
					else
					{
						ambiguousNames.Add(((Object)val4).name);
					}
				}
				int num = 0;
				int num2 = 0;
				_enforcing = true;
				try
				{
					array4 = array2;
					foreach (SpriteRenderer val5 in array4)
					{
						if (!((Object)(object)val5 == (Object)null) && !((Object)(object)val5.sprite == (Object)null) && hashSet.Contains(val5.sprite))
						{
							Sprite value;
							Sprite val6 = (_loadedSprites.TryGetValue(KeyForSprite(val5.sprite), out value) ? value : FindVanilla(val5.sprite));
							if ((Object)(object)val6 != (Object)null)
							{
								val5.sprite = val6;
								num++;
								continue;
							}
							Plugin.Logger.LogWarning((object)("[T2D-Revert] SpriteRenderer '" + ((Object)val5).name + "': old sprite '" + ((Object)val5.sprite).name + "' has no replacement or vanilla match"));
							num2++;
						}
					}
					array5 = array3;
					foreach (Image val7 in array5)
					{
						if (!((Object)(object)val7 == (Object)null) && !((Object)(object)val7.sprite == (Object)null) && hashSet.Contains(val7.sprite))
						{
							Sprite value2;
							Sprite val8 = (_loadedSprites.TryGetValue(KeyForSprite(val7.sprite), out value2) ? value2 : FindVanilla(val7.sprite));
							if ((Object)(object)val8 != (Object)null)
							{
								val7.sprite = val8;
								num++;
								continue;
							}
							Plugin.Logger.LogWarning((object)("[T2D-Revert] Image '" + ((Object)val7).name + "': old sprite '" + ((Object)val7.sprite).name + "' has no replacement or vanilla match"));
							num2++;
						}
					}
				}
				finally
				{
					_enforcing = false;
				}
				Plugin.Logger.LogDebug((object)$"[T2D-Reload] Revert sweep: {list.Count} old sprites, {vanillaByName.Count} vanilla candidates, {num} reverted, {num2} missed");
				if (num2 > 0)
				{
					Plugin.Logger.LogWarning((object)$"[T2D-Reload] {num2} sprite(s) could not be reverted — see [T2D-Revert] warnings above for names");
				}
			}
			HashSet<int> hashSet2 = new HashSet<int>();
			array4 = array2;
			foreach (SpriteRenderer val9 in array4)
			{
				if (!((Object)(object)val9 == (Object)null) && !((Object)(object)val9.sprite == (Object)null) && hashSet.Contains(val9.sprite))
				{
					hashSet2.Add(((Object)val9.sprite).GetInstanceID());
				}
			}
			array5 = array3;
			foreach (Image val10 in array5)
			{
				if (!((Object)(object)val10 == (Object)null) && !((Object)(object)val10.sprite == (Object)null) && hashSet.Contains(val10.sprite))
				{
					hashSet2.Add(((Object)val10.sprite).GetInstanceID());
				}
			}
			HashSet<int> hashSet3 = new HashSet<int>();
			foreach (Sprite item2 in list)
			{
				if (!((Object)(object)item2 == (Object)null) && !((Object)(object)item2.texture == (Object)null) && hashSet2.Contains(((Object)item2).GetInstanceID()))
				{
					hashSet3.Add(((Object)item2.texture).GetInstanceID());
				}
			}
			int num3 = 0;
			int num4 = 0;
			foreach (Sprite item3 in list)
			{
				if ((Object)(object)item3 == (Object)null)
				{
					continue;
				}
				if (hashSet2.Contains(((Object)item3).GetInstanceID()))
				{
					num4++;
					continue;
				}
				if ((Object)(object)item3.texture != (Object)null && !hashSet3.Contains(((Object)item3.texture).GetInstanceID()))
				{
					Object.Destroy((Object)(object)item3.texture);
				}
				Object.Destroy((Object)(object)item3);
				num3++;
			}
			if (num4 > 0)
			{
				Plugin.Logger.LogWarning((object)($"[T2D-Reload] Destroy skipped for {num4} old sprite(s) still held by live renderers; " + $"{num3} destroyed. Skip is intentional (avoids fake-null raycast hazard); " + "a non-zero skip count means the revert sweep couldn't match those sprite names to new/vanilla candidates."));
			}
			Sprite FindVanilla(Sprite old)
			{
				if ((Object)(object)old.texture != (Object)null && vanillaByQual.TryGetValue(((Object)old.texture).name + "/" + ((Object)old).name, out var value3))
				{
					return value3;
				}
				if (!ambiguousNames.Contains(((Object)old).name) && vanillaByName.TryGetValue(((Object)old).name, out var value4))
				{
					return value4;
				}
				return null;
			}
		}

		public static void InvalidateSpritesheet(string texName)
		{
			string text = T2DUtil.CleanTextureName(texName);
			SpritesheetOverrides.Remove(texName);
			ReplacedTextureIds.Clear();
			SkippedTextureIds.Clear();
			ClearSoftSkips();
			string prefix = text + "/";
			foreach (string item in _loadedSprites.Keys.Where((string k) => k.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)).ToList())
			{
				_loadedSprites.Remove(item);
			}
		}

		private static bool IsCacheRefreshDue()
		{
			if (!_cacheInvalidated)
			{
				return Time.realtimeSinceStartup >= _nextCacheRefreshTime;
			}
			return true;
		}

		private static void MarkCacheRefreshed()
		{
			_nextCacheRefreshTime = Time.realtimeSinceStartup + UninitRefreshSeconds;
			_cacheInvalidated = false;
			DevProfiler.RecordUninitRefresh();
		}

		public static void InvalidateUninitCache()
		{
			_cacheInvalidated = true;
		}

		public static void NotifySetterCall()
		{
			_setterCallsThisFrame++;
		}

		public static void OnSceneLoaded()
		{
			InitializedSpriteRenderers.Clear();
			_cacheInvalidated = true;
			_lastSeenSpriteIdSr.Clear();
			_lastSeenSpriteIdImg.Clear();
			_lastLoggedSpriteIdSr.Clear();
			_lastLoggedSpriteIdImg.Clear();
		}

		public static void AdvanceSetterTracking()
		{
			_prevFrameSetterCalls = _setterCallsThisFrame;
			_setterCallsThisFrame = 0;
		}

		public static void ScanForLogTriggers()
		{
			if (!IsT2DLogActive)
			{
				return;
			}
			if (!HasT2DReplacements && (_cachedSrArray.Length == 0 || IsCacheRefreshDue()))
			{
				_cachedSrArray = Object.FindObjectsByType<SpriteRenderer>((FindObjectsSortMode)0);
				_cachedImgArray = Object.FindObjectsByType<Image>((FindObjectsSortMode)0);
				MarkCacheRefreshed();
			}
			SpriteRenderer[] cachedSrArray = _cachedSrArray;
			foreach (SpriteRenderer val in cachedSrArray)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Sprite sprite = val.sprite;
				if ((Object)(object)sprite == (Object)null)
				{
					continue;
				}
				Texture2D texture = sprite.texture;
				if ((Object)(object)texture == (Object)null)
				{
					continue;
				}
				string name = ((Object)texture).name;
				if (!string.IsNullOrEmpty(name) && T2DUtil.IsT2DTexture(name))
				{
					int instanceID = ((Object)val).GetInstanceID();
					int instanceID2 = ((Object)sprite).GetInstanceID();
					if (!_lastLoggedSpriteIdSr.TryGetValue(instanceID, out var value) || value != instanceID2)
					{
						_lastLoggedSpriteIdSr[instanceID] = instanceID2;
						RaiseT2DTrigger(name, T2DUtil.CleanTextureName(name), ((Object)sprite).name);
					}
				}
			}
			Image[] cachedImgArray = _cachedImgArray;
			foreach (Image val2 in cachedImgArray)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Sprite sprite2 = val2.sprite;
				if ((Object)(object)sprite2 == (Object)null)
				{
					continue;
				}
				Texture2D texture2 = sprite2.texture;
				if ((Object)(object)texture2 == (Object)null)
				{
					continue;
				}
				string name2 = ((Object)texture2).name;
				if (!string.IsNullOrEmpty(name2) && T2DUtil.IsT2DTexture(name2))
				{
					int instanceID3 = ((Object)val2).GetInstanceID();
					int instanceID4 = ((Object)sprite2).GetInstanceID();
					if (!_lastLoggedSpriteIdImg.TryGetValue(instanceID3, out var value2) || value2 != instanceID4)
					{
						_lastLoggedSpriteIdImg[instanceID3] = instanceID4;
						RaiseT2DTrigger(name2, T2DUtil.CleanTextureName(name2), ((Object)sprite2).name);
					}
				}
			}
		}

		public static void ResetLogScanState()
		{
			_lastLoggedSpriteIdSr.Clear();
			_lastLoggedSpriteIdImg.Clear();
		}

		public static void CheckForUninitializedSprites()
		{
			StitchworkConfig config = Plugin.Config;
			if ((config != null && config.DisableUninitCheck) || !HasT2DReplacements)
			{
				return;
			}
			if (IsCacheRefreshDue())
			{
				long num = DevProfiler.SnapshotHeapBytes();
				StitchworkConfig config2 = Plugin.Config;
				int num2 = ((config2 != null && config2.ThoroughT2DEnrollment) ? 1 : 0);
				_cachedSrArray = Object.FindObjectsByType<SpriteRenderer>((FindObjectsInactive)num2, (FindObjectsSortMode)0);
				long num3 = DevProfiler.SnapshotHeapBytes();
				DevProfiler.AddOpAlloc("UninitCheck.FindSR", num3 - num);
				_cachedImgArray = Object.FindObjectsByType<Image>((FindObjectsInactive)num2, (FindObjectsSortMode)0);
				long num4 = DevProfiler.SnapshotHeapBytes();
				DevProfiler.AddOpAlloc("UninitCheck.FindImg", num4 - num3);
				MarkCacheRefreshed();
			}
			long num5 = DevProfiler.SnapshotHeapBytes();
			int num6 = 0;
			SpriteRenderer[] cachedSrArray = _cachedSrArray;
			foreach (SpriteRenderer val in cachedSrArray)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sprite == (Object)null))
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (!InitializedSpriteRenderers.Contains(instanceID))
					{
						val.sprite = val.sprite;
						InitializedSpriteRenderers.Add(instanceID);
						num6++;
					}
				}
			}
			long num7 = DevProfiler.SnapshotHeapBytes();
			DevProfiler.AddOpAlloc("UninitCheck.SRloop", num7 - num5);
			int num8 = 0;
			Image[] cachedImgArray = _cachedImgArray;
			foreach (Image val2 in cachedImgArray)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.sprite == (Object)null))
				{
					int instanceID2 = ((Object)val2).GetInstanceID();
					if (!InitializedSpriteRenderers.Contains(instanceID2))
					{
						val2.sprite = val2.sprite;
						InitializedSpriteRenderers.Add(instanceID2);
						num8++;
					}
				}
			}
			long num9 = DevProfiler.SnapshotHeapBytes();
			DevProfiler.AddOpAlloc("UninitCheck.Imgloop", num9 - num7);
			DevProfiler.RecordUninitCounts(_cachedSrArray.Length, _cachedImgArray.Length, num6, num8);
		}

		public static void EnforceT2DReplacements()
		{
			if (!HasT2DReplacements || (_replacedSrs.Count == 0 && _replacedImgs.Count == 0))
			{
				return;
			}
			_enforcing = true;
			try
			{
				foreach (SpriteRenderer replacedSr in _replacedSrs)
				{
					if ((Object)(object)replacedSr == (Object)null)
					{
						continue;
					}
					Sprite sprite = replacedSr.sprite;
					if ((Object)(object)sprite == (Object)null)
					{
						continue;
					}
					int instanceID = ((Object)replacedSr).GetInstanceID();
					int instanceID2 = ((Object)sprite).GetInstanceID();
					if (!_lastSeenSpriteIdSr.TryGetValue(instanceID, out var value) || value != instanceID2)
					{
						if (TryGetReplacement(sprite, out var replacement) && (Object)(object)sprite != (Object)(object)replacement)
						{
							replacedSr.sprite = replacement;
							_lastSeenSpriteIdSr[instanceID] = ((Object)replacement).GetInstanceID();
						}
						else
						{
							_lastSeenSpriteIdSr[instanceID] = instanceID2;
						}
					}
				}
				foreach (Image replacedImg in _replacedImgs)
				{
					if ((Object)(object)replacedImg == (Object)null)
					{
						continue;
					}
					Sprite sprite2 = replacedImg.sprite;
					if ((Object)(object)sprite2 == (Object)null)
					{
						continue;
					}
					int instanceID3 = ((Object)replacedImg).GetInstanceID();
					int instanceID4 = ((Object)sprite2).GetInstanceID();
					if (!_lastSeenSpriteIdImg.TryGetValue(instanceID3, out var value2) || value2 != instanceID4)
					{
						if (TryGetReplacement(sprite2, out var replacement2) && (Object)(object)sprite2 != (Object)(object)replacement2)
						{
							replacedImg.sprite = replacement2;
							_lastSeenSpriteIdImg[instanceID3] = ((Object)replacement2).GetInstanceID();
						}
						else
						{
							_lastSeenSpriteIdImg[instanceID3] = instanceID4;
						}
					}
				}
			}
			finally
			{
				_enforcing = false;
			}
			if (++_enforcePruneCounter >= 300)
			{
				_enforcePruneCounter = 0;
				PruneEnforcementCaches();
			}
		}

		private static void PruneEnforcementCaches()
		{
			HashSet<int> liveSrIds = new HashSet<int>();
			_replacedSrs.RemoveWhere(delegate(SpriteRenderer sr)
			{
				if ((Object)(object)sr == (Object)null)
				{
					return true;
				}
				liveSrIds.Add(((Object)sr).GetInstanceID());
				return false;
			});
			if (_lastSeenSpriteIdSr.Count > liveSrIds.Count)
			{
				List<int> list = new List<int>();
				foreach (int key in _lastSeenSpriteIdSr.Keys)
				{
					if (!liveSrIds.Contains(key))
					{
						list.Add(key);
					}
				}
				foreach (int item in list)
				{
					_lastSeenSpriteIdSr.Remove(item);
				}
			}
			HashSet<int> liveImgIds = new HashSet<int>();
			_replacedImgs.RemoveWhere(delegate(Image img)
			{
				if ((Object)(object)img == (Object)null)
				{
					return true;
				}
				liveImgIds.Add(((Object)img).GetInstanceID());
				return false;
			});
			if (_lastSeenSpriteIdImg.Count <= liveImgIds.Count)
			{
				return;
			}
			List<int> list2 = new List<int>();
			foreach (int key2 in _lastSeenSpriteIdImg.Keys)
			{
				if (!liveImgIds.Contains(key2))
				{
					list2.Add(key2);
				}
			}
			foreach (int item2 in list2)
			{
				_lastSeenSpriteIdImg.Remove(item2);
			}
		}

		private static bool TryGetReplacement(Sprite sprite, out Sprite replacement)
		{
			if (ResolveOrRebuild(KeyForSprite(sprite), sprite, out replacement))
			{
				return true;
			}
			if (_spriteNameToKey.TryGetValue(((Object)sprite).name, out var value) && ResolveOrRebuild(value, sprite, out replacement))
			{
				return true;
			}
			replacement = null;
			return false;
		}

		private static bool ResolveOrRebuild(string key, Sprite live, out Sprite replacement)
		{
			if (!_loadedSprites.TryGetValue(key, out replacement))
			{
				return false;
			}
			if ((Object)(object)replacement != (Object)null)
			{
				replacement = EnsurePPU(key, replacement, live.pixelsPerUnit, ((Object)(object)live.texture != (Object)null) ? ((Object)live.texture).name : null, live);
				return (Object)(object)replacement != (Object)null;
			}
			replacement = RebuildLoadedSprite(key, live.pixelsPerUnit);
			return (Object)(object)replacement != (Object)null;
		}

		internal static void ClearSoftSkips()
		{
			SoftSkippedTextureIds.Clear();
		}

		private static void InitFontBridge()
		{
			if (_fontBridgeInit)
			{
				return;
			}
			_fontBridgeInit = true;
			_tmpFontAssetType = AccessTools.TypeByName("TMProOld.TMP_FontAsset");
			if (_tmpFontAssetType == null)
			{
				Plugin.Logger.LogDebug((object)"[T2D] TMProOld.TMP_FontAsset not resolvable; font-atlas hard-ban skipped");
				return;
			}
			_fontAssetAtlasMember = ResolveAtlasMember();
			if (_fontAssetAtlasMember == null)
			{
				Plugin.Logger.LogDebug((object)"[T2D] TMProOld.TMP_FontAsset primary atlas member not resolvable; falling back to name-pattern denylist (IsLikelyFontAtlasName).");
			}
			else
			{
				Plugin.Logger.LogInfo((object)("[T2D] TMProOld.TMP_FontAsset primary atlas resolved via " + DescribeMember(_fontAssetAtlasMember)));
			}
			_fontAssetAtlasTexturesMember = ResolveFontAssetMember("atlasTextures", "m_AtlasTextures");
			if (_fontAssetAtlasTexturesMember == null)
			{
				Plugin.Logger.LogDebug((object)"[T2D] TMProOld.TMP_FontAsset.atlasTextures not resolvable — Dynamic-mode spillover atlases will not be hard-banned");
			}
			_fontAssetFallbackTableMember = ResolveFontAssetMember("fallbackFontAssetTable", "fallbackFontAssets");
			if (_fontAssetFallbackTableMember == null)
			{
				Plugin.Logger.LogDebug((object)"[T2D] TMProOld.TMP_FontAsset fallback list not resolvable — fallback fonts will not be recursively hard-banned");
			}
		}

		private static MemberInfo ResolveAtlasMember()
		{
			string[] array = new string[4] { "atlas", "atlasTexture", "m_AtlasTexture", "_atlas" };
			string[] array2 = array;
			foreach (string name in array2)
			{
				PropertyInfo property = _tmpFontAssetType.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && typeof(Texture2D).IsAssignableFrom(property.PropertyType))
				{
					return property;
				}
			}
			array2 = array;
			foreach (string name2 in array2)
			{
				FieldInfo field = _tmpFontAssetType.GetField(name2, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null && typeof(Texture2D).IsAssignableFrom(field.FieldType))
				{
					return field;
				}
			}
			PropertyInfo[] properties = _tmpFontAssetType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.PropertyType == typeof(Texture2D) && propertyInfo.GetIndexParameters().Length == 0)
				{
					return propertyInfo;
				}
			}
			FieldInfo[] fields = _tmpFontAssetType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (fieldInfo.FieldType == typeof(Texture2D))
				{
					return fieldInfo;
				}
			}
			return null;
		}

		private static string DescribeMember(MemberInfo m)
		{
			if (!(m is PropertyInfo propertyInfo))
			{
				if (m is FieldInfo fieldInfo)
				{
					return "field '" + fieldInfo.Name + "' (type " + fieldInfo.FieldType.Name + ")";
				}
				return m?.Name ?? "<null>";
			}
			return "property '" + propertyInfo.Name + "' (type " + propertyInfo.PropertyType.Name + ")";
		}

		private static MemberInfo ResolveFontAssetMember(string propName, string fieldName)
		{
			PropertyInfo property = _tmpFontAssetType.GetProperty(propName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				return property;
			}
			return _tmpFontAssetType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}

		private static object ReadMember(MemberInfo m, object target)
		{
			if (m is PropertyInfo propertyInfo)
			{
				return propertyInfo.GetValue(target);
			}
			if (m is FieldInfo fieldInfo)
			{
				return fieldInfo.GetValue(target);
			}
			return null;
		}

		internal static bool IsLikelyFontAtlasName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (name.Length >= 6 && name.EndsWith(" Atlas", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (name.IndexOf("font", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (name.IndexOf("SDF", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			string[] array = new string[10] { "Noto", "SourceHan", "Liberation", "Roboto", "OpenSans", "Arial", "Helvetica", "Lato", "Tahoma", "Verdana" };
			foreach (string value in array)
			{
				if (name.StartsWith(value, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsLikelyEngineBuiltin(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (name.Length > 5 && (name[0] == 'U' || name[0] == 'u') && name.StartsWith("Unity", StringComparison.OrdinalIgnoreCase))
			{
				char c = name[5];
				if (c >= 'A' && c <= 'Z')
				{
					return true;
				}
			}
			if (name.StartsWith("tk2dCamera ", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (name.StartsWith("Default-", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (name.Equals("Default Sprite Asset", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return false;
		}

		internal static bool IsKnownBuiltinByNameAndDim(string name, int w, int h)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			switch (name)
			{
			case "button":
			case "button active":
			case "button hover":
			case "textfield":
			case "textfield hover":
			case "vertical scrollbar thumb":
			case "horizontal scrollbar thumb":
				if (w == 12)
				{
					return h == 12;
				}
				return false;
			case "vertical scrollbar":
				if (w == 15)
				{
					return h == 18;
				}
				return false;
			case "horizontal scrollbar":
				if (w == 18)
				{
					return h == 15;
				}
				return false;
			case "toggle":
				if (w == 20)
				{
					return h == 20;
				}
				return false;
			case "window":
			case "box":
				if (w == 16)
				{
					return h == 16;
				}
				return false;
			default:
				return false;
			}
		}

		internal static int RegisterFontAtlasIds()
		{
			InitFontBridge();
			if (_tmpFontAssetType == null || _fontAssetAtlasMember == null)
			{
				return 0;
			}
			int num = 0;
			HashSet<int> visited = new HashSet<int>();
			Object[] array = Resources.FindObjectsOfTypeAll(_tmpFontAssetType);
			foreach (Object asset in array)
			{
				num += BanFontAssetRecursive(asset, visited);
			}
			if (num > 0)
			{
				Plugin.Logger.LogDebug((object)$"[T2D] Hard-banned {num} font atlas texture(s) from TrySwapTexture");
			}
			return num;
		}

		private static int BanFontAssetRecursive(Object asset, HashSet<int> visited)
		{
			if (asset == (Object)null)
			{
				return 0;
			}
			if (!visited.Add(asset.GetInstanceID()))
			{
				return 0;
			}
			int num = 0;
			if (_fontAssetAtlasMember != null)
			{
				object obj = ReadMember(_fontAssetAtlasMember, asset);
				Texture2D val = (Texture2D)((obj is Texture2D) ? obj : null);
				if (val != null && SkippedTextureIds.Add(((Object)val).GetInstanceID()))
				{
					num++;
				}
			}
			if (_fontAssetAtlasTexturesMember != null)
			{
				object obj2 = ReadMember(_fontAssetAtlasTexturesMember, asset);
				if (obj2 is Texture2D[] array)
				{
					Texture2D[] array2 = array;
					foreach (Texture2D val2 in array2)
					{
						if ((Object)(object)val2 != (Object)null && SkippedTextureIds.Add(((Object)val2).GetInstanceID()))
						{
							num++;
						}
					}
				}
				else if (obj2 is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						Texture2D val3 = (Texture2D)((item is Texture2D) ? item : null);
						if (val3 != null && SkippedTextureIds.Add(((Object)val3).GetInstanceID()))
						{
							num++;
						}
					}
				}
			}
			if (_fontAssetFallbackTableMember != null && ReadMember(_fontAssetFallbackTableMember, asset) is IEnumerable enumerable2)
			{
				foreach (object item2 in enumerable2)
				{
					Object val4 = (Object)((item2 is Object) ? item2 : null);
					if (val4 != null)
					{
						num += BanFontAssetRecursive(val4, visited);
					}
				}
			}
			return num;
		}

		private static void InitPostProcessBridge()
		{
			if (_ppBridgeInit)
			{
				return;
			}
			_ppBridgeInit = true;
			_ppProfileType = AccessTools.TypeByName("UnityEngine.Rendering.PostProcessing.PostProcessProfile");
			if (_ppProfileType == null)
			{
				Plugin.Logger.LogDebug((object)"[T2D] PostProcessing.PostProcessProfile not resolvable; LUT bridge skipped (name-pattern denylist still protects via IsLikelyEngineBuiltin tk2dCamera prefix).");
				return;
			}
			_ppProfileSettingsField = _ppProfileType.GetField("settings", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (_ppProfileSettingsField == null)
			{
				Plugin.Logger.LogDebug((object)"[T2D] PostProcessProfile.settings field not resolvable; LUT bridge skipped.");
				_ppProfileType = null;
			}
			else
			{
				_ppParamOverrideType = AccessTools.TypeByName("UnityEngine.Rendering.PostProcessing.ParameterOverride`1");
				Plugin.Logger.LogInfo((object)("[T2D] PostProcessing bridge resolved: profile.settings field present" + ((_ppParamOverrideType != null) ? ", ParameterOverride<T> located" : "")));
			}
		}

		internal static int RegisterPostProcessTextureIds()
		{
			InitPostProcessBridge();
			if (_ppProfileType == null)
			{
				return 0;
			}
			int num = 0;
			Object[] array = Resources.FindObjectsOfTypeAll(_ppProfileType);
			foreach (Object val in array)
			{
				if (val == (Object)null || !(_ppProfileSettingsField.GetValue(val) is IEnumerable enumerable))
				{
					continue;
				}
				foreach (object item in enumerable)
				{
					if (item == null)
					{
						continue;
					}
					FieldInfo[] fields = item.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (FieldInfo fieldInfo in fields)
					{
						object value = fieldInfo.GetValue(item);
						if (value == null)
						{
							continue;
						}
						Texture val2 = (Texture)((value is Texture) ? value : null);
						if (val2 != null && SkippedTextureIds.Add(((Object)val2).GetInstanceID()))
						{
							num++;
						}
						FieldInfo fieldInfo2 = fieldInfo.FieldType.GetField("value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? fieldInfo.FieldType.GetField("m_Value", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (fieldInfo2 != null)
						{
							object? value2 = fieldInfo2.GetValue(value);
							Texture val3 = (Texture)((value2 is Texture) ? value2 : null);
							if (val3 != null && SkippedTextureIds.Add(((Object)val3).GetInstanceID()))
							{
								num++;
							}
						}
					}
				}
			}
			if (num > 0)
			{
				Plugin.Logger.LogDebug((object)$"[T2D] Hard-banned {num} post-process texture(s) from TrySwapTexture");
			}
			return num;
		}

		private static void CheckTrackingCapAndMaybeFlush()
		{
			if (ReplacedTextureIds.Count > 16384 || SkippedTextureIds.Count > 16384 || SoftSkippedTextureIds.Count > 16384)
			{
				Plugin.Logger.LogInfo((object)($"[T2D] Tracking sets exceeded cap ({16384}) — flushing " + $"(replaced={ReplacedTextureIds.Count}, hardSkip={SkippedTextureIds.Count}, " + $"softSkip={SoftSkippedTextureIds.Count}). TrySwapTexture will re-evaluate " + "textures on next reference."));
				ReplacedTextureIds.Clear();
				SkippedTextureIds.Clear();
				SoftSkippedTextureIds.Clear();
			}
		}

		internal static bool TryGetOriginalPngBytes(string texName, out byte[] png)
		{
			return _originalTextureData.TryGetValue(texName, out png);
		}

		internal static bool TrySwapTexture(Texture2D tex)
		{
			if ((Object)(object)tex == (Object)null)
			{
				return false;
			}
			CheckTrackingCapAndMaybeFlush();
			int instanceID = ((Object)tex).GetInstanceID();
			if (ReplacedTextureIds.Contains(instanceID))
			{
				return true;
			}
			if (SkippedTextureIds.Contains(instanceID))
			{
				return false;
			}
			if (SoftSkippedTextureIds.Contains(instanceID))
			{
				return false;
			}
			if (string.IsNullOrEmpty(((Object)tex).name))
			{
				SkippedTextureIds.Add(instanceID);
				return false;
			}
			if (IsLikelyFontAtlasName(((Object)tex).name))
			{
				SkippedTextureIds.Add(instanceID);
				if (Plugin.Config.LogTextureSwaps)
				{
					Plugin.Logger.LogInfo((object)("[T2D] denylist refused swap on '" + ((Object)tex).name + "' " + $"({((Texture)tex).width}x{((Texture)tex).height}) — name matches font-atlas pattern."));
				}
				return false;
			}
			if (IsLikelyEngineBuiltin(((Object)tex).name) || IsKnownBuiltinByNameAndDim(((Object)tex).name, ((Texture)tex).width, ((Texture)tex).height))
			{
				SkippedTextureIds.Add(instanceID);
				if (Plugin.Config.LogTextureSwaps)
				{
					Plugin.Logger.LogInfo((object)("[T2D] denylist refused swap on '" + ((Object)tex).name + "' " + $"({((Texture)tex).width}x{((Texture)tex).height}) — engine built-in."));
				}
				return false;
			}
			string text = T2DUtil.CleanTextureName(((Object)tex).name);
			if (!SpritesheetOverrides.TryGetValue(((Object)tex).name, out (byte[], int, int) value) && !SpritesheetOverrides.TryGetValue(text, out value))
			{
				value = default((byte[], int, int));
				string text2 = null;
				if (T2DUtil.IsT2DTexture(((Object)tex).name))
				{
					int num = T2DUtil.AtlasIndexFromRaw(((Object)tex).name);
					foreach (KeyValuePair<string, (byte[], int, int)> spritesheetOverride in SpritesheetOverrides)
					{
						if (!string.Equals(T2DUtil.CleanTextureName(spritesheetOverride.Key), text, StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						int num2 = T2DUtil.AtlasIndexFromRaw(spritesheetOverride.Key);
						if (num < 0 || num2 < 0 || num == num2)
						{
							if (spritesheetOverride.Value.Item2 == ((Texture)tex).width && spritesheetOverride.Value.Item3 == ((Texture)tex).height)
							{
								value = spritesheetOverride.Value;
								text2 = spritesheetOverride.Key;
								break;
							}
							if (T2DUtil.IsT2DTexture(spritesheetOverride.Key) && _staleSheetWarned.Add(spritesheetOverride.Key))
							{
								Plugin.Logger.LogWarning((object)("[T2D] Sheet '" + spritesheetOverride.Key + "' matches '" + text + "' by name but not by size " + $"({spritesheetOverride.Value.Item2}x{spritesheetOverride.Value.Item3} vs runtime {((Texture)tex).width}x{((Texture)tex).height}) — " + "authored for a different game build; NOT applied. The art needs re-authoring against the current atlas."));
							}
						}
					}
				}
				if (value.Item1 == null)
				{
					SoftSkippedTextureIds.Add(instanceID);
					Plugin.Logger.LogDebug((object)("[T2D] Soft-skip '" + ((Object)tex).name + "' (clean='" + text + "', " + $"{((Texture)tex).width}x{((Texture)tex).height}) — no override matched; will retry after next rebuild"));
					return false;
				}
				bool flag = text2 != null && T2DUtil.IsT2DTexture(text2) && !string.Equals(text2, ((Object)tex).name, StringComparison.OrdinalIgnoreCase);
				Plugin.Logger.LogInfo((object)("[T2D] Fuzzy match for '" + ((Object)tex).name + "' → clean name '" + text + "' " + $"({((Texture)tex).width}x{((Texture)tex).height})" + (flag ? (" — NOTE: sheet file '" + text2 + "' carries a different build's atlas hash. Applied by name+size, but if this art looks scrambled the update repacked the atlas layout — the sheet needs re-authoring (or convert to per-sprite files while a matching build is available).") : "")));
			}
			if (((Texture)tex).width != value.Item2 || ((Texture)tex).height != value.Item3)
			{
				if (((Texture)tex).width == 0 || ((Texture)tex).height == 0)
				{
					SoftSkippedTextureIds.Add(instanceID);
					return false;
				}
				Plugin.Logger.LogWarning((object)("[T2D] Spritesheet size mismatch for '" + text + "': " + $"runtime texture '{((Object)tex).name}' is {((Texture)tex).width}x{((Texture)tex).height}, " + $"replacement PNG is {value.Item2}x{value.Item3}. " + $"Skipping. (texture ID: {instanceID})"));
				SkippedTextureIds.Add(instanceID);
				return false;
			}
			if (!_originalTextureData.ContainsKey(((Object)tex).name))
			{
				byte[] array = CaptureTextureAsPng(tex);
				if (array != null)
				{
					_originalTextureData[((Object)tex).name] = array;
				}
			}
			if (ImageConversion.LoadImage(tex, value.Item1))
			{
				ReplacedTextureIds.Add(instanceID);
				_restoredNames.Remove(((Object)tex).name);
				string value2;
				string value3;
				string arg = (_sheetProviders.TryGetValue(text, out value2) ? (value2 ?? "<base>") : (_sheetProviders.TryGetValue(((Object)tex).name, out value3) ? (value3 ?? "<base>") : "<unknown>"));
				string text3 = "[T2D] swap '" + text + "' applied to '" + ((Object)tex).name + "' " + $"({((Texture)tex).width}x{((Texture)tex).height}) from pack '{arg}'";
				if (Plugin.Config.LogTextureSwaps)
				{
					Plugin.Logger.LogInfo((object)text3);
				}
				else
				{
					Plugin.Logger.LogDebug((object)text3);
				}
				if (Plugin.Config.ConvertSpritesheets)
				{
					ConvertSpritesheet(tex, text);
				}
				return true;
			}
			Plugin.Logger.LogWarning((object)("[T2D] LoadImage failed for '" + text + "' on texture '" + ((Object)tex).name + "'"));
			SkippedTextureIds.Add(instanceID);
			return false;
		}

		private static bool IsGenericRuntimeName(string name)
		{
			if (string.IsNullOrEmpty(name) || name.Length > 12)
			{
				return false;
			}
			string text = name.ToLowerInvariant();
			string[] array = new string[7] { "atlas", "texture", "sheet", "material", "image", "tex", "img" };
			string text4;
			foreach (string text2 in array)
			{
				if (!text.StartsWith(text2))
				{
					continue;
				}
				string text3 = text.Substring(text2.Length);
				if (text3.Length == 0)
				{
					return true;
				}
				bool flag = true;
				text4 = text3;
				foreach (char c in text4)
				{
					if (c < '0' || c > '9')
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return true;
				}
			}
			bool result = true;
			text4 = text;
			foreach (char c2 in text4)
			{
				if (c2 < '0' || c2 > '9')
				{
					result = false;
					break;
				}
			}
			return result;
		}

		private static void BuildSpritesheetOverrides()
		{
			Dictionary<string, (byte[] PngData, int Width, int Height)> previousOverrides = new Dictionary<string, (byte[], int, int)>(SpritesheetOverrides, StringComparer.OrdinalIgnoreCase);
			Dictionary<string, string> previousProviders = new Dictionary<string, string>(_sheetProviders, StringComparer.OrdinalIgnoreCase);
			SpritesheetOverrides.Clear();
			_sheetProviders.Clear();
			HashSet<string> namesAttempted = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				ScanDirectory(PackLayout.T2DSheetsRoot(pluginPackPath), pluginPackPath);
				if (PackLayout.IsCustomizerPack(pluginPackPath))
				{
					ScanFlatRoot(pluginPackPath);
				}
			}
			ScanDirectory(AtlasLoadPath, null);
			void ScanDirectory(string dir, string sourcePack)
			{
				if (Directory.Exists(dir))
				{
					string[] files = Directory.GetFiles(dir, "*.png", SearchOption.TopDirectoryOnly);
					for (int i = 0; i < files.Length; i++)
					{
						ScanFile(files[i], sourcePack);
					}
				}
			}
			void ScanFile(string file, string sourcePack)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
				if (string.IsNullOrEmpty(fileNameWithoutExtension))
				{
					Plugin.Logger.LogWarning((object)("[T2D] Ignoring '" + file + "' — file has no name; an empty-keyed override would match every unnamed runtime texture."));
				}
				else
				{
					namesAttempted.Add(fileNameWithoutExtension);
					if (SpritesheetOverrides.ContainsKey(fileNameWithoutExtension))
					{
						if (!IOUtil.FileMatchesBytes(file, SpritesheetOverrides[fileNameWithoutExtension].PngData))
						{
							ConflictTracker.Record("t2d-sheet", fileNameWithoutExtension, _sheetProviders.GetValueOrDefault(fileNameWithoutExtension), sourcePack, null, null, file);
						}
					}
					else
					{
						bool flag = false;
						try
						{
							byte[] array = File.ReadAllBytes(IOUtil.LongSafe(file));
							if (IOUtil.TryReadPngDimensions(array, out var width, out var height))
							{
								SpritesheetOverrides[fileNameWithoutExtension] = (array, width, height);
								_sheetProviders[fileNameWithoutExtension] = sourcePack;
								Plugin.Logger.LogDebug((object)$"[T2D] Loaded spritesheet override: '{fileNameWithoutExtension}' ({width}x{height})");
								if (IsGenericRuntimeName(fileNameWithoutExtension))
								{
									Plugin.Logger.LogWarning((object)("[T2D] Generic-name override '" + fileNameWithoutExtension + "' from pack '" + (sourcePack ?? "<base>") + "' — this name collides with many runtime textures and risks corrupting unrelated assets at the same dimensions. Recommend re-keying on the hash-stamped sactx atlas name from the original dump."));
								}
								if (IsLikelyEngineBuiltin(fileNameWithoutExtension))
								{
									Plugin.Logger.LogWarning((object)("[T2D] Engine-builtin override '" + fileNameWithoutExtension + "' from pack '" + (sourcePack ?? "<base>") + "' — Unity's '" + fileNameWithoutExtension + "' is a built-in texture shared across the engine, not a game asset. Replacement will be skipped at swap time to avoid affecting unrelated subsystems (color grading, particle defaults, GUI skin, etc.)."));
								}
								flag = true;
							}
							else
							{
								Plugin.Logger.LogWarning((object)("[T2D] Could not read PNG dimensions for spritesheet '" + fileNameWithoutExtension + "' " + $"(pngData.Length={((array != null) ? array.Length : 0)}). " + "Possibly a partial write; preserving previous override if any."));
							}
						}
						catch (Exception ex)
						{
							Plugin.Logger.LogWarning((object)("[T2D] Failed to load spritesheet '" + file + "': " + ex.Message + ". Preserving previous override if any."));
						}
						if (!flag && previousOverrides.TryGetValue(fileNameWithoutExtension, out (byte[], int, int) value))
						{
							SpritesheetOverrides[fileNameWithoutExtension] = value;
							if (previousProviders.TryGetValue(fileNameWithoutExtension, out var value2))
							{
								_sheetProviders[fileNameWithoutExtension] = value2;
							}
							Plugin.Logger.LogInfo((object)("[T2D] Restored previous spritesheet override for '" + fileNameWithoutExtension + "' " + $"({value.Item2}x{value.Item3}) after fresh read failed."));
						}
					}
				}
			}
			void ScanFlatRoot(string packPath)
			{
				string[] files = Directory.GetFiles(packPath, "*.png", SearchOption.TopDirectoryOnly);
				foreach (string text in files)
				{
					if (!PackLayout.IsPackagingAsset(text))
					{
						if (IsGenericRuntimeName(Path.GetFileNameWithoutExtension(text)))
						{
							Plugin.Logger.LogInfo((object)("[T2D] Flat Customizer skin '" + Path.GetFileName(packPath) + "': '" + Path.GetFileName(text) + "' is a tk2d atlas with no collection attribution — not applied. The addressable form is Spritesheets/[Collection]/[TextureName].png."));
						}
						else
						{
							ScanFile(text, packPath);
						}
					}
				}
			}
		}

		internal static void RegisterStandaloneSpritesheet(string textureName, string file, string sourcePack)
		{
			if (string.IsNullOrEmpty(textureName))
			{
				Plugin.Logger.LogWarning((object)("[T2D] Ignoring standalone '" + file + "' — file has no name."));
				return;
			}
			if (SpritesheetOverrides.ContainsKey(textureName))
			{
				if (!IOUtil.FileMatchesBytes(file, SpritesheetOverrides[textureName].PngData))
				{
					ConflictTracker.Record("t2d-sheet", textureName, _sheetProviders.GetValueOrDefault(textureName), sourcePack, "Spritesheets/T2D › Sprites/T2D/_standalone", null, file);
				}
				return;
			}
			try
			{
				byte[] array = File.ReadAllBytes(IOUtil.LongSafe(file));
				if (!IOUtil.TryReadPngDimensions(array, out var width, out var height))
				{
					Plugin.Logger.LogWarning((object)("[T2D] _standalone PNG '" + textureName + "' has unreadable dimensions; in-place swap will be skipped."));
					return;
				}
				SpritesheetOverrides[textureName] = (array, width, height);
				_sheetProviders[textureName] = sourcePack;
				Plugin.Logger.LogDebug((object)$"[T2D] Registered standalone spritesheet override: '{textureName}' ({width}x{height})");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[T2D] Failed to load standalone PNG '" + file + "': " + ex.Message));
			}
		}

		private static (int written, int identical) ConvertSpritesheet(Texture2D atlas, string cleanName, bool onlyChanged = false, bool overwrite = false)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Invalid comparison between Unknown and I4
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(SpriteDumper.ConvertPath, "T2D", cleanName);
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)atlas).width, ((Texture)atlas).height, 0, (RenderTextureFormat)0);
			Graphics.Blit((Texture)(object)atlas, temporary);
			RenderTexture val = null;
			Texture2D val2 = null;
			if (onlyChanged && TryGetOriginalPngBytes(((Object)atlas).name, out var png))
			{
				val2 = new Texture2D(2, 2, (TextureFormat)4, false);
				if (ImageConversion.LoadImage(val2, png) && ((Texture)val2).width == ((Texture)atlas).width && ((Texture)val2).height == ((Texture)atlas).height)
				{
					val = RenderTexture.GetTemporary(((Texture)atlas).width, ((Texture)atlas).height, 0, (RenderTextureFormat)0);
					Graphics.Blit((Texture)(object)val2, val);
				}
			}
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary;
			try
			{
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
				foreach (Sprite val3 in array)
				{
					if ((Object)(object)val3 == (Object)null || (Object)(object)val3.texture == (Object)null || ((Object)val3.texture).GetInstanceID() != ((Object)atlas).GetInstanceID() || string.IsNullOrEmpty(((Object)val3).name))
					{
						continue;
					}
					string path = Path.Combine(text, ((Object)val3).name + ".png");
					if (!overwrite && File.Exists(path))
					{
						continue;
					}
					Rect val4 = val3.rect;
					if (val3.packed)
					{
						if ((int)val3.packingMode != 1)
						{
							num3++;
							continue;
						}
						val4 = val3.textureRect;
					}
					if (((Rect)(ref val4)).width <= 0f || ((Rect)(ref val4)).height <= 0f)
					{
						continue;
					}
					if ((Object)(object)val != (Object)null)
					{
						Texture2D val5 = new Texture2D((int)((Rect)(ref val4)).width, (int)((Rect)(ref val4)).height, (TextureFormat)4, false);
						Texture2D val6 = new Texture2D((int)((Rect)(ref val4)).width, (int)((Rect)(ref val4)).height, (TextureFormat)4, false);
						bool flag;
						try
						{
							RenderTexture.active = val;
							val5.ReadPixels(new Rect(((Rect)(ref val4)).x, ((Rect)(ref val4)).y, ((Rect)(ref val4)).width, ((Rect)(ref val4)).height), 0, 0);
							val5.Apply();
							RenderTexture.active = temporary;
							val6.ReadPixels(new Rect(((Rect)(ref val4)).x, ((Rect)(ref val4)).y, ((Rect)(ref val4)).width, ((Rect)(ref val4)).height), 0, 0);
							val6.Apply();
							byte[] rawTextureData = val5.GetRawTextureData();
							byte[] rawTextureData2 = val6.GetRawTextureData();
							flag = rawTextureData.AsSpan().SequenceEqual(rawTextureData2);
						}
						finally
						{
							Object.Destroy((Object)(object)val5);
							Object.Destroy((Object)(object)val6);
						}
						if (flag)
						{
							num2++;
							continue;
						}
					}
					Texture2D val7 = new Texture2D((int)((Rect)(ref val4)).width, (int)((Rect)(ref val4)).height, (TextureFormat)4, false);
					try
					{
						val7.ReadPixels(new Rect(((Rect)(ref val4)).x, ((Rect)(ref val4)).y, ((Rect)(ref val4)).width, ((Rect)(ref val4)).height), 0, 0);
						val7.Apply();
						IOUtil.EnsureDirectoryExists(text);
						File.WriteAllBytes(IOUtil.LongSafe(path), ImageConversion.EncodeToPNG(val7));
						num++;
					}
					finally
					{
						Object.Destroy((Object)(object)val7);
					}
				}
				if (num > 0)
				{
					Plugin.Logger.LogDebug((object)$"[T2D] Converted spritesheet '{cleanName}' → {num} individual sprites in {text}");
				}
				if (num3 > 0)
				{
					Plugin.Logger.LogWarning((object)($"[T2D] Convert '{cleanName}': {num3} tight-packed sprite(s) skipped — " + "their atlas location is undefined (SpritePackingMode.Tight); a wrong crop would be worse than none."));
				}
				return (written: num, identical: num2);
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
				if ((Object)(object)val != (Object)null)
				{
					RenderTexture.ReleaseTemporary(val);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Destroy((Object)(object)val2);
				}
			}
		}

		internal static (int sheets, int written, int identical) ConvertAllActiveSheets(bool onlyChanged)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
			foreach (Texture2D val in array)
			{
				if (!((Object)(object)val == (Object)null) && ReplacedTextureIds.Contains(((Object)val).GetInstanceID()))
				{
					var (num4, num5) = ConvertSpritesheet(val, T2DUtil.CleanTextureName(((Object)val).name), onlyChanged, overwrite: true);
					if (num4 + num5 > 0)
					{
						num++;
						num2 += num4;
						num3 += num5;
					}
				}
			}
			return (sheets: num, written: num2, identical: num3);
		}

		private static byte[] CaptureTextureAsPng(Texture2D tex)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_008a: Expected O, but got Unknown
			if ((Object)(object)tex == (Object)null)
			{
				return null;
			}
			try
			{
				RenderTexture temporary = RenderTexture.GetTemporary(((Texture)tex).width, ((Texture)tex).height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
				Graphics.Blit((Texture)(object)tex, temporary);
				RenderTexture active = RenderTexture.active;
				RenderTexture.active = temporary;
				Texture2D val = new Texture2D(((Texture)tex).width, ((Texture)tex).height, (TextureFormat)4, false);
				val.ReadPixels(new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), 0, 0);
				val.Apply();
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
				byte[] array = ImageConversion.EncodeToPNG(val);
				Object.Destroy((Object)val);
				Plugin.Logger.LogDebug((object)$"[T2D] Captured {array.Length / 1024} KB original for '{((Object)tex).name}'");
				return array;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[T2D] Failed to capture original for '" + ((Object)tex).name + "': " + ex.Message));
				return null;
			}
		}

		internal static bool TryRestoreTexture(Texture2D tex)
		{
			if ((Object)(object)tex == (Object)null)
			{
				return false;
			}
			if (!_originalTextureData.TryGetValue(((Object)tex).name, out var value))
			{
				Plugin.Logger.LogDebug((object)("[T2D] No stored original for '" + ((Object)tex).name + "' — skipping restore"));
				return false;
			}
			if (ImageConversion.LoadImage(tex, value))
			{
				Plugin.Logger.LogDebug((object)("[T2D] Restored vanilla pixels for '" + ((Object)tex).name + "'"));
				_restoredNames.Add(((Object)tex).name);
				return true;
			}
			Plugin.Logger.LogWarning((object)("[T2D] LoadImage failed while restoring '" + ((Object)tex).name + "'"));
			return false;
		}

		internal static void PruneStaleOriginals()
		{
			if (_originalTextureData.Count == 0)
			{
				return;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
			foreach (Texture2D val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					hashSet.Add(((Object)val).name);
				}
			}
			int count = _originalTextureData.Count;
			foreach (string item in new List<string>(_originalTextureData.Keys))
			{
				if (!hashSet.Contains(item))
				{
					string key = T2DUtil.CleanTextureName(item);
					if (!SpritesheetOverrides.ContainsKey(item) && !SpritesheetOverrides.ContainsKey(key) && _restoredNames.Contains(item))
					{
						_originalTextureData.Remove(item);
						_restoredNames.Remove(item);
					}
				}
			}
			int num = count - _originalTextureData.Count;
			if (num > 0)
			{
				Plugin.Logger.LogDebug((object)$"[T2D] Pruned {num} stale original(s) after scene unload ({_originalTextureData.Count} remaining)");
			}
		}
	}
	public static class TextMerger
	{
		public sealed class Conflict
		{
			public string Sheet;

			public string Lang;

			public string Key;

			public string RootValue;

			public string PackValue;

			public int Choice = -1;

			public string CustomValue = "";
		}

		public sealed class Plan
		{
			public string PackName;

			public string PackPath;

			public PackSource PackSource;

			public readonly List<Conflict> Conflicts = new List<Conflict>();

			public readonly Dictionary<(string Sheet, string Lang), Dictionary<string, string>> Additions = new Dictionary<(string, string), Dictionary<string, string>>();

			public readonly Dictionary<(string Sheet, string Lang), Dictionary<string, string>> RootOnly = new Dictionary<(string, string), Dictionary<string, string>>();

			public readonly Dictionary<(string Sheet, string Lang), List<string>> IdenticalKeys = new Dictionary<(string, string), List<string>>();

			public int AddedCount;

			public int IdenticalCount;

			public int RootOnlyCount;

			public int ResolvedCount => Conflicts.Count((Conflict c) => c.Choice == 0 || c.Choice == 1 || (c.Choice == 2 && !string.IsNullOrWhiteSpace(c.CustomValue)));

			public bool Resolved => ResolvedCount == Conflicts.Count;

			public bool IsEmpty
			{
				get
				{
					if (AddedCount == 0 && IdenticalCount == 0)
					{
						return Conflicts.Count == 0;
					}
					return false;
				}
			}
		}

		public static Plan Scan(PackInfo pack)
		{
			string path = Path.Combine(pack.Path, "Text");
			if (!Directory.Exists(path))
			{
				return null;
			}
			Plan plan = new Plan
			{
				PackName = pack.Name,
				PackPath = pack.Path,
				PackSource = pack.Source
			};
			string[] directories = Directory.GetDirectories(path);
			foreach (string text in directories)
			{
				string fileName = Path.GetFileName(text);
				string[] files = Directory.GetFiles(text, "*.yml");
				foreach (string obj in files)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(obj);
					Dictionary<string, string> dictionary = DialogueHandler.ParseSheetFile(obj);
					Dictionary<string, string> dictionary2 = DialogueHandler.ParseSheetFile(Path.Combine(DialogueHandler.TextLoadPath, fileName, fileNameWithoutExtension + ".yml"));
					foreach (KeyValuePair<string, string> item in dictionary)
					{
						if (!dictionary2.TryGetValue(item.Key, out var value))
						{
							(string, string) key = (fileName, fileNameWithoutExtension);
							if (!plan.Additions.TryGetValue(key, out var value2))
							{
								value2 = (plan.Additions[key] = new Dictionary<string, string>());
							}
							value2[item.Key] = item.Value;
							plan.AddedCount++;
						}
						else if (value == item.Value)
						{
							plan.IdenticalCount++;
							(string, string) key2 = (fileName, fileNameWithoutExtension);
							if (!plan.IdenticalKeys.TryGetValue(key2, out var value3))
							{
								value3 = (plan.IdenticalKeys[key2] = new List<string>());
							}
							value3.Add(item.Key);
						}
						else
						{
							plan.Conflicts.Add(new Conflict
							{
								Sheet = fileName,
								Lang = fileNameWithoutExtension,
								Key = item.Key,
								RootValue = value,
								PackValue = item.Value
							});
						}
					}
					foreach (KeyValuePair<string, string> item2 in dictionary2)
					{
						if (!dictionary.ContainsKey(item2.Key))
						{
							(string, string) key3 = (fileName, fileNameWithoutExtension);
							if (!plan.RootOnly.TryGetValue(key3, out var value4))
							{
								value4 = (plan.RootOnly[key3] = new Dictionary<string, string>());
							}
							value4[item2.Key] = item2.Value;
							plan.RootOnlyCount++;
						}
					}
				}
				string path2 = Path.Combine(DialogueHandler.TextLoadPath, fileName);
				if (!Directory.Exists(path2))
				{
					continue;
				}
				files = Directory.GetFiles(path2, "*.yml");
				foreach (string text2 in files)
				{
					string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(text2);
					if (!File.Exists(Path.Combine(text, fileNameWithoutExtension2 + ".yml")))
					{
						Dictionary<string, string> dictionary5 = DialogueHandler.ParseSheetFile(text2);
						if (dictionary5.Count != 0)
						{
							plan.RootOnly[(fileName, fileNameWithoutExtension2)] = new Dictionary<string, string>(dictionary5);
							plan.RootOnlyCount += dictionary5.Count;
						}
					}
				}
			}
			plan.Conflicts.Sort(delegate(Conflict a, Conflict b)
			{
				int num = string.Compare(a.Sheet, b.Sheet, StringComparison.OrdinalIgnoreCase);
				if (num != 0)
				{
					return num;
				}
				num = string.Compare(a.Lang, b.Lang, StringComparison.OrdinalIgnoreCase);
				return (num == 0) ? string.Compare(a.Key, b.Key, StringComparison.Ordinal) : num;
			});
			return plan;
		}

		public static (int Files, int Keys, string Backup) Apply(Plan plan)
		{
			Dictionary<(string, string), Dictionary<string, string>> dictionary = new Dictionary<(string, string), Dictionary<string, string>>();
			foreach (KeyValuePair<(string, string), Dictionary<string, string>> addition in plan.Additions)
			{
				dictionary[addition.Key] = new Dictionary<string, string>(addition.Value);
			}
			foreach (Conflict conflict in plan.Conflicts)
			{
				if (conflict.Choice == 1 || (conflict.Choice == 2 && !string.IsNullOrWhiteSpace(conflict.CustomValue)))
				{
					string value = ((conflict.Choice == 1) ? conflict.PackValue : conflict.CustomValue);
					(string, string) key = (conflict.Sheet, conflict.Lang);
					if (!dictionary.TryGetValue(key, out var value2))
					{
						value2 = (dictionary[key] = new Dictionary<string, string>());
					}
					value2[conflict.Key] = value;
				}
			}
			if (dictionary.Count == 0)
			{
				return (Files: 0, Keys: 0, Backup: null);
			}
			string text = null;
			string textLoadPath = DialogueHandler.TextLoadPath;
			if (Directory.Exists(textLoadPath))
			{
				text = $"{textLoadPath}.backup-{DateTime.Now:yyyyMMdd-HHmmss}";
				CopyTree(textLoadPath, text);
			}
			int num = 0;
			int num2 = 0;
			foreach (KeyValuePair<(string, string), Dictionary<string, string>> item3 in dictionary)
			{
				(string, string) key2 = item3.Key;
				string item = key2.Item1;
				string item2 = key2.Item2;
				Dictionary<string, string> value3 = item3.Value;
				string text2 = Path.Combine(textLoadPath, item);
				IOUtil.EnsureDirectoryExists(text2);
				string path = Path.Combine(text2, item2 + ".yml");
				List<string> list = new List<string>();
				Dictionary<string, string> dictionary3 = new Dictionary<string, string>(value3);
				if (File.Exists(path))
				{
					string[] array = File.ReadAllLines(path);
					foreach (string text3 in array)
					{
						if (!text3.StartsWith("#") && !string.IsNullOrWhiteSpace(text3))
						{
							int num3 = text3.IndexOf(':');
							if (num3 != -1)
							{
								string text4 = text3.Substring(0, num3).Trim();
								if (dictionary3.TryGetValue(text4, out var value4))
								{
									list.Add(text4 + ": " + EscapeValue(value4));
									dictionary3.Remove(text4);
									continue;
								}
							}
						}
						list.Add(text3);
					}
				}
				else
				{
					list.Add($"# merged from pack '{plan.PackName}' — {DateTime.Now:yyyy-MM-dd}");
				}
				foreach (KeyValuePair<string, string> item4 in dictionary3.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> k) => k.Key, StringComparer.OrdinalIgnoreCase))
				{
					list.Add(item4.Key + ": " + EscapeValue(item4.Value));
				}
				File.WriteAllLines(path, list);
				num++;
				num2 += value3.Count;
			}
			Plugin.Logger.LogInfo((object)($"[TextMerger] Merged pack '{plan.PackName}' → working folder: {num2} key(s) across " + $"{num} file(s) ({plan.AddedCount} added, {plan.Conflicts.Count} conflict(s) resolved). " + "Backup: " + (text ?? "none needed")));
			return (Files: num, Keys: num2, Backup: text);
		}

		public static (int Files, int Keys, int Removed, string Backup) ApplyToPack(Plan plan)
		{
			if (plan.PackSource == PackSource.Customizer)
			{
				Plugin.Logger.LogWarning((object)"[TextMerger] Push refused: Customizer packs are read-only.");
				return (Files: 0, Keys: 0, Removed: 0, Backup: null);
			}
			Dictionary<(string, string), Dictionary<string, string>> dictionary = new Dictionary<(string, string), Dictionary<string, string>>();
			foreach (KeyValuePair<(string, string), Dictionary<string, string>> item5 in plan.RootOnly)
			{
				dictionary[item5.Key] = new Dictionary<string, string>(item5.Value);
			}
			foreach (Conflict conflict in plan.Conflicts)
			{
				if (conflict.Choice == 0 || (conflict.Choice == 2 && !string.IsNullOrWhiteSpace(conflict.CustomValue)))
				{
					string value = ((conflict.Choice == 0) ? conflict.RootValue : conflict.CustomValue);
					(string, string) key = (conflict.Sheet, conflict.Lang);
					if (!dictionary.TryGetValue(key, out var value2))
					{
						value2 = (dictionary[key] = new Dictionary<string, string>());
					}
					value2[conflict.Key] = value;
				}
			}
			Dictionary<(string Sheet, string Lang), HashSet<string>> removals = new Dictionary<(string, string), HashSet<string>>();
			foreach (Conflict conflict2 in plan.Conflicts)
			{
				if (conflict2.Choice == 0 || conflict2.Choice == 1 || (conflict2.Choice == 2 && !string.IsNullOrWhiteSpace(conflict2.CustomValue)))
				{
					MarkRemoval(conflict2.Sheet, conflict2.Lang, conflict2.Key);
				}
			}
			foreach (KeyValuePair<(string, string), Dictionary<string, string>> item6 in plan.RootOnly)
			{
				foreach (string key4 in item6.Value.Keys)
				{
					MarkRemoval(item6.Key.Item1, item6.Key.Item2, key4);
				}
			}
			foreach (KeyValuePair<(string, string), List<string>> identicalKey in plan.IdenticalKeys)
			{
				foreach (string item7 in identicalKey.Value)
				{
					MarkRemoval(identicalKey.Key.Item1, identicalKey.Key.Item2, item7);
				}
			}
			if (dictionary.Count == 0 && removals.Count == 0)
			{
				return (Files: 0, Keys: 0, Removed: 0, Backup: null);
			}
			string text = DateTime.Now.ToString("yyyyMMdd-HHmmss");
			string text2 = Path.Combine(plan.PackPath, "Text");
			string textLoadPath = DialogueHandler.TextLoadPath;
			string text3 = null;
			if (Directory.Exists(text2))
			{
				text3 = text2 + ".backup-" + text;
				CopyTree(text2, text3);
			}
			if (Directory.Exists(textLoadPath))
			{
				CopyTree(textLoadPath, textLoadPath + ".backup-" + text);
			}
			int num = 0;
			int num2 = 0;
			foreach (KeyValuePair<(string, string), Dictionary<string, string>> item8 in dictionary)
			{
				(string, string) key2 = item8.Key;
				string item = key2.Item1;
				string item2 = key2.Item2;
				Dictionary<string, string> value3 = item8.Value;
				string text4 = Path.Combine(text2, item);
				IOUtil.EnsureDirectoryExists(text4);
				string path = Path.Combine(text4, item2 + ".yml");
				Dictionary<string, string> dictionary3 = new Dictionary<string, string>(value3);
				List<string> list = (File.Exists(path) ? new List<string>(File.ReadAllLines(path)) : new List<string>());
				List<string> list2 = new List<string>();
				for (int i = 0; i < list.Count; i++)
				{
					string text5 = KeyOf(list[i]);
					if (text5 != null)
					{
						if (dictionary3.TryGetValue(text5, out var value4))
						{
							list[i] = text5 + ": " + EscapeValue(value4);
							dictionary3.Remove(text5);
						}
						list2.Add(text5);
					}
				}
				if (dictionary3.Count > 0)
				{
					List<KeyValuePair<string, string>> list3 = dictionary3.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> k) => k.Key, StringComparer.OrdinalIgnoreCase).ToList();
					bool flag = list2.Count > 0;
					for (int num3 = 1; num3 < list2.Count && flag; num3++)
					{
						if (string.Compare(list2[num3 - 1], list2[num3], StringComparison.OrdinalIgnoreCase) > 0)
						{
							flag = false;
						}
					}
					if (flag)
					{
						List<string> list4 = new List<string>(list.Count + list3.Count);
						int num4 = 0;
						foreach (string item9 in list)
						{
							string text6 = KeyOf(item9);
							if (text6 != null)
							{
								for (; num4 < list3.Count && string.Compare(list3[num4].Key, text6, StringComparison.OrdinalIgnoreCase) < 0; num4++)
								{
									list4.Add(list3[num4].Key + ": " + EscapeValue(list3[num4].Value));
								}
							}
							list4.Add(item9);
						}
						for (; num4 < list3.Count; num4++)
						{
							list4.Add(list3[num4].Key + ": " + EscapeValue(list3[num4].Value));
						}
						list = list4;
					}
					else
					{
						list.Add($"# pushed from working folder — {DateTime.Now:yyyy-MM-dd}");
						foreach (KeyValuePair<string, string> item10 in list3)
						{
							list.Add(item10.Key + ": " + EscapeValue(item10.Value));
						}
					}
				}
				File.WriteAllLines(path, list);
				num++;
				num2 += value3.Count;
			}
			int num5 = 0;
			foreach (KeyValuePair<(string, string), HashSet<string>> item11 in removals)
			{
				(string, string) key3 = item11.Key;
				string item3 = key3.Item1;
				string item4 = key3.Item2;
				string path2 = Path.Combine(textLoadPath, item3, item4 + ".yml");
				if (!File.Exists(path2))
				{
					continue;
				}
				List<string> list5 = new List<string>();
				string[] array = File.ReadAllLines(path2);
				foreach (string text7 in array)
				{
					string text8 = KeyOf(text7);
					if (text8 != null && item11.Value.Contains(text8))
					{
						num5++;
					}
					else
					{
						list5.Add(text7);
					}
				}
				if (list5.Any((string l) => !string.IsNullOrWhiteSpace(l)))
				{
					File.WriteAllLines(path2, list5);
				}
				else
				{
					File.Delete(path2);
				}
			}
			Plugin.Logger.LogInfo((object)($"[TextMerger] Pushed → pack '{plan.PackName}': {num2} key(s) across {num} file(s); " + string.Format("{0} key(s) moved out of the working folder. Backup: {1}", num5, text3 ?? "none needed")));
			return (Files: num, Keys: num2, Removed: num5, Backup: text3);
			void MarkRemoval(string sheet, string lang, string item5)
			{
				if (!removals.TryGetValue((sheet, lang), out var value5))
				{
					value5 = (removals[(sheet, lang)] = new HashSet<string>(StringComparer.Ordinal));
				}
				value5.Add(item5);
			}
		}

		private static string KeyOf(string line)
		{
			if (line.StartsWith("#") || string.IsNullOrWhiteSpace(line))
			{
				return null;
			}
			int num = line.IndexOf(':');
			if (num != -1)
			{
				return line.Substring(0, num).Trim();
			}
			return null;
		}

		private static string EscapeValue(string v)
		{
			return "\"" + v.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
		}

		private static void CopyTree(string src, string dst)
		{
			Directory.CreateDirectory(dst);
			string[] directories = Directory.GetDirectories(src, "*", SearchOption.AllDirectories);
			for (int i = 0; i < directories.Length; i++)
			{
				Directory.CreateDirectory(directories[i].Replace(src, dst));
			}
			directories = Directory.GetFiles(src, "*", SearchOption.AllDirectories);
			foreach (string obj in directories)
			{
				File.Copy(obj, obj.Replace(src, dst), overwrite: true);
			}
		}
	}
	public class VideoHandler
	{
		public static Dictionary<string, string> VideoFileMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		public static bool ReloadVideos = false;

		public static readonly string[] KnownCinematics = new string[26]
		{
			"act_03_intro", "bellbeast_travel_children_v3", "bellbeast_travel_children_v3_30_fps", "bellbeast_travel_normal_v3", "bellbeast_travel_normal_v3_30_fps", "bellhart_intro", "city_reveal", "city_reveal_inner", "diving_bell", "doctor_cure",
			"ending_a", "ending_b", "ending_c", "ending_d", "ending_e", "farsight", "intro_cinematic", "lace_battle", "last_dive", "mr_mushroom",
			"pinstress_battle", "plinney_sharpen", "plinney_sharpen_oil", "red_memory_ritual", "seamstress_flash", "slab_cinematic"
		};

		internal static readonly string[] SupportedExtensions = new string[9] { ".mp4", ".webm", ".ogv", ".mov", ".avi", ".m4v", ".mpg", ".mpeg", ".wmv" };

		private static readonly FieldInfo _ccaCurves = AccessTools.Field(typeof(ColorCorrectionCurvesAnimator), "curves");

		private static readonly FieldInfo _ccaPlayer = AccessTools.Field(typeof(ColorCorrectionCurvesAnimator), "getDurationFromCinematic");

		public static string VideoLoadPath => Path.Combine(Plugin.BasePath, "Videos");

		public static event Action<string, bool> OnCinematicTriggered;

		public static void Reload()
		{
			VideoFileMap.Clear();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				ScanDir(PackLayout.VideosRoot(pluginPackPath));
			}
			ScanDir(VideoLoadPath);
			Plugin.Logger.LogDebug((object)$"[VideoHandler] Reload: {VideoFileMap.Count} video replacement(s) found");
			static void ScanDir(string dir)
			{
				if (Directory.Exists(dir))
				{
					string[] files = Directory.GetFiles(dir, "*.*", SearchOption.AllDirectories);
					foreach (string text in files)
					{
						string value = Path.GetExtension(text).ToLowerInvariant();
						if (Array.IndexOf(SupportedExtensions, value) >= 0)
						{
							string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
							if (!VideoFileMap.ContainsKey(fileNameWithoutExtension))
							{
								VideoFileMap[fileNameWithoutExtension] = "file:///" + text;
							}
						}
					}
				}
			}
		}

		public static void ApplyPatches(Harmony harmony)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			harmony.Patch((MethodBase)AccessTools.Constructor(typeof(EmbeddedCinematicVideoPlayer), new Type[1] { typeof(CinematicVideoPlayerConfig) }, false), (HarmonyMethod)null, new HarmonyMethod(typeof(VideoHandler), "ConstructorPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(EmbeddedCinematicVideoPlayer), "PlayVideo", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(VideoHandler), "PlayVideoPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(EmbeddedCinematicVideoPlayer), "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(VideoHandler), "UpdatePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.PropertyGetter(typeof(CinematicSequence), "VideoLength"), (HarmonyMethod)null, new HarmonyMethod(typeof(VideoHandler), "VideoLengthPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ColorCorrectionCurvesAnimator), "DoPlay", (Type[])null, (Type[])null), new HarmonyMethod(typeof(VideoHandler), "DoPlayPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(CinematicPlayer), "StartVideo", (Type[])null, (Type[])null), new HarmonyMethod(typeof(VideoHandler), "StartVideoPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static string FindVideoFile(string name)
		{
			if (VideoFileMap.TryGetValue(name, out var value))
			{
				return value;
			}
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				string path = PackLayout.VideosRoot(pluginPackPath);
				if (Directory.Exists(path))
				{
					string[] array = (from f in Directory.GetFiles(path, name + ".*", SearchOption.AllDirectories)
						where Array.IndexOf(SupportedExtensions, Path.GetExtension(f).ToLowerInvariant()) >= 0
						select f).ToArray();
					if (array.Any())
					{
						string text = "file:///" + array[0];
						VideoFileMap[name] = text;
						return text;
					}
				}
			}
			string[] files = Directory.GetFiles(VideoLoadPath, name + ".*", SearchOption.AllDirectories);
			if (files.Any())
			{
				string text2 = "file:///" + files[0];
				VideoFileMap[name] = text2;
				return text2;
			}
			VideoFileMap[name] = null;
			return null;
		}

		private static void StartVideoPrefix(CinematicPlayer __instance)
		{
			if (__instance.videoClip.VideoFileName != null && FindVideoFile(__instance.videoClip.VideoFileName) != null)
			{
				__instance.additionalAudio = null;
			}
		}

		private static void UpdatePostfix(EmbeddedCinematicVideoPlayer __instance)
		{
			if (FindVideoFile(((CinematicVideoPlayer)__instance).Config.VideoReference.VideoFileName) != null)
			{
				Platform.Current.RestoreFrameRate();
			}
			if (Plugin.Config.VideoSkipFrameOnDrop)
			{
				VideoPlayer videoPlayer = __instance.videoPlayer;
				if ((Object)(object)videoPlayer != (Object)null && !videoPlayer.skipOnDrop)
				{
					videoPlayer.skipOnDrop = true;
				}
			}
		}

		private static bool DoPlayPrefix(ColorCorrectionCurvesAnimator __instance)
		{
			if (!Plugin.Config.VideoSkipColorGrading)
			{
				return true;
			}
			object? obj = _ccaPlayer?.GetValue(__instance);
			CinematicPlayer val = (CinematicPlayer)((obj is CinematicPlayer) ? obj : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val.videoClip == (Object)null)
			{
				return true;
			}
			string videoFileName = val.videoClip.VideoFileName;
			if (FindVideoFile(videoFileName) == null)
			{
				return true;
			}
			object? obj2 = _ccaCurves?.GetValue(__instance);
			ColorCorrectionCurves val2 = (ColorCorrectionCurves)((obj2 is ColorCorrectionCurves) ? obj2 : null);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.saturation = 1f;
				val2.redChannel = AnimationCurve.Linear(0f, 0f, 1f, 1f);
				val2.greenChannel = AnimationCurve.Linear(0f, 0f, 1f, 1f);
				val2.blueChannel = AnimationCurve.Linear(0f, 0f, 1f, 1f);
				val2.UpdateParameters();
				val2.UpdateMaterial();
			}
			Plugin.Logger.LogInfo((object)("[Video] '" + videoFileName + "': cinematic colour-grade animation skipped for the replacement (VideoSkipColorGrading)."));
			return false;
		}

		private static void VideoLengthPostfix(CinematicSequence __instance, ref float __result)
		{
			CinematicVideoPlayer videoPlayer = __instance.VideoPlayer;
			EmbeddedCinematicVideoPlayer val = (EmbeddedCinematicVideoPlayer)(object)((videoPlayer is EmbeddedCinematicVideoPlayer) ? videoPlayer : null);
			if (val != null && (Object)(object)val.videoPlayer != (Object)null && FindVideoFile(((CinematicVideoPlayer)val).Config.VideoReference.VideoFileName) != null && val.videoPlayer.length > 0.0)
			{
				__result = (float)val.videoPlayer.length;
			}
		}

		private static void ConstructorPostfix(EmbeddedCinematicVideoPlayer __instance, CinematicVideoPlayerConfig config)
		{
			string videoFileName = config.VideoReference.VideoFileName;
			string text = FindVideoFile(videoFileName);
			VideoHandler.OnCinematicTriggered?.Invoke(videoFileName, text != null);
			if (text == null)
			{
				return;
			}
			__instance.videoPlayer.url = text;
			__instance.videoPlayer.clip = null;
			__instance.videoPlayer.playbackSpeed = 1f;
			if (Object.op_Implicit((Object)(object)config.AudioSource) && !Plugin.Config.VideoAudioDirect)
			{
				AudioSource val = ((Component)config.AudioSource).gameObject.AddComponent<AudioSource>();
				val.playOnAwake = false;
				__instance.videoPlayer.audioOutputMode = (VideoAudioOutputMode)1;
				__instance.videoPlayer.SetTargetAudioSource((ushort)0, val);
				__instance.videoPlayer.controlledAudioTrackCount = 1;
				val.volume = 1f;
			}
			else
			{
				if (!Plugin.Config.VideoAudioDirect)
				{
					Plugin.Logger.LogWarning((object)("Using custom video file '" + config.VideoReference.VideoFileName + "' with direct audio output. This may result in no audio being played."));
				}
				else
				{
					Plugin.Logger.LogInfo((object)("[Video] '" + config.VideoReference.VideoFileName + "': Direct audio output (VideoAudioDirect)."));
				}
				__instance.videoPlayer.audioOutputMode = (VideoAudioOutputMode)2;
			}
			__instance.videoPlayer.Prepare();
		}

		private static void PlayVideoPostfix(EmbeddedCinematicVideoPlayer __instance)
		{
			LogGate.SuppressForCinematic(__instance.videoPlayer, ((CinematicVideoPlayer)__instance).Config.VideoReference.VideoFileName);
			if (FindVideoFile(((CinematicVideoPlayer)__instance).Config.VideoReference.VideoFileName) != null && !__instance.isSeeking)
			{
				((CinematicVideoPlayer)__instance).StopAudio();
			}
		}
	}
	public class SpriteFileWatcher : IDisposable
	{
		public FileSystemWatcher SpriteWatcher;

		public FileSystemWatcher AtlasWatcher;

		public List<FileSystemWatcher> PackSpriteWatchers = new List<FileSystemWatcher>();

		public List<FileSystemWatcher> PackAtlasWatchers = new List<FileSystemWatcher>();

		public static volatile bool ReloadSprites;

		public static volatile bool ReloadT2DSprites;

		private const int DebounceMs = 100;

		private static long _spriteDeadlineTicks;

		private static long _t2dSpriteDeadlineTicks;

		private static void DeferReloadSprites()
		{
			Interlocked.Exchange(ref _spriteDeadlineTicks, DateTime.UtcNow.AddMilliseconds(100.0).Ticks);
		}

		private static void DeferReloadT2DSprites()
		{
			Interlocked.Exchange(ref _t2dSpriteDeadlineTicks, DateTime.UtcNow.AddMilliseconds(100.0).Ticks);
		}

		public static void Tick()
		{
			long ticks = DateTime.UtcNow.Ticks;
			long num = Interlocked.Read(in _spriteDeadlineTicks);
			if (num != 0L && ticks >= num)
			{
				Interlocked.Exchange(ref _spriteDeadlineTicks, 0L);
				ReloadSprites = true;
			}
			long num2 = Interlocked.Read(in _t2dSpriteDeadlineTicks);
			if (num2 != 0L && ticks >= num2)
			{
				Interlocked.Exchange(ref _t2dSpriteDeadlineTicks, 0L);
				ReloadT2DSprites = true;
			}
		}

		public SpriteFileWatcher()
		{
			SpriteWatcher = CreateSpriteWatcher(SpriteLoader.LoadPath);
			AtlasWatcher = CreateAtlasWatcher(SpriteLoader.AtlasLoadPath);
			RebuildPackPngWatchers();
		}

		public void RebuildPackPngWatchers()
		{
			foreach (FileSystemWatcher packSpriteWatcher in PackSpriteWatchers)
			{
				packSpriteWatcher.EnableRaisingEvents = false;
				packSpriteWatcher.Dispose();
			}
			PackSpriteWatchers.Clear();
			foreach (FileSystemWatcher packAtlasWatcher in PackAtlasWatchers)
			{
				packAtlasWatcher.EnableRaisingEvents = false;
				packAtlasWatcher.Dispose();
			}
			PackAtlasWatchers.Clear();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				string path = Path.Combine(pluginPackPath, "Sprites");
				if (Directory.Exists(path))
				{
					PackSpriteWatchers.Add(CreateSpriteWatcher(path));
				}
				string path2 = PackLayout.SheetsRoot(pluginPackPath);
				if (Directory.Exists(path2))
				{
					PackAtlasWatchers.Add(CreateAtlasWatcher(path2));
				}
			}
			Plugin.Logger.LogDebug((object)("[SpriteFileWatcher] Rebuilt pack PNG watchers: " + $"{PackSpriteWatchers.Count} sprites dir(s), {PackAtlasWatchers.Count} sheets dir(s)"));
		}

		private FileSystemWatcher CreateSpriteWatcher(string path)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
			fileSystemWatcher.Path = path;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.Filter = "*.png";
			fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite;
			fileSystemWatcher.InternalBufferSize = 65536;
			fileSystemWatcher.Changed += OnSpriteChanged;
			fileSystemWatcher.Created += OnSpriteChanged;
			fileSystemWatcher.Deleted += OnSpriteChanged;
			fileSystemWatcher.Renamed += OnSpriteChanged;
			fileSystemWatcher.Error += OnWatcherOverflow;
			fileSystemWatcher.EnableRaisingEvents = true;
			return fileSystemWatcher;
		}

		private FileSystemWatcher CreateAtlasWatcher(string path)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();
			fileSystemWatcher.Path = path;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.Filter = "*.png";
			fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite;
			fileSystemWatcher.InternalBufferSize = 65536;
			fileSystemWatcher.Changed += OnAtlasChanged;
			fileSystemWatcher.Created += OnAtlasChanged;
			fileSystemWatcher.Deleted += OnAtlasChanged;
			fileSystemWatcher.Renamed += OnAtlasChanged;
			fileSystemWatcher.Error += OnWatcherOverflow;
			fileSystemWatcher.EnableRaisingEvents = true;
			return fileSystemWatcher;
		}

		private void OnWatcherOverflow(object sender, ErrorEventArgs e)
		{
			Plugin.Logger.LogWarning((object)("[SpriteFileWatcher] Watcher buffer overflow (" + e.GetException()?.Message + ") — events lost; raising full tk2d + T2D reloads."));
			DeferReloadSprites();
			DeferReloadT2DSprites();
		}

		public void Dispose()
		{
			SpriteWatcher.EnableRaisingEvents = false;
			SpriteWatcher.Dispose();
			AtlasWatcher.EnableRaisingEvents = false;
			AtlasWatcher.Dispose();
			foreach (FileSystemWatcher packSpriteWatcher in PackSpriteWatchers)
			{
				packSpriteWatcher.EnableRaisingEvents = false;
				packSpriteWatcher.Dispose();
			}
			PackSpriteWatchers.Clear();
			foreach (FileSystemWatcher packAtlasWatcher in PackAtlasWatchers)
			{
				packAtlasWatcher.EnableRaisingEvents = false;
				packAtlasWatcher.Dispose();
			}
			PackAtlasWatchers.Clear();
		}

		private void OnSpriteChanged(object sender, FileSystemEventArgs e)
		{
			Plugin.Logger.LogDebug((object)$"[FileWatcher] Sprite file event: {e.ChangeType} — {e.FullPath}");
			string relativePath = Path.GetRelativePath((sender as FileSystemWatcher)?.Path ?? SpriteLoader.LoadPath, e.FullPath);
			if (relativePath.IndexOf("_WIP" + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return;
			}
			string[] array = relativePath.Split(Path.DirectorySeparatorChar);
			if (array.Length >= 2)
			{
				if (array[^2] == "T2D" || (array.Length >= 3 && array[^3] == "T2D"))
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(array[^1]);
					string text = ((array.Length >= 3 && array[^3] == "T2D") ? array[^2] : null);
					Plugin.Logger.LogDebug((object)("[FileWatcher] → T2D sprite change detected: atlas='" + text + "', sprite='" + fileNameWithoutExtension + "', setting ReloadT2DSprites=true"));
					ReloadToast.Record(ReloadToast.Kind.T2D, e.FullPath);
					DeferReloadT2DSprites();
				}
				else if (array.Length < 3)
				{
					Plugin.Logger.LogDebug((object)$"[FileWatcher] → Path too short ({array.Length} parts), ignoring: {relativePath}");
				}
				else
				{
					string text2 = array[^3];
					string text3 = array[^2];
					string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(array[^1]);
					SpriteLoader.MarkReloadSprite(text2, text3, fileNameWithoutExtension2);
					Plugin.Logger.LogDebug((object)("[FileWatcher] → tk2d sprite change: collection=" + text2 + ", atlas=" + text3 + ", sprite=" + fileNameWithoutExtension2 + ", setting ReloadSprites=true"));
					ReloadToast.Record(ReloadToast.Kind.Sprite, e.FullPath, (e.ChangeType == WatcherChangeTypes.Deleted) ? null : IOUtil.ParseAnchorTag(fileNameWithoutExtension2).name);
					DeferReloadSprites();
				}
			}
		}

		private void OnAtlasChanged(object sender, FileSystemEventArgs e)
		{
			Plugin.Logger.LogDebug((object)$"[FileWatcher] Atlas file event: {e.ChangeType} — {e.FullPath}");
			string[] array = Path.GetRelativePath((sender as FileSystemWatcher)?.Path ?? SpriteLoader.AtlasLoadPath, e.FullPath).Split(Path.DirectorySeparatorChar);
			if (array.Length < 2)
			{
				Plugin.Logger.LogDebug((object)$"[FileWatcher] → Atlas path too short ({array.Length} parts), ignoring");
				return;
			}
			if (array[^2] == "T2D")
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(array[^1]);
				Plugin.Logger.LogDebug((object)("[FileWatcher] → T2D spritesheet change: '" + fileNameWithoutExtension + "', setting ReloadT2DSprites=true"));
				ReloadToast.Record(ReloadToast.Kind.T2D, e.FullPath);
				DeferReloadT2DSprites();
				return;
			}
			string text = array[^2];
			string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(array[^1]);
			ReloadToast.Record(ReloadToast.Kind.Atlas, e.FullPath);
			SpriteLoader.MarkReloadAtlas(text, fileNameWithoutExtension2);
			Plugin.Logger.LogDebug((object)("[FileWatcher] → tk2d atlas change: collection=" + text + ", atlas=" + fileNameWithoutExtension2 + ", setting ReloadSprites=true"));
			DeferReloadSprites();
		}
	}
}
namespace Stitchwork.GUI
{
	public static class AudioList
	{
		private static List<AudioClipEntry> _entries = new List<AudioClipEntry>();

		private static bool _needsRefresh = true;

		private static int _version;

		public static IReadOnlyList<AudioClipEntry> Entries => _entries;

		public static bool NeedsRefresh => _needsRefresh;

		public static int Version => _version;

		public static void RequestRefresh()
		{
			_needsRefresh = true;
		}

		public static void Refresh()
		{
			_needsRefresh = false;
			_entries = AudioHandler.GetClipInventory();
			_version++;
		}

		public static void ClearList()
		{
			_entries.Clear();
			_needsRefresh = true;
			_version++;
		}
	}
	public static class AudioLog
	{
		internal class AudioPlayEntry
		{
			public string ClipName;

			public string SourcePath;

			public DateTime StartTime;

			public DateTime? BumpedTime;

			public float GetFadeOpacity(double fadeDuration)
			{
				if (!BumpedTime.HasValue)
				{
					return 1f;
				}
				double totalSeconds = (DateTime.Now - BumpedTime.Value).TotalSeconds;
				if (totalSeconds >= fadeDuration)
				{
					return 0f;
				}
				return 1f - (float)(totalSeconds / fadeDuration);
			}

			public bool IsFadedOut(double fadeDuration)
			{
				if (!BumpedTime.HasValue)
				{
					return false;
				}
				return (DateTime.Now - BumpedTime.Value).TotalSeconds >= fadeDuration;
			}
		}

		private static readonly List<AudioPlayEntry> AudioPlayEntries = new List<AudioPlayEntry>();

		private static string _pendingFocusClip = null;

		public static string ConsumePendingFocus()
		{
			string pendingFocusClip = _pendingFocusClip;
			_pendingFocusClip = null;
			return pendingFocusClip;
		}

		public static void DrawEntries(int maxVisible, double fadeDuration, bool hideModded)
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			UpdateEntryLifecycle(maxVisible, fadeDuration);
			int num = 0;
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			for (int i = 0; i < AudioPlayEntries.Count; i++)
			{
				AudioPlayEntry audioPlayEntry = AudioPlayEntries[i];
				if (!hideModded || !File.Exists(Path.Combine(AudioHandler.SoundFolder, audioPlayEntry.ClipName + ".wav")))
				{
					float num2 = ((i < maxVisible) ? 1f : audioPlayEntry.GetFadeOpacity(fadeDuration));
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUI.contentColor = new Color(1f, 1f, 1f, num2);
					if (GUILayout.Button(GUIHelper.TT(audioPlayEntry.ClipName, "Click to copy name"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
					{
						GUIUtility.systemCopyBuffer = audioPlayEntry.ClipName;
						_pendingFocusClip = audioPlayEntry.ClipName;
					}
					if (!string.IsNullOrEmpty(audioPlayEntry.SourcePath))
					{
						GUI.contentColor = new Color(0.55f, 0.55f, 0.55f, num2);
						GUILayout.Label("← " + audioPlayEntry.SourcePath, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
					}
					GUI.contentColor = Color.white;
					GUILayout.EndHorizontal();
					num++;
				}
			}
			if (num == 0)
			{
				GUI.contentColor = Color.yellow;
				GUILayout.Label("No audio played recently.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			}
			GUI.contentColor = Color.white;
			GUILayout.EndVertical();
		}

		private static void UpdateEntryLifecycle(int maxVisible, double fadeDuration)
		{
			for (int num = AudioPlayEntries.Count - 1; num >= maxVisible; num--)
			{
				if (AudioPlayEntries[num].IsFadedOut(fadeDuration))
				{
					AudioPlayEntries.RemoveAt(num);
				}
			}
			for (int i = maxVisible; i < AudioPlayEntries.Count; i++)
			{
				if (!AudioPlayEntries[i].BumpedTime.HasValue)
				{
					AudioPlayEntries[i].BumpedTime = DateTime.Now;
				}
			}
			for (int j = 0; j < Math.Min(maxVisible, AudioPlayEntries.Count); j++)
			{
				AudioPlayEntries[j].BumpedTime = null;
			}
		}

		public static void LogAudio(AudioClip clip, AudioSource source)
		{
			if (!Plugin.ShowDevHub)
			{
				return;
			}
			string cleanName = ((Object)clip).name.Replace("PATCHWORK_", "");
			string text = (((Object)(object)source != (Object)null) ? AudioHandler.GetGameObjectPath(source) : "");
			AudioPlayEntry audioPlayEntry = AudioPlayEntries.Find((AudioPlayEntry e) => e.ClipName == cleanName);
			if (audioPlayEntry != null)
			{
				AudioPlayEntries.Remove(audioPlayEntry);
				if (!string.IsNullOrEmpty(text))
				{
					audioPlayEntry.SourcePath = text;
				}
				audioPlayEntry.StartTime = DateTime.Now;
				audioPlayEntry.BumpedTime = null;
				AudioPlayEntries.Insert(0, audioPlayEntry);
			}
			else
			{
				AudioPlayEntries.Insert(0, new AudioPlayEntry
				{
					ClipName = cleanName,
					SourcePath = text,
					StartTime = DateTime.Now,
					BumpedTime = null
				});
			}
		}

		public static void ClearLog()
		{
			AudioPlayEntries.Clear();
		}
	}
	public static class CameraTracker
	{
		private static Transform _target;

		private static CameraTarget _camTarget;

		private static Vector3 _vel;

		private static string _label = "";

		public static void Track(Component clicked, string label)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)clicked == (Object)null))
			{
				GameCameras instance = GameCameras.instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.cameraTarget == (Object)null)
				{
					Plugin.Logger.LogWarning((object)"[CamTrack] GameCameras/cameraTarget unavailable — cannot track.");
					return;
				}
				_camTarget = instance.cameraTarget;
				_target = clicked.transform;
				_label = (string.IsNullOrEmpty(label) ? ((Object)clicked).name : label);
				_vel = Vector3.zero;
				_camTarget.mode = (TargetMode)3;
				Plugin.Logger.LogInfo((object)("[CamTrack] Tracking '" + _label + "'."));
			}
		}

		public static void Release()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_camTarget != (Object)null)
			{
				_camTarget.mode = (TargetMode)0;
			}
			_camTarget = null;
			_target = null;
			Plugin.Logger.LogInfo((object)"[CamTrack] Released — camera follows Hornet.");
		}

		public static void LateUpdate()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Invalid comparison between Unknown and I4
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_target == (Object)null && (Object)(object)_camTarget == (Object)null)
			{
				return;
			}
			if ((Object)(object)_target == (Object)null || (Object)(object)_camTarget == (Object)null)
			{
				Release();
				return;
			}
			Vector3 position = ((Component)_camTarget).transform.position;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(_target.position.x, _target.position.y, position.z);
			((Component)_camTarget).transform.position = Vector3.SmoothDamp(position, val, ref _vel, 0.12f);
			if ((int)_camTarget.mode != 3)
			{
				_camTarget.mode = (TargetMode)3;
			}
		}

		public static void OnSceneUnloaded()
		{
			if ((Object)(object)_target != (Object)null || (Object)(object)_camTarget != (Object)null)
			{
				Release();
			}
		}

		public static void DrawIndicator()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_target == (Object)null))
			{
				GUIContent val = new GUIContent(string.Format(Loc.T("Camera: tracking {0} — click to release"), _label));
				Vector2 val2 = GUIHelper.LabelStyle.CalcSize(val);
				float num = GUIHelper.Scaled(8f);
				Rect val3 = default(Rect);
				((Rect)(ref val3))..ctor((float)Screen.width - val2.x - num * 2f - GUIHelper.Scaled(10f), GUIHelper.Scaled(8f), val2.x + num * 2f, val2.y + GUIHelper.Scaled(6f));
				GUI.DrawTexture(val3, (Texture)(object)Texture2D.whiteTexture, (ScaleMode)0, true, 0f, new Color(GUIHelper.ColSurface.r, GUIHelper.ColSurface.g, GUIHelper.ColSurface.b, 0.95f), 0f, ((Rect)(ref val3)).height * 0.5f);
				GUI.DrawTexture(val3, (Texture)(object)Texture2D.whiteTexture, (ScaleMode)0, true, 0f, new Color(GUIHelper.ColConfirm.r, GUIHelper.ColConfirm.g, GUIHelper.ColConfirm.b, 0.9f), 1f, ((Rect)(ref val3)).height * 0.5f);
				GUI.contentColor = GUIHelper.ColText;
				GUI.Label(new Rect(((Rect)(ref val3)).x + num, ((Rect)(ref val3)).y + GUIHelper.Scaled(3f), ((Rect)(ref val3)).width - num, val2.y), val, GUIHelper.LabelStyle);
				GUI.contentColor = Color.white;
				if (GUI.Button(val3, GUIContent.none, GUIStyle.none))
				{
					Release();
				}
			}
		}
	}
	public static class CanvasPackManager
	{
		private const float WinW = 460f;

		private const float WinH = 720f;

		private const float StripW = 15f;

		private const float Pad = 8f;

		private const float PadRight = 12f;

		private static GameObject _root;

		private static RectTransform _rootRT;

		private static bool _built;

		private static List<PackInfo> _staged;

		private static bool _closePrompt;

		private static string _pendingProfileDelete;

		private static ScrollRect _packListScroll;

		private static GameObject _actionBtnRow;

		private static GameObject _closePromptRow;

		private static Text _applyHint;

		private static string _lastStagedProfile;

		private static Transform _packListContent;

		private static Text _packsLabel;

		private static Text _statusText;

		private static Text _changesText;

		private static Text _overlayBtnText;

		private static Text _langBtnText;

		private static GameObject _discardBtn;

		private static GameObject _applyBtn;

		private static Image _applyBg;

		private static GameObject _profilesContent;

		private static Transform _profileButtonsContent;

		private static InputField _profileNameInput;

		private static Text _profilesFoldText;

		private static bool _profilesFoldout;

		private static Transform _conflictsContent;

		private static GameObject _conflictsScrollGO;

		private static Text _conflictsFoldText;

		private static bool _conflictsFoldout;

		private static Image _applyBorder;

		private static RawImage _stripImage;

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

		private static int _lastStripH;

		private static int _builtLocGen = -1;

		private static string _openPicker;

		private static bool HasChanges => _staged != null;

		public static bool IsVisible
		{
			get
			{
				if ((Object)(object)_root != (Object)null)
				{
					return _root.activeSelf;
				}
				return false;
			}
		}

		public static void Show()
		{
			if (_built && (Object)(object)_root != (Object)null && _builtLocGen != Loc.Generation)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
				_built = false;
			}
			if (!_built || (Object)(object)_root == (Object)null)
			{
				Build();
			}
			_root.SetActive(true);
			FabricUI.MakeEventSystemCurrent();
			_closePrompt = false;
			_pendingProfileDelete = null;
			Rebuild();
		}

		public static void Hide()
		{
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
			FabricUI.RestoreEventSystem();
		}

		public static void Toggle()
		{
			if (IsVisible)
			{
				RequestClose();
			}
			else
			{
				Show();
			}
		}

		private static void RequestClose()
		{
			if (_closePrompt)
			{
				DoClose();
				return;
			}
			NormalizeStaged();
			if (_staged != null)
			{
				_closePrompt = true;
				Rebuild(keepPrompts: true);
			}
			else
			{
				DoClose();
			}
		}

		private static void DoClose()
		{
			_closePrompt = false;
			Plugin.ShowPackManager = false;
			Hide();
		}

		private static void Build()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			_builtLocGen = Loc.Generation;
			Canvas rootCanvas = FabricUI.RootCanvas;
			float num = FabricUI.S(460f);
			float num2 = FabricUI.S(720f);
			_root = new GameObject("CanvasPackManager", new Type[1] { typeof(RectTransform) });
			_root.transform.SetParent(((Component)rootCanvas).transform, false);
			_rootRT = _root.GetComponent<RectTransform>();
			_rootRT.anchorMin = new Vector2(0f, 1f);
			_rootRT.anchorMax = new Vector2(0f, 1f);
			_rootRT.pivot = new Vector2(0f, 1f);
			_rootRT.sizeDelta = new Vector2(num, num2);
			float num3 = Plugin.Config?.CanvasPMX ?? 0f;
			float num4 = Plugin.Config?.CanvasPMY ?? 0f;
			_rootRT.anchoredPosition = ((num3 != 0f || num4 != 0f) ? new Vector2(num3, num4) : new Vector2(FabricUI.S(20f), 0f - FabricUI.S(60f)));
			Image obj = _root.AddComponent<Image>();
			obj.sprite = FabricUI.CreateRoundedSprite(FabricUI.SI(6f), FabricUI.SI(32f));
			obj.type = (Type)1;
			((Graphic)obj).color = GUIHelper.ColSurface;
			((Graphic)obj).raycastTarget = true;
			FabricUI.AddBorder(_root, GUIHelper.ColBorder, 6);
			_root.AddComponent<CanvasPanelDragger>();
			BuildStrip();
			float num5 = FabricUI.S(23f);
			float num6 = FabricUI.S(12f);
			float num7 = FabricUI.S(8f);
			GameObject obj2 = FabricUI.CreateVerticalGroup(_root.transform, "Content", FabricUI.S(4f), new RectOffset(Mathf.RoundToInt(num5), Mathf.RoundToInt(num6), Mathf.RoundToInt(num7), Mathf.RoundToInt(num7)));
			FabricUI.SetStretch(obj2.GetComponent<RectTransform>());
			BuildHeader(obj2.transform);
			BuildPackListHeader(obj2.transform);
			BuildPackListContainer(obj2.transform);
			BuildSectionsArea(obj2.transform);
			BuildActionBar(obj2.transform);
			BuildFooter(obj2.transform);
			_root.SetActive(false);
			_built = true;
		}

		private static void BuildStrip()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("CassetteStrip", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(_root.transform, false);
			_stripImage = val.AddComponent<RawImage>();
			((Graphic)_stripImage).raycastTarget = false;
			FabricUI.SetStretchLeft(val.GetComponent<RectTransform>(), FabricUI.S(15f));
			RefreshStripTexture();
		}

		private static void RefreshStripTexture()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			int texW = Mathf.Max(FabricUI.SI(15f), 2);
			int num = Mathf.Max(Mathf.RoundToInt(_rootRT.sizeDelta.y), 2);
			if (num != _lastStripH || !((Object)(object)_stripImage.texture != (Object)null))
			{
				_stripImage.texture = (Texture)(object)GUIHelper.GetVerticalStripTex(texW, num);
				_lastStripH = num;
			}
		}

		private static void BuildHeader(Transform parent)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = FabricUI.CreateHorizontalGroup(parent, "Header", 6f);
			FabricUI.AddLayout(obj, -1f, FabricUI.S(24f));
			GameObject obj2 = FabricUI.CreateText(obj.transform, "Wordmark", "STITCHWORK", 14, GUIHelper.ColBone, (TextAnchor)3);
			obj2.GetComponent<Text>().fontStyle = (FontStyle)1;
			FabricUI.AddLayout(obj2, FabricUI.S(100f));
			FabricUI.AddLayout(FabricUI.CreateText(obj.transform, "Subtitle", Loc.T("Resource packs"), 11, GUIHelper.ColMuted, (TextAnchor)3), -1f, -1f, -1f, -1f, 1f);
			Transform transform = obj.transform;
			Action onClick = RequestClose;
			Color? textColor = Color.Lerp(GUIHelper.ColDanger, Color.white, 0.35f);
			FabricUI.AddLayout(FabricUI.CreateButton(transform, "Close", "×", onClick, null, textColor), FabricUI.S(26f), FabricUI.S(20f));
		}

		private static void BuildPackListHeader(Transform parent)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = FabricUI.CreateHorizontalGroup(parent, "PacksHeader", 4f);
			FabricUI.AddLayout(obj, -1f, FabricUI.S(22f));
			GameObject obj2 = FabricUI.CreateText(obj.transform, "PacksLabel", Loc.T("PACKS"), 10, GUIHelper.ColMuted, (TextAnchor)3);
			FabricUI.AddLayout(obj2, -1f, -1f, -1f, -1f, 1f);
			_packsLabel = obj2.GetComponent<Text>();
			FabricUI.CreateButton(obj.transform, "GlobalFolder", Loc.T("Global folder"), delegate
			{
				try
				{
					Directory.CreateDirectory(PackLayout.GlobalPacksRoot);
				}
				catch (Exception ex) when (ex is UnauthorizedAccessException || ex is IOException)
				{
					Plugin.Logger.LogWarning((object)("[PackManager] Cannot create global packs root: " + ex.Message));
				}
				IOUtil.OpenDeepestExisting(PackLayout.GlobalPacksRoot);
			});
			GameObject obj3 = FabricUI.CreateButton(obj.transform, "Rescan", Loc.T("Rescan"), delegate
			{
				List<PackInfo> staged = _staged;
				PackManager.Rescan();
				if (staged != null)
				{
					IReadOnlyList<PackInfo> live = PackManager.AllPacks;
					List<PackInfo> list = staged.Where((PackInfo s) => live.Any((PackInfo packInfo) => string.Equals(packInfo.Path, s.Path, StringComparison.OrdinalIgnoreCase))).ToList();
					foreach (PackInfo p in live)
					{
						if (!list.Any((PackInfo m) => string.Equals(m.Path, p.Path, StringComparison.OrdinalIgnoreCase)))
						{
							list.Add(p.Clone());
						}
					}
					_staged = list;
				}
				Rebuild();
			});
			FabricUI.AddLayout(obj3, FabricUI.S(72f), FabricUI.S(20f));
			Text componentInChildren = obj3.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = FabricUI.FontSize(11);
			}
			GameObject obj4 = FabricUI.CreateButton(obj.transform, "DisableAll", Loc.T("Disable all"), delegate
			{
				EnsureStaged();
				foreach (PackInfo item in _staged)
				{
					item.IsEnabled = false;
				}
				Rebuild();
			}, GUIHelper.ColSurface1);
			FabricUI.AddLayout(obj4, FabricUI.S(88f), FabricUI.S(20f));
			Text componentInChildren2 = obj4.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				componentInChildren2.fontSize = FabricUI.FontSize(11);
			}
		}

		private static void BuildPackListContainer(Transform parent)
		{
			GameObject obj = FabricUI.CreateScrollView(parent, "PackList");
			FabricUI.AddLayout(obj, -1f, FabricUI.S(240f), -1f, -1f, -1f, 1f);
			_packListScroll = obj.GetComponent<ScrollRect>();
			_packListContent = (Transform)(object)_packListScroll.content;
		}

		private static void BuildSectionsArea(Transform parent)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = FabricUI.CreateHorizontalGroup(parent, "Sections", 6f);
			FabricUI.AddLayout(obj, -1f, FabricUI.S(22f));
			GameObject obj2 = FabricUI.CreateButton(obj.transform, "ProfilesFold", "", delegate
			{
				_profilesFoldout = !_profilesFoldout;
				Rebuild();
			});
			FabricUI.AddLayout(obj2, -1f, FabricUI.S(22f), -1f, -1f, 1f);
			_profilesFoldText = obj2.GetComponentInChildren<Text>();
			_profilesFoldText.fontSize = FabricUI.FontSize(10);
			((Graphic)_profilesFoldText).color = GUIHelper.ColMuted;
			GameObject obj3 = FabricUI.CreateButton(obj.transform, "ConflictsFold", "", delegate
			{
				_conflictsFoldout = !_conflictsFoldout;
				Rebuild();
			});
			FabricUI.AddLayout(obj3, -1f, FabricUI.S(22f), -1f, -1f, 1f);
			_conflictsFoldText = obj3.GetComponentInChildren<Text>();
			_conflictsFoldText.fontSize = FabricUI.FontSize(10);
			_profilesContent = FabricUI.CreateVerticalGroup(parent, "ProfilesContent", 3f);
			GameObject obj4 = FabricUI.CreateHorizontalGroup(_profilesContent.transform, "ProfileButtons", 4f);
			FabricUI.AddLayout(obj4, -1f, FabricUI.S(24f));
			_profileButtonsContent = obj4.transform;
			GameObject obj5 = FabricUI.CreateHorizontalGroup(_profilesContent.transform, "SaveRow", 4f);
			FabricUI.AddLayout(obj5, -1f, FabricUI.S(24f));
			FabricUI.AddLayout(FabricUI.CreateText(obj5.transform, "SaveLabel", Loc.T("Save as:"), 12, GUIHelper.ColMuted, (TextAnchor)3), FabricUI.S(55f));
			GameObject obj6 = FabricUI.CreateInputField(obj5.transform, "ProfileNameInput", Loc.T("profile name"));
			FabricUI.AddLayout(obj6, FabricUI.S(140f), FabricUI.S(22f));
			_profileNameInput = obj6.GetComponent<InputField>();
			GameObject obj7 = FabricUI.CreateButton(obj5.transform, "SaveBtn", Loc.T("Save"), (Action)delegate
			{
				string text = _profileNameInput.text?.Trim();
				if (!string.IsNullOrWhiteSpace(text))
				{
					PackManager.SaveProfile(text, _staged);
					_profileNameInput.text = "";
					_lastStagedProfile = text;
					Rebuild();
				}
			}, (Color?)GUIHelper.ColConfirm, (Color?)new Color(0.031f, 0.145f, 0.11f, 1f), (Color?)null);
			FabricUI.AddLayout(obj7, FabricUI.S(50f), FabricUI.S(22f));
			Text componentInChildren = obj7.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontStyle = (FontStyle)1;
			}
			_profilesContent.SetActive(false);
			GameObject obj8 = (_conflictsScrollGO = FabricUI.CreateScrollView(parent, "ConflictScroll"));
			_conflictsContent = (Transform)(object)obj8.GetComponent<ScrollRect>().content;
			obj8.SetActive(false);
		}

		private static void BuildActionBar(Transform parent)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			FabricUI.CreateSeparator(parent);
			GameObject obj = FabricUI.CreateVerticalGroup(parent, "ActionBar", 2f);
			GameObject obj2 = FabricUI.CreateHorizontalGroup(obj.transform, "StatusRow", 6f);
			FabricUI.AddLayout(obj2, -1f, FabricUI.S(16f));
			GameObject obj3 = FabricUI.CreateText(obj2.transform, "StatusCount", string.Format(Loc.T("{0}/{1} active"), 0, 0), 11, GUIHelper.ColText, (TextAnchor)3);
			FabricUI.AddLayout(obj3, FabricUI.S(80f));
			_statusText = obj3.GetComponent<Text>();
			GameObject obj4 = FabricUI.CreateText(obj2.transform, "Changes", "", 11, GUIHelper.ColWarn, (TextAnchor)3);
			FabricUI.AddLayout(obj4, -1f, -1f, -1f, -1f, 1f);
			_changesText = obj4.GetComponent<Text>();
			GameObject obj5 = FabricUI.CreateText(obj2.transform, "ApplyHint", "", 10, GUIHelper.ColFaint, (TextAnchor)5);
			FabricUI.AddLayout(obj5, FabricUI.S(170f));
			_applyHint = obj5.GetComponent<Text>();
			obj5.SetActive(false);
			GameObject obj6 = FabricUI.CreateHorizontalGroup(obj.transform, "ActionButtons", 4f);
			FabricUI.AddLayout(obj6, -1f, FabricUI.S(28f));
			_actionBtnRow = obj6;
			_discardBtn = FabricUI.CreateButton(obj6.transform, "Discard", Loc.T("Discard"), delegate
			{
				_staged = null;
				Rebuild();
			});
			FabricUI.AddLayout(_discardBtn, FabricUI.S(88f), FabricUI.S(26f));
			_applyBtn = FabricUI.CreateButton(obj6.transform, "Apply", Loc.T("Apply"), (Action)delegate
			{
				if (_staged != null)
				{
					PackManager.Apply(_staged);
					_staged = null;
					Rebuild();
				}
			}, (Color?)GUIHelper.ColConfirm, (Color?)new Color(0.031f, 0.145f, 0.11f, 1f), (Color?)Color.Lerp(GUIHelper.ColConfirm, Color.white, 0.25f));
			FabricUI.AddLayout(_applyBtn, -1f, FabricUI.S(26f), -1f, -1f, 1f);
			_applyBg = _applyBtn.GetComponent<Image>();
			Transform val = _applyBtn.transform.Find("Apply_Border");
			_applyBorder = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Image>() : null);
			Text componentInChildren = _applyBtn.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontStyle = (FontStyle)1;
			}
			GameObject obj7 = FabricUI.CreateHorizontalGroup(obj.transform, "ClosePrompt", 4f);
			FabricUI.AddLayout(obj7, -1f, FabricUI.S(28f));
			_closePromptRow = obj7;
			GameObject obj8 = FabricUI.CreateButton(obj7.transform, "ApplyClose", Loc.T("Apply & close"), (Action)delegate
			{
				if (_staged != null)
				{
					PackManager.Apply(_staged);
				}
				_staged = null;
				DoClose();
			}, (Color?)GUIHelper.ColConfirm, (Color?)new Color(0.031f, 0.145f, 0.11f, 1f), (Color?)Color.Lerp(GUIHelper.ColConfirm, Color.white, 0.25f));
			FabricUI.AddLayout(obj8, -1f, FabricUI.S(26f), -1f, -1f, 1.4f);
			Text componentInChildren2 = obj8.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				componentInChildren2.fontStyle = (FontStyle)1;
			}
			FabricUI.AddLayout(FabricUI.CreateButton(obj7.transform, "DiscardClose", Loc.T("Discard & close"), (Action)delegate
			{
				_staged = null;
				DoClose();
			}, (Color?)new Color(GUIHelper.ColDanger.r * 0.5f, GUIHelper.ColDanger.g * 0.5f, GUIHelper.ColDanger.b * 0.5f), (Color?)null, (Color?)null), -1f, FabricUI.S(26f), -1f, -1f, 1f);
			FabricUI.AddLayout(FabricUI.CreateButton(obj7.transform, "KeepClose", Loc.T("Keep & close"), delegate
			{
				DoClose();
			}), -1f, FabricUI.S(26f), -1f, -1f, 1f);
			obj7.SetActive(false);
		}

		private static void BuildFooter(Transform parent)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			FabricUI.CreateSeparator(parent);
			GameObject obj = FabricUI.CreateHorizontalGroup(parent, "Footer", 4f);
			FabricUI.AddLayout(obj, -1f, FabricUI.S(26f));
			FabricUI.AddLayout(FabricUI.CreateText(obj.transform, "Version", "Stitchwork 0.8.6", 9, GUIHelper.ColFaint, (TextAnchor)3), -1f, -1f, -1f, -1f, 1f);
			Transform transform = obj.transform;
			string text = "语言 " + Loc.NativeName(Plugin.Config.UILanguage.ToLowerInvariant());
			Action onClick = delegate
			{
				Loc.CycleLanguage();
				Rebuild();
			};
			Color? textColor = GUIHelper.ColMuted;
			GameObject obj2 = FabricUI.CreateButton(transform, "LangCycle", text, onClick, null, textColor);
			FabricUI.AddLayout(obj2, FabricUI.S(92f), FabricUI.S(20f));
			_langBtnText = obj2.GetComponentInChildren<Text>();
			_langBtnText.fontSize = FabricUI.FontSize(9);
			Transform transform2 = obj.transform;
			string text2 = (Plugin.ShowStatusOverlay ? Loc.T("Overlay: on") : Loc.T("Overlay: off"));
			Action onClick2 = delegate
			{
				Plugin.ShowStatusOverlay = !Plugin.ShowStatusOverlay;
				Rebuild();
			};
			textColor = GUIHelper.ColMuted;
			GameObject obj3 = FabricUI.CreateButton(transform2, "OverlayToggle", text2, onClick2, null, textColor);
			FabricUI.AddLayout(obj3, FabricUI.S(84f), FabricUI.S(20f));
			_overlayBtnText = obj3.GetComponentInChildren<Text>();
			_overlayBtnText.fontSize = FabricUI.FontSize(9);
			Transform transform3 = obj.transform;
			string text3 = Loc.T("dev tools");
			Action onClick3 = delegate
			{
				DevHub.OpenAt(1);
			};
			textColor = GUIHelper.ColMuted;
			GameObject obj4 = FabricUI.CreateButton(transform3, "DevTools", text3, onClick3, null, textColor);
			FabricUI.AddLayout(obj4, FabricUI.S(64f), FabricUI.S(20f));
			Text componentInChildren = obj4.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = FabricUI.FontSize(9);
			}
		}

		private static void Rebuild(bool keepPrompts = false)
		{
			if (!((Object)(object)_root == (Object)null))
			{
				if (!keepPrompts)
				{
					_closePrompt = false;
					_pendingProfileDelete = null;
				}
				NormalizeStaged();
				List<PackInfo> list = _staged ?? PackManager.AllPacks.ToList();
				float num = (((Object)(object)_packListScroll != (Object)null) ? _packListScroll.verticalNormalizedPosition : 1f);
				RefreshStripTexture();
				RebuildPackList(list);
				RebuildProfiles();
				RefreshConflicts();
				RefreshActionBar(list);
				RefreshFooter();
				if ((Object)(object)_packListScroll != (Object)null)
				{
					Canvas.ForceUpdateCanvases();
					_packListScroll.verticalNormalizedPosition = Mathf.Clamp01(num);
				}
			}
		}

		private static void NormalizeStaged()
		{
			if (_staged != null && !StagedDiffers())
			{
				_staged = null;
			}
		}

		private static bool StagedDiffers()
		{
			IReadOnlyList<PackInfo> allPacks = PackManager.AllPacks;
			if (_staged.Count != allPacks.Count)
			{
				return true;
			}
			for (int i = 0; i < _staged.Count; i++)
			{
				PackInfo packInfo = _staged[i];
				PackInfo packInfo2 = allPacks[i];
				if (!string.Equals(packInfo.Path, packInfo2.Path, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				if (packInfo.IsEnabled != packInfo2.IsEnabled)
				{
					return true;
				}
				if (packInfo.ReloadTrigger != packInfo2.ReloadTrigger)
				{
					return true;
				}
				if (packInfo.Conditions.Count != packInfo2.Conditions.Count)
				{
					return true;
				}
				for (int j = 0; j < packInfo.Conditions.Count; j++)
				{
					if (packInfo.Conditions[j].Serialize() != packInfo2.Conditions[j].Serialize())
					{
						return true;
					}
				}
			}
			return false;
		}

		private static PackInfo StagedPack(string path)
		{
			EnsureStaged();
			return _staged.FirstOrDefault((PackInfo p) => string.Equals(p.Path, path, StringComparison.OrdinalIgnoreCase));
		}

		private static void RebuildPackList(List<PackInfo> list)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			FabricUI.ClearChildren(_packListContent);
			if (list.Count == 0)
			{
				FabricUI.AddLayout(FabricUI.CreateText(_packListContent, "Empty", Loc.T("No packs found.\nDrop packs into Stitchwork/Packs/ or install via Thunderstore."), 12, GUIHelper.ColMuted, (TextAnchor)3), -1f, FabricUI.S(40f));
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				BuildPackRow(list, i);
			}
		}

		private static void BuildPackRow(List<PackInfo> list, int idx)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0650: Unknown result type (might be due to invalid IL or missing references)
			//IL_0655: Unknown result type (might be due to invalid IL or missing references)
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0649: Unknown result type (might be due to invalid IL or missing references)
			//IL_069c: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			PackInfo packInfo = list[idx];
			bool hasConditions = packInfo.HasConditions;
			Color color = (packInfo.IsEnabled ? GUIHelper.ColSurface1 : Color.Lerp(GUIHelper.ColSurface, GUIHelper.ColSurface1, 0.5f));
			GameObject val = FabricUI.CreatePanel(_packListContent, $"Pack_{idx}", color);
			Image component = val.GetComponent<Image>();
			component.sprite = FabricUI.CreateRoundedSprite(FabricUI.SI(5f), FabricUI.SI(20f));
			component.type = (Type)1;
			FabricUI.AddBorder(val, GUIHelper.ColBorder, 5);
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = FabricUI.S(2f);
			((LayoutGroup)obj).padding = new RectOffset(FabricUI.SI(9f), FabricUI.SI(8f), FabricUI.SI(6f), FabricUI.SI(6f));
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			FabricUI.AddFitter(val, (FitMode)0, (FitMode)2);
			if (packInfo.IsEnabled)
			{
				GameObject val2 = new GameObject("StateEdge", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val2.transform.SetParent(val.transform, false);
				((Graphic)val2.GetComponent<Image>()).color = GUIHelper.ColConfirm;
				((Graphic)val2.GetComponent<Image>()).raycastTarget = false;
				FabricUI.SetStretchLeft(val2.GetComponent<RectTransform>(), FabricUI.S(3f));
				FabricUI.AddLayout(val2, -1f, -1f, -1f, -1f, -1f, -1f, ignoreLayout: true);
			}
			int capturedIdx = idx;
			GameObject obj2 = FabricUI.CreateHorizontalGroup(val.transform, "MainRow", 4f);
			FabricUI.AddFitter(obj2, (FitMode)0, (FitMode)2);
			bool canUp = idx > 0;
			bool canDown = idx < list.Count - 1;
			float num = FabricUI.S(18f);
			float preferredHeight = FabricUI.S(13f);
			GameObject obj3 = FabricUI.CreateVerticalGroup(obj2.transform, "Arrows", 2f);
			((HorizontalOrVerticalLayoutGroup)obj3.GetComponent<VerticalLayoutGroup>()).childForceExpandWidth = false;
			FabricUI.AddLayout(obj3, num, -1f, num);
			Transform transform = obj3.transform;
			Action onClick = delegate
			{
				if (canUp)
				{
					EnsureStaged();
					List<PackInfo> staged = _staged;
					int index = capturedIdx - 1;
					List<PackInfo> staged2 = _staged;
					int index2 = capturedIdx;
					PackInfo value = _staged[capturedIdx];
					PackInfo value2 = _staged[capturedIdx - 1];
					staged[index] = value;
					staged2[index2] = value2;
					Rebuild();
				}
			};
			Color? textColor = GUIHelper.ColMuted;
			GameObject val3 = FabricUI.CreateButton(transform, "Up", "▲", onClick, null, textColor);
			float minWidth = num;
			FabricUI.AddLayout(val3, num, preferredHeight, minWidth);
			val3.GetComponentInChildren<Text>().fontSize = FabricUI.FontSize(8);
			if (!canUp)
			{
				((Selectable)val3.GetComponent<Button>()).interactable = false;
			}
			Transform transform2 = obj3.transform;
			Action onClick2 = delegate
			{
				if (canDown)
				{
					EnsureStaged();
					List<PackInfo> staged = _staged;
					int index = capturedIdx + 1;
					List<PackInfo> staged2 = _staged;
					int index2 = capturedIdx;
					PackInfo value = _staged[capturedIdx];
					PackInfo value2 = _staged[capturedIdx + 1];
					staged[index] = value;
					staged2[index2] = value2;
					Rebuild();
				}
			};
			textColor = GUIHelper.ColMuted;
			GameObject val4 = FabricUI.CreateButton(transform2, "Down", "▼", onClick2, null, textColor);
			minWidth = num;
			FabricUI.AddLayout(val4, num, preferredHeight, minWidth);
			val4.GetComponentInChildren<Text>().fontSize = FabricUI.FontSize(8);
			if (!canDown)
			{
				((Selectable)val4.GetComponent<Button>()).interactable = false;
			}
			GameObject obj4 = FabricUI.CreateVerticalGroup(obj2.transform, "NameCol", 1f);
			FabricUI.AddLayout(obj4, -1f, -1f, -1f, -1f, 1f);
			GameObject val5 = FabricUI.CreateHorizontalGroup(obj4.transform, "NameRow", 4f);
			FabricUI.AddLayout(val5, -1f, FabricUI.S(16f));
			FabricUI.AddLayout(FabricUI.CreateText(val5.transform, "Name", packInfo.Name, 13, packInfo.IsEnabled ? GUIHelper.ColText : GUIHelper.ColMuted, (TextAnchor)3), -1f, -1f, -1f, -1f, 1f);
			int num2 = ConflictTracker.ShadowedCount(packInfo.Path);
			if (num2 > 0)
			{
				FabricUI.AddLayout(FabricUI.CreateText(val5.transform, "Warn", string.Format(Loc.T("{0} shadowed"), num2), 10, GUIHelper.ColWarn, (TextAnchor)3), FabricUI.S(80f));
			}
			List<string> list2 = new List<string> { (packInfo.Source == PackSource.Global) ? Loc.T("global") : ((packInfo.Source != PackSource.Customizer) ? Loc.T("pack") : (PackLayout.IsMarkerRoot(packInfo.Path) ? Loc.T("wayward") : Loc.T("customizer"))) };
			string badge = packInfo.Stats.Badge;
			if (badge != null)
			{
				list2.Add(badge);
			}
			if (!string.IsNullOrEmpty(packInfo.EffectiveAuthor))
			{
				list2.Add(string.Format(Loc.T("by {0}"), packInfo.EffectiveAuthor));
			}
			if (!string.IsNullOrEmpty(packInfo.Version))
			{
				list2.Add("v" + packInfo.Version);
			}
			string text = CondSummary(packInfo);
			if (text != null)
			{
				list2.Add("<color=#E87530>" + text + "</color>");
			}
			FabricUI.AddLayout(FabricUI.CreateText(obj4.transform, "SubLine", string.Join(" · ", list2), 10, packInfo.IsEnabled ? GUIHelper.ColMuted : GUIHelper.ColFaint, (TextAnchor)3), -1f, FabricUI.S(13f));
			string packPath = packInfo.Path;
			bool flag = _conditionsOpen.Contains(packPath) || hasConditions;
			Transform transform3 = obj2.transform;
			Action onClick3 = delegate
			{
				if (_conditionsOpen.Contains(packPath))
				{
					_conditionsOpen.Remove(packPath);
				}
				else
				{
					_conditionsOpen.Add(packPath);
				}
				Rebuild();
			};
			textColor = (flag ? Color.Lerp(GUIHelper.ColAccent, Color.white, 0.3f) : GUIHelper.ColMuted);
			GameObject obj5 = FabricUI.CreateButton(borderColor: flag ? new Color?(new Color(GUIHelper.ColAccent.r, GUIHelper.ColAccent.g, GUIHelper.ColAccent.b, 0.55f)) : ((Color?)null), parent: transform3, name: "Gear", text: "cfg", onClick: onClick3, bgColor: null, textColor: textColor);
			FabricUI.AddLayout(obj5, FabricUI.S(34f), minWidth: FabricUI.S(34f), preferredHeight: FabricUI.S(24f));
			obj5.GetComponentInChildren<Text>().fontSize = FabricUI.FontSize(10);
			PackInfo packRef = packInfo;
			Transform transform4 = obj2.transform;
			string text2 = Loc.T("scan@doctor", "scan");
			Action onClick4 = delegate
			{
				string text3 = PackDoctor.ScanAndReport(packRef);
				if (text3 != null)
				{
					IOUtil.OpenPath(text3);
				}
			};
			Color? textColor2 = GUIHelper.ColMuted;
			GameObject obj6 = FabricUI.CreateButton(transform4, "Doctor", text2, onClick4, null, textColor2);
			FabricUI.AddLayout(obj6, FabricUI.S(40f), minWidth: FabricUI.S(40f), preferredHeight: FabricUI.S(24f));
			obj6.GetComponentInChildren<Text>().fontSize = FabricUI.FontSize(10);
			FabricUI.CreateSwitch(obj2.transform, "Toggle", packInfo.IsEnabled, delegate
			{
				EnsureStaged();
				_staged[capturedIdx].IsEnabled = !_staged[capturedIdx].IsEnabled;
				Rebuild();
			});
			if (_conditionsOpen.Contains(packInfo.Path))
			{
				FabricUI.CreateSeparator(val.transform);
				BuildConditionEditor(val.transform, packInfo);
			}
		}

		private static string CondSummary(PackInfo pack)
		{
			if (!pack.HasConditions)
			{
				return null;
			}
			PackCondition packCondition = pack.Conditions[0];
			string text = ((packCondition.Type == ConditionType.CrestEquipped) ? PackCondition.CrestDisplayName(packCondition.Value) : (string.IsNullOrEmpty(packCondition.Value) ? "?" : packCondition.Value));
			string text2 = packCondition.TypeLabel + ": " + text;
			if (pack.Conditions.Count > 1)
			{
				text2 += $" +{pack.Conditions.Count - 1}";
			}
			return text2;
		}

		private static void RebuildProfiles()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			FabricUI.ClearChildren(_profileButtonsContent);
			string[] profileNames = PackManager.GetProfileNames();
			string arg = (_profilesFoldout ? "▼" : "▶");
			_profilesFoldText.text = string.Format("{0}  {1} · {2}", arg, Loc.T("PROFILES"), profileNames.Length);
			_profilesContent.SetActive(_profilesFoldout);
			if (profileNames.Length == 0)
			{
				FabricUI.AddLayout(FabricUI.CreateText(_profileButtonsContent, "NoProfiles", Loc.T("No saved profiles."), 11, GUIHelper.ColMuted, (TextAnchor)3), FabricUI.S(140f));
				return;
			}
			string[] array = profileNames;
			foreach (string text in array)
			{
				string capName = text;
				bool flag = string.Equals(capName, _lastStagedProfile, StringComparison.Ordinal);
				Transform profileButtonsContent = _profileButtonsContent;
				string name = "Prof_" + text;
				Action onClick = delegate
				{
					List<PackInfo> list = PackManager.StageProfile(capName);
					if (list != null)
					{
						_staged = list;
						_lastStagedProfile = capName;
					}
					Rebuild();
				};
				Color? borderColor = (flag ? new Color?(new Color(GUIHelper.ColAccent.r, GUIHelper.ColAccent.g, GUIHelper.ColAccent.b, 0.9f)) : ((Color?)null));
				GameObject obj = FabricUI.CreateButton(profileButtonsContent, name, text, onClick, null, null, borderColor);
				Text componentInChildren = obj.GetComponentInChildren<Text>();
				componentInChildren.fontSize = FabricUI.FontSize(11);
				if (flag)
				{
					componentInChildren.fontStyle = (FontStyle)1;
				}
				float preferredWidth = Mathf.Clamp(componentInChildren.preferredWidth + FabricUI.S(22f), FabricUI.S(64f), FabricUI.S(180f));
				FabricUI.AddLayout(obj, preferredWidth, FabricUI.S(22f));
				bool flag2 = string.Equals(capName, _pendingProfileDelete, StringComparison.Ordinal);
				FabricUI.AddLayout(FabricUI.CreateButton(_profileButtonsContent, "Del_" + text, flag2 ? Loc.T("sure?") : "✕", delegate
				{
					if (string.Equals(capName, _pendingProfileDelete, StringComparison.Ordinal))
					{
						PackManager.DeleteProfile(capName);
						_pendingProfileDelete = null;
						if (string.Equals(capName, _lastStagedProfile, StringComparison.Ordinal))
						{
							_lastStagedProfile = null;
						}
						Rebuild();
					}
					else
					{
						_pendingProfileDelete = capName;
						Rebuild(keepPrompts: true);
					}
				}, (Color)(flag2 ? new Color(GUIHelper.ColDanger.r * 0.6f, GUIHelper.ColDanger.g * 0.6f, GUIHelper.ColDanger.b * 0.6f) : GUIHelper.ColSurface1), flag2 ? Color.white : GUIHelper.ColDanger), FabricUI.S(flag2 ? 44 : 20), FabricUI.S(22f));
			}
		}

		private static string ResolveLoserFile(ConflictTracker.Entry e)
		{
			if (!string.IsNullOrEmpty(e.LoserFile))
			{
				return e.LoserFile;
			}
			if (e.Type == "text" && e.LoserPack != null)
			{
				string[] array = e.Key.Split('/');
				if (array.Length >= 3)
				{
					return Path.Combine(e.LoserPack, "Text", array[0], array[1] + ".yml");
				}
			}
			return null;
		}

		private static string TruncMiddle(string s, int max)
		{
			if (string.IsNullOrEmpty(s) || s.Length <= max)
			{
				return s;
			}
			int num = (max - 1) * 11 / 20;
			int length = max - 1 - num;
			return s.Substring(0, length) + "…" + s.Substring(s.Length - num);
		}

		private static void RefreshConflicts()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			int total = ConflictTracker.Total;
			string arg = (_conflictsFoldout ? "▼" : "▶");
			_conflictsFoldText.text = string.Format("{0}  {1} · {2}", arg, Loc.T("CONFLICTS"), total);
			((Graphic)_conflictsFoldText).color = ((total > 0) ? GUIHelper.ColWarn : GUIHelper.ColMuted);
			bool flag = _conflictsFoldout && total > 0;
			_conflictsScrollGO.SetActive(flag);
			if (!flag)
			{
				return;
			}
			float v = Mathf.Min((float)total * 23f + 8f, 210f);
			FabricUI.AddLayout(_conflictsScrollGO, -1f, FabricUI.S(v), -1f, -1f, -1f, 0f);
			FabricUI.ClearChildren(_conflictsContent);
			Color color = default(Color);
			foreach (ConflictTracker.Entry item in ConflictTracker.All)
			{
				string packName = PackManager.GetPackName(item.WinnerPack);
				string packName2 = PackManager.GetPackName(item.LoserPack);
				GameObject val = FabricUI.CreateHorizontalGroup(_conflictsContent, "ConflictRow", 4f, new RectOffset(FabricUI.SI(2f), FabricUI.SI(2f), FabricUI.SI(2f), FabricUI.SI(2f)));
				FabricUI.AddLayout(val, -1f, FabricUI.S(20f));
				((Color)(ref color))..ctor(GUIHelper.ColAccent.r * 0.18f, GUIHelper.ColAccent.g * 0.18f, GUIHelper.ColAccent.b * 0.18f, 0.85f);
				GameObject val2 = FabricUI.CreatePanel(val.transform, "Type", color);
				FabricUI.AddLayout(val2, FabricUI.S(56f), FabricUI.S(18f));
				GameObject val3 = new GameObject("TypeText", new Type[1] { typeof(RectTransform) });
				val3.transform.SetParent(val2.transform, false);
				FabricUI.SetStretch(val3.GetComponent<RectTransform>());
				Text obj = val3.AddComponent<Text>();
				obj.text = item.Type;
				obj.font = FabricUI.GameFont;
				obj.fontSize = FabricUI.FontSize(10);
				((Graphic)obj).color = GUIHelper.ColAccent;
				obj.alignment = (TextAnchor)4;
				((Graphic)obj).raycastTarget = false;
				GameObject obj2 = FabricUI.CreateText(val.transform, "Key", TruncMiddle(item.Key, 36), 11, GUIHelper.ColText, (TextAnchor)3);
				FabricUI.AddLayout(obj2, -1f, -1f, -1f, -1f, 1f);
				Text component = obj2.GetComponent<Text>();
				component.horizontalOverflow = (HorizontalWrapMode)0;
				component.verticalOverflow = (VerticalWrapMode)0;
				FabricUI.AddLayout(FabricUI.CreateText(val.transform, "Arrow", packName + " › " + packName2, 10, GUIHelper.ColMuted, (TextAnchor)5), FabricUI.S(140f));
				bool resolvable = item.Type == "text" && item.WinnerPack == null && item.LoserPack != null;
				string loserPackPath = item.LoserPack;
				string loserFile = ResolveLoserFile(item);
				string jumpPath = item.LoserPack ?? SpriteLoader.LoadPath;
				GameObject obj3 = FabricUI.CreateButton(val.transform, "Jump", Loc.T(resolvable ? "Resolve" : "Open"), delegate
				{
					if (resolvable)
					{
						Hide();
						DevHub.OpenAt(2);
						TextMergePanel.OpenMergeFor(loserPackPath);
					}
					else if (loserFile != null && File.Exists(loserFile))
					{
						IOUtil.RevealPath(loserFile);
					}
					else if (Directory.Exists(jumpPath))
					{
						IOUtil.OpenPath(jumpPath);
					}
				}, GUIHelper.ColSurface1);
				FabricUI.AddLayout(obj3, FabricUI.S(resolvable ? 56 : 40), FabricUI.S(18f));
				Text componentInChildren = obj3.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.fontSize = FabricUI.FontSize(9);
					((Graphic)componentInChildren).color = GUIHelper.ColMuted;
				}
			}
		}

		private static void RefreshActionBar(List<PackInfo> list)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			int num = list.Count((PackInfo p) => p.IsEnabled);
			int count = list.Count;
			_statusText.text = string.Format(Loc.T("{0}/{1} active"), num, count);
			_changesText.text = (HasChanges ? Loc.T("unsaved changes") : "");
			((Selectable)_discardBtn.GetComponent<Button>()).interactable = HasChanges;
			((Selectable)_applyBtn.GetComponent<Button>()).interactable = HasChanges;
			((Graphic)_applyBg).color = (HasChanges ? GUIHelper.ColConfirm : GUIHelper.ColSurface2);
			Text componentInChildren = _applyBtn.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Graphic)componentInChildren).color = (Color)(HasChanges ? new Color(0.031f, 0.145f, 0.11f, 1f) : GUIHelper.ColFaint);
			}
			if ((Object)(object)_applyBorder != (Object)null)
			{
				((Graphic)_applyBorder).color = (HasChanges ? Color.Lerp(GUIHelper.ColConfirm, Color.white, 0.25f) : GUIHelper.ColBorderHi);
			}
			bool flag = _closePrompt && HasChanges;
			if ((Object)(object)_actionBtnRow != (Object)null)
			{
				_actionBtnRow.SetActive(!flag);
			}
			if ((Object)(object)_closePromptRow != (Object)null)
			{
				_closePromptRow.SetActive(flag);
			}
			if ((Object)(object)_applyHint != (Object)null)
			{
				bool flag2 = HasChanges && GameBridge.IsInGameScene;
				((Component)_applyHint).gameObject.SetActive(flag2);
				if (flag2)
				{
					_applyHint.text = Loc.T("Apply reloads the current scene");
				}
			}
		}

		private static void RefreshFooter()
		{
			if ((Object)(object)_overlayBtnText != (Object)null)
			{
				_overlayBtnText.text = (Plugin.ShowStatusOverlay ? Loc.T("Overlay: on") : Loc.T("Overlay: off"));
			}
			if ((Object)(object)_langBtnText != (Object)null)
			{
				_langBtnText.text = "语言 " + Loc.NativeName(Plugin.Config.UILanguage.ToLowerInvariant());
			}
		}

		private static void BuildConditionEditor(Transform parent, PackInfo pack)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0902: Unknown result type (might be due to invalid IL or missing references)
			//IL_093e: Expected O, but got Unknown
			//IL_09b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0616: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Expected O, but got Unknown
			//IL_0bd8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bdd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c19: Expected O, but got Unknown
			//IL_0c87: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc3: Expected O, but got Unknown
			//IL_0ce7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf1: Unknown result type (might be due to invalid IL or missing references)
			//IL_075b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0760: Unknown result type (might be due to invalid IL or missing references)
			//IL_0773: Unknown result type (might be due to invalid IL or missing references)
			//IL_0795: Expected O, but got Unknown
			//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0804: Unknown result type (might be due to invalid IL or missing references)
			//IL_0819: Unknown result type (might be due to invalid IL or missing references)
			//IL_082e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0855: Unknown result type (might be due to invalid IL or missing references)
			//IL_086e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b15: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b49: Expected O, but got Unknown
			//IL_0aef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b62: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba3: Expected O, but got Unknown
			GameObject val = FabricUI.CreatePanel(parent, "CondEditor", new Color(GUIHelper.ColSurface.r * 1.2f, GUIHelper.ColSurface.g * 1.2f, GUIHelper.ColSurface.b * 1.2f, 0.9f));
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = FabricUI.S(1f);
			((LayoutGroup)obj).padding = new RectOffset(FabricUI.SI(2f), FabricUI.SI(2f), FabricUI.SI(2f), FabricUI.SI(2f));
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			FabricUI.AddFitter(val, (FitMode)0, (FitMode)2);
			GameObject obj2 = FabricUI.CreateHorizontalGroup(val.transform, "TriggerRow", 4f);
			FabricUI.AddLayout(obj2, -1f, FabricUI.S(18f));
			FabricUI.AddLayout(FabricUI.CreateText(obj2.transform, "TriggerLabel", Loc.T("Reload:"), 11, GUIHelper.ColMuted, (TextAnchor)3), FabricUI.S(44f));
			string condPath = pack.Path;
			bool flag = pack.ReloadTrigger == ReloadTrigger.OnSceneTransition;
			FabricUI.AddLayout(FabricUI.CreateButton(obj2.transform, "TrigScene", Loc.T("on scene"), delegate
			{
				StagedPack(condPath).ReloadTrigger = ReloadTrigger.OnSceneTransition;
				Rebuild();
			}, (Color)(flag ? new Color(GUIHelper.ColAccent.r * 0.3f, GUIHelper.ColAccent.g * 0.3f, GUIHelper.ColAccent.b * 0.3f) : GUIHelper.ColSurface1), flag ? GUIHelper.ColAccent : Color.white), FabricUI.S(72f), FabricUI.S(18f));
			bool flag2 = pack.ReloadTrigger == ReloadTrigger.HotReload;
			FabricUI.AddLayout(FabricUI.CreateButton(obj2.transform, "TrigHot", Loc.T("hot reload"), delegate
			{
				StagedPack(condPath).ReloadTrigger = ReloadTrigger.HotReload;
				Rebuild();
			}, (Color)(flag2 ? new Color(GUIHelper.ColAccent.r * 0.3f, GUIHelper.ColAccent.g * 0.3f, GUIHelper.ColAccent.b * 0.3f) : GUIHelper.ColSurface1), flag2 ? GUIHelper.ColAccent : Color.white), FabricUI.S(80f), FabricUI.S(18f));
			if (pack.ReloadTrigger == ReloadTrigger.OnSceneTransition && pack.Conditions.Any((PackCondition c) => PackCondition.IsMidSceneType(c.Type)))
			{
				FabricUI.AddLayout(FabricUI.CreateText(val.transform, "TrigWarn", Loc.T("⚠ Crest/Nail/PlayerData change mid-scene — use Hot reload."), 10, GUIHelper.ColWarn, (TextAnchor)3), -1f, FabricUI.S(14f));
			}
			int num = 0;
			foreach (List<int> item in BuildClauses(pack.Conditions))
			{
				num += item.Count;
			}
			int num2 = num + 1;
			float v = Mathf.Min((float)num2 * 32f + (float)Math.Max(0, num2 - 1) * 4f + 8f, 320f);
			GameObject obj3 = FabricUI.CreateScrollView(val.transform, "CondScroll");
			FabricUI.AddLayout(obj3, -1f, FabricUI.S(v), -1f, FabricUI.S(40f), -1f, 0f);
			GameObject obj4 = FabricUI.CreateHorizontalGroup((Transform)(object)obj3.GetComponent<ScrollRect>().content, "Columns", 1f);
			FabricUI.AddLayout(obj4, -1f, -1f, -1f, -1f, 1f);
			FabricUI.AddFitter(obj4, (FitMode)0, (FitMode)2);
			HorizontalLayoutGroup component = obj4.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			GameObject val2 = FabricUI.CreateVerticalGroup(obj4.transform, "OpCol");
			FabricUI.AddLayout(val2, FabricUI.S(34f), -1f, FabricUI.S(34f));
			VerticalLayoutGroup component2 = val2.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true;
			GameObject val3 = FabricUI.CreateVerticalGroup(obj4.transform, "BracketCol");
			FabricUI.AddLayout(val3, FabricUI.S(8f), -1f, FabricUI.S(8f));
			VerticalLayoutGroup component3 = val3.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
			GameObject val4 = FabricUI.CreateVerticalGroup(obj4.transform, "CondCol", 4f);
			FabricUI.AddLayout(val4, -1f, -1f, -1f, -1f, 1f);
			List<List<int>> list = BuildClauses(pack.Conditions);
			int num3 = 0;
			int condIdx = -1;
			Color value = default(Color);
			for (int num4 = 0; num4 < list.Count; num4++)
			{
				List<int> list2 = list[num4];
				bool flag3 = num4 == 0;
				for (int num5 = 0; num5 < list2.Count; num5++)
				{
					int num6 = list2[num5];
					bool flag4 = num5 == 0;
					if (num3 == 0)
					{
						GameObject val5 = new GameObject("OpFirst", new Type[1] { typeof(RectTransform) });
						val5.transform.SetParent(val2.transform, false);
						FabricUI.AddLayout(val5, -1f, BannerH(num6) * 0.5f);
					}
					else
					{
						string text;
						Action onClick;
						if (flag4 && !flag3)
						{
							text = Loc.T("OR");
							int capOrIdx = list2[0] - 1;
							onClick = delegate
							{
								StagedPack(condPath).Conditions[capOrIdx].JoinNext = LogicJoin.And;
								Rebuild();
							};
						}
						else
						{
							text = Loc.T("AND");
							int capAndIdx = num6 - 1;
							onClick = delegate
							{
								StagedPack(condPath).Conditions[capAndIdx].JoinNext = LogicJoin.Or;
								Rebuild();
							};
						}
						((Color)(ref value))..ctor(GUIHelper.ColAccent.r * 0.18f, GUIHelper.ColAccent.g * 0.18f, GUIHelper.ColAccent.b * 0.18f, 0.95f);
						float preferredHeight = BannerH(condIdx) * 0.5f + FabricUI.S(4f) + BannerH(num6) * 0.5f;
						GameObject val6 = new GameObject($"OpSlot_{num3}", new Type[1] { typeof(RectTransform) });
						val6.transform.SetParent(val2.transform, false);
						FabricUI.AddLayout(val6, -1f, preferredHeight);
						GameObject obj5 = FabricUI.CreateButton(val6.transform, $"Op_{num3}", text, onClick, (Color?)value, (Color?)GUIHelper.ColAccent, (Color?)new Color(GUIHelper.ColAccent.r, GUIHelper.ColAccent.g, GUIHelper.ColAccent.b, 0.5f));
						RectTransform component4 = obj5.GetComponent<RectTransform>();
						component4.anchorMin = new Vector2(0f, 0.5f);
						component4.anchorMax = new Vector2(1f, 0.5f);
						component4.pivot = new Vector2(0.5f, 0.5f);
						component4.anchoredPosition = new Vector2(0f, (BannerH(num6) - BannerH(condIdx)) * 0.25f);
						component4.sizeDelta = new Vector2(0f, FabricUI.S(22f));
						Text componentInChildren = obj5.GetComponentInChildren<Text>();
						if ((Object)(object)componentInChildren != (Object)null)
						{
							componentInChildren.fontStyle = (FontStyle)1;
							componentInChildren.fontSize = FabricUI.FontSize(11);
						}
					}
					BuildConditionRow(val4.transform, pack, num6);
					condIdx = num6;
					num3++;
				}
			}
			GameObject val7 = new GameObject("GhostOpSpacer", new Type[1] { typeof(RectTransform) });
			val7.transform.SetParent(val2.transform, false);
			FabricUI.AddLayout(val7, -1f, FabricUI.S(32f));
			Color value2 = default(Color);
			((Color)(ref value2))..ctor(GUIHelper.ColSurface1.r, GUIHelper.ColSurface1.g, GUIHelper.ColSurface1.b, 0.35f);
			Color value3 = default(Color);
			((Color)(ref value3))..ctor(GUIHelper.ColPop1.r, GUIHelper.ColPop1.g, GUIHelper.ColPop1.b, 0.75f);
			FabricUI.AddLayout(FabricUI.CreateButton(val4.transform, "GhostAdd", Loc.T("+ Add condition"), (Action)delegate
			{
				StagedPack(condPath).Conditions.Add(new PackCondition());
				Rebuild();
			}, (Color?)value2, (Color?)value3, (Color?)new Color(GUIHelper.ColAccent.r, GUIHelper.ColAccent.g, GUIHelper.ColAccent.b, 0.28f)), -1f, FabricUI.S(32f));
			Color color = default(Color);
			((Color)(ref color))..ctor(Mathf.Min(GUIHelper.ColPop2.r * 1.4f, 1f), Mathf.Min(GUIHelper.ColPop2.g * 1.4f, 1f), Mathf.Min(GUIHelper.ColPop2.b * 1.4f, 1f), 1f);
			foreach (List<int> item2 in list)
			{
				float num7 = 0f;
				for (int num8 = 0; num8 < item2.Count; num8++)
				{
					num7 += BannerH(item2[num8]);
				}
				num7 += FabricUI.S(4f) * (float)(item2.Count - 1);
				if (item2.Count > 1)
				{
					BuildNotchedBracket(val3.transform, num7, color);
				}
				else
				{
					GameObject val8 = new GameObject("BracketSpacer", new Type[1] { typeof(RectTransform) });
					val8.transform.SetParent(val3.transform, false);
					FabricUI.AddLayout(val8, -1f, num7);
				}
				GameObject val9 = new GameObject("BracketGap", new Type[1] { typeof(RectTransform) });
				val9.transform.SetParent(val3.transform, false);
				FabricUI.AddLayout(val9, -1f, FabricUI.S(4f));
			}
			GameObject val10 = new GameObject("GhostBracketSpacer", new Type[1] { typeof(RectTransform) });
			val10.transform.SetParent(val3.transform, false);
			FabricUI.AddLayout(val10, -1f, FabricUI.S(32f));
			string packPath2 = pack.Path;
			GameObject val11 = FabricUI.CreateHorizontalGroup(val.transform, "FooterRow", 4f);
			FabricUI.AddLayout(val11, -1f, FabricUI.S(24f));
			GameObject val12 = new GameObject("FooterSpacer", new Type[1] { typeof(RectTransform) });
			val12.transform.SetParent(val11.transform, false);
			FabricUI.AddLayout(val12, -1f, -1f, -1f, -1f, 1f);
			FabricUI.AddLayout(FabricUI.CreateButton(val11.transform, "Done", Loc.T("Done"), delegate
			{
				_conditionsOpen.Remove(packPath2);
				Rebuild();
			}, GUIHelper.ColConfirm, Color.white), FabricUI.S(70f), FabricUI.S(22f));
			float BannerH(int index)
			{
				ConditionType type = pack.Conditions[index].Type;
				if (type != ConditionType.CrestEquipped && type != ConditionType.NailUpgrade)
				{
					return FabricUI.S(32f) + FabricUI.S(2f) + FabricUI.S(24f);
				}
				return FabricUI.S(32f);
			}
		}

		private static void BuildNotchedBracket(Transform parent, float height, Color color)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Bracket", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			FabricUI.AddLayout(val, -1f, height);
			float num = FabricUI.S(6f);
			float num2 = FabricUI.S(2f);
			float num3 = FabricUI.S(2f);
			GameObject val2 = new GameObject("Line", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val2.transform.SetParent(val.transform, false);
			((Graphic)val2.GetComponent<Image>()).color = color;
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(0f, 1f);
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = new Vector2(num3, 0f);
			GameObject val3 = new GameObject("TopStub", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent(val.transform, false);
			((Graphic)val3.GetComponent<Image>()).color = color;
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(0f, 1f);
			component2.pivot = new Vector2(0f, 1f);
			component2.anchoredPosition = Vector2.zero;
			component2.sizeDelta = new Vector2(num, num2);
			GameObject val4 = new GameObject("BottomStub", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val4.transform.SetParent(val.transform, false);
			((Graphic)val4.GetComponent<Image>()).color = color;
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(0f, 0f);
			component3.pivot = new Vector2(0f, 0f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(num, num2);
		}

		private static void BuildConditionRow(Transform parent, PackInfo pack, int ci)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Expected O, but got Unknown
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			PackCondition packCondition = pack.Conditions[ci];
			string path = pack.Path;
			GameObject val = FabricUI.CreateVerticalGroup(parent, $"CondWrap_{ci}", 2f);
			GameObject val2 = FabricUI.CreateHorizontalGroup(val.transform, $"Cond_{ci}", 6f, new RectOffset(FabricUI.SI(6f), FabricUI.SI(6f), FabricUI.SI(4f), FabricUI.SI(4f)));
			((Graphic)val2.AddComponent<Image>()).color = GUIHelper.ColSurface1;
			FabricUI.AddLayout(val2, -1f, FabricUI.S(32f));
			int capCi = ci;
			string typeKey = $"{path}#{capCi}#type";
			string crestKey = $"{path}#{capCi}#crest";
			string nailKey = $"{path}#{capCi}#nail";
			Color value = default(Color);
			((Color)(ref value))..ctor(GUIHelper.ColAccent.r * 0.18f, GUIHelper.ColAccent.g * 0.18f, GUIHelper.ColAccent.b * 0.18f, 0.85f);
			GameObject obj = FabricUI.CreateButton(val2.transform, "Type", packCondition.TypeLabel + "  ▼", delegate
			{
				TogglePicker(typeKey);
			}, value, GUIHelper.ColAccent);
			FabricUI.AddLayout(obj, FabricUI.S(80f), FabricUI.S(24f));
			Text componentInChildren = obj.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = FabricUI.FontSize(12);
			}
			string text = (packCondition.Negate ? "!=" : "==");
			GameObject obj2 = FabricUI.CreateButton(val2.transform, "Negate", text, delegate
			{
				PackInfo packInfo = StagedPack(path);
				packInfo.Conditions[capCi].Negate = !packInfo.Conditions[capCi].Negate;
				Rebuild();
			}, GUIHelper.ColSurface1);
			FabricUI.AddLayout(obj2, FabricUI.S(34f), FabricUI.S(24f));
			Text componentInChildren2 = obj2.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				componentInChildren2.fontSize = FabricUI.FontSize(12);
			}
			if (packCondition.Type == ConditionType.CrestEquipped)
			{
				string text2 = PackCondition.CrestDisplayName(packCondition.Value);
				GameObject obj3 = FabricUI.CreateButton(val2.transform, "CrestVal", text2 + "  ▼", delegate
				{
					TogglePicker(crestKey);
				}, GUIHelper.ColSurface1);
				FabricUI.AddLayout(obj3, -1f, FabricUI.S(24f), -1f, -1f, 1f);
				Text componentInChildren3 = obj3.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren3 != (Object)null)
				{
					componentInChildren3.fontSize = FabricUI.FontSize(12);
				}
			}
			else if (packCondition.Type == ConditionType.NailUpgrade)
			{
				string text3 = PackCondition.NailDisplayValue(packCondition.Value);
				GameObject obj4 = FabricUI.CreateButton(val2.transform, "NailVal", text3 + "  ▼", delegate
				{
					TogglePicker(nailKey);
				}, GUIHelper.ColSurface1);
				FabricUI.AddLayout(obj4, -1f, FabricUI.S(24f), -1f, -1f, 1f);
				Text componentInChildren4 = obj4.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren4 != (Object)null)
				{
					componentInChildren4.fontSize = FabricUI.FontSize(12);
				}
			}
			else
			{
				GameObject val3 = new GameObject("ValSpacer", new Type[1] { typeof(RectTransform) });
				val3.transform.SetParent(val2.transform, false);
				FabricUI.AddLayout(val3, -1f, FabricUI.S(24f), -1f, -1f, 1f);
				GameObject obj5 = FabricUI.CreateInputField(val.transform, $"CondVal_{ci}", Loc.T("value"));
				FabricUI.AddLayout(obj5, -1f, FabricUI.S(24f));
				InputField component = obj5.GetComponent<InputField>();
				component.text = packCondition.Value;
				int capCi2 = ci;
				((UnityEvent<string>)(object)component.onEndEdit).AddListener((UnityAction<string>)delegate(string text4)
				{
					IReadOnlyList<PackInfo> staged = _staged;
					PackInfo packInfo = (staged ?? PackManager.AllPacks).FirstOrDefault((PackInfo p) => string.Equals(p.Path, path, StringComparison.OrdinalIgnoreCase));
					if (packInfo != null && !(text4 == packInfo.Conditions[capCi2].Value))
					{
						StagedPack(path).Conditions[capCi2].Value = text4;
						NormalizeStaged();
						RefreshActionBar(_staged ?? PackManager.AllPacks.ToList());
					}
				});
			}
			GameObject obj6 = FabricUI.CreateButton(val2.transform, "Remove", "×", delegate
			{
				StagedPack(path).Conditions.RemoveAt(capCi);
				Rebuild();
			}, GUIHelper.ColBorder, GUIHelper.ColDanger);
			FabricUI.AddLayout(obj6, FabricUI.S(26f), minWidth: FabricUI.S(26f), preferredHeight: FabricUI.S(24f));
			Text componentInChildren5 = obj6.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren5 != (Object)null)
			{
				componentInChildren5.fontSize = FabricUI.FontSize(13);
			}
			if (_openPicker == typeKey)
			{
				BuildOptionList(val.transform, "TypePicker", ((ConditionType[])Enum.GetValues(typeof(ConditionType))).Select((ConditionType v) => (v.ToString(), PackCondition.LabelFor(v))), packCondition.Type.ToString(), delegate(string id)
				{
					ApplyTypePick(path, capCi, id);
				}, 1);
			}
			else if (_openPicker == crestKey && packCondition.Type == ConditionType.CrestEquipped)
			{
				BuildOptionList(val.transform, "CrestPicker", PackCondition.KnownCrests.Select(((string Id, string DisplayName) k) => (Id: k.Id, DisplayName: k.DisplayName)), packCondition.Value, delegate(string id)
				{
					StagedPack(path).Conditions[capCi].Value = id;
				}, 1);
			}
			else if (_openPicker == nailKey && packCondition.Type == ConditionType.NailUpgrade)
			{
				BuildOptionList(val.transform, "NailPicker", PackCondition.KnownNailLevels.Select(((string Value, string DisplayName) n) => (Value: n.Value, DisplayName: n.DisplayName)), packCondition.Value, delegate(string id)
				{
					StagedPack(path).Conditions[capCi].Value = id;
				}, 1);
			}
		}

		private static void TogglePicker(string key)
		{
			_openPicker = ((_openPicker == key) ? null : key);
			Rebuild();
		}

		private static void BuildOptionList(Transform parent, string name, IEnumerable<(string Id, string Label)> options, string currentId, Action<string> onPick, int siblingIndex = -1)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = FabricUI.CreateVerticalGroup(parent, name, 2f, new RectOffset(FabricUI.SI(6f), FabricUI.SI(6f), FabricUI.SI(4f), FabricUI.SI(4f)));
			if (siblingIndex >= 0)
			{
				val.transform.SetSiblingIndex(siblingIndex);
			}
			((Graphic)val.AddComponent<Image>()).color = GUIHelper.ColSurface2;
			foreach (var option in options)
			{
				string item = option.Id;
				string item2 = option.Label;
				bool flag = string.Equals(item, currentId, StringComparison.OrdinalIgnoreCase);
				Color value = (Color)(flag ? new Color(GUIHelper.ColAccent.r * 0.25f, GUIHelper.ColAccent.g * 0.25f, GUIHelper.ColAccent.b * 0.25f, 0.95f) : GUIHelper.ColSurface1);
				string capId = item;
				GameObject obj = FabricUI.CreateButton(val.transform, "Opt", item2, delegate
				{
					onPick(capId);
					_openPicker = null;
					Rebuild();
				}, value, flag ? GUIHelper.ColAccent : Color.white);
				FabricUI.AddLayout(obj, -1f, FabricUI.S(22f));
				Text componentInChildren = obj.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.fontSize = FabricUI.FontSize(12);
				}
			}
		}

		private static void ApplyTypePick(string path, int ci, string typeId)
		{
			PackInfo packInfo = StagedPack(path);
			PackCondition c = packInfo.Conditions[ci];
			ConditionType conditionType = (ConditionType)Enum.Parse(typeof(ConditionType), typeId);
			c.Type = conditionType;
			if (conditionType == ConditionType.CrestEquipped && !PackCondition.KnownCrests.Any(((string Id, string DisplayName) k) => string.Equals(k.Id, c.Value, StringComparison.OrdinalIgnoreCase)))
			{
				c.Value = PackCondition.KnownCrests[0].Id;
			}
			else if (conditionType == ConditionType.NailUpgrade && !PackCondition.KnownNailLevels.Any(((string Value, string DisplayName) n) => string.Equals(n.Value, c.Value, StringComparison.OrdinalIgnoreCase)))
			{
				c.Value = PackCondition.KnownNailLevels[0].Value;
			}
			if (PackCondition.IsMidSceneType(conditionType) && packInfo.ReloadTrigger == ReloadTrigger.OnSceneTransition)
			{
				packInfo.ReloadTrigger = ReloadTrigger.HotReload;
			}
		}

		private static List<List<int>> BuildClauses(List<PackCondition> conds)
		{
			List<List<int>> list = new List<List<int>>();
			if (conds.Count == 0)
			{
				return list;
			}
			List<int> list2 = new List<int> { 0 };
			for (int i = 0; i < conds.Count - 1; i++)
			{
				if (conds[i].JoinNext == LogicJoin.And)
				{
					list2.Add(i + 1);
					continue;
				}
				list.Add(list2);
				list2 = new List<int> { i + 1 };
			}
			list.Add(list2);
			return list;
		}

		private static void EnsureStaged()
		{
			if (_staged == null)
			{
				_staged = PackManager.AllPacks.Select((PackInfo p) => p.Clone()).ToList();
			}
		}
	}
	public class CanvasPanelDragger : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler, IEndDragHandler
	{
		private Vector2 _offset;

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			Transform parent = ((Transform)component).parent;
			Vector2 val = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)(object)((parent is RectTransform) ? parent : null), eventData.position, eventData.pressEventCamera, ref val);
			_offset = component.anchoredPosition - val;
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0013: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			Transform parent = ((Transform)component).parent;
			Vector2 val = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)(object)((parent is RectTransform) ? parent : null), eventData.position, eventData.pressEventCamera, ref val);
			Vector2 val2 = val + _offset;
			float num = 40f;
			val2.x = Mathf.Clamp(val2.x, 0f - component.sizeDelta.x + num, (float)Screen.width - num);
			val2.y = Mathf.Clamp(val2.y, (float)(-Screen.height) + num, 0f);
			component.anchoredPosition = val2;
		}

		public void OnEndDrag(PointerEventData eventData)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			if (Plugin.Config != null)
			{
				Plugin.Config.CanvasPMX = component.anchoredPosition.x;
				Plugin.Config.CanvasPMY = component.anchoredPosition.y;
			}
		}
	}
	public static class DevHub
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static WindowFunction <0>__DrawWindow;
		}

		public const int TabDashboard = 0;

		public const int TabGraphics = 1;

		public const int TabText = 2;

		public const int TabVideo = 3;

		public const int TabAudio = 4;

		public const int TabDebug = 5;

		private static readonly string[] TabNames = new string[6] { "Dashboard", "Graphics", "Text", "Video", "Audio", "Debug" };

		private const float WindowWidth = 720f;

		private const float WindowHeight = 620f;

		private const float TabWidth = 92f;

		private static readonly Vector2[] TabSizes = (Vector2[])(object)new Vector2[6]
		{
			new Vector2(720f, 620f),
			new Vector2(660f, 840f),
			new Vector2(920f, 620f),
			new Vector2(720f, 620f),
			new Vector2(720f, 620f),
			new Vector2(720f, 620f)
		};

		private static int _lastSizedTab = -1;

		private static Rect _windowRect;

		private static bool _initialized;

		private static bool _helpOn;

		private static readonly string[] HelpWikiPages = new string[6] { "A1-getting-started", "B2-finding-any-sprite", "C1-text", "E1-video", "D1-audio", "dumping" };

		private static readonly string[] HelpFallbacks = new string[6] { "Your control room: pack status, health checks, quick toggles. The bottom-left Status Overlay badge in game opens the Pack Manager; this hub is for CREATING content. Full guide: A1 Getting Started.", "The art workflow. Find any sprite by pointing at it in game (Pick object in world), then Edit — the PNG opens in your image editor and hot-reloads on save. Animations: Extract renders a clip's frames into a workspace folder you edit; Compile writes them back as replacements. The Workspace line shows exactly which folder is in play. T2D art (HUD, effects, menus) has its own browser tab. Full guides: B2 Finding Any Sprite, B8 Animation Controller.", "Live text editing. The Dialogue Editor saves to the root Text/ folder and always wins over packs — in-editor edits are guaranteed visible in game. The Text Log shows every string the game requested this session. Full guide: C1 Text.", "Replace cinematics: drop a video file in a pack's Videos/ folder named after the cinematic. This tab lists what has played and what's overridden. Full guide: E1 Video.", "Audio replacement plus the Audio Log of clips as they play — trigger the sound in game, then grab its clip name here. Full guide: D1 Audio.", "Dumping and diagnostics. Dump Text exports every string; the sprite-dump toggle exports each scene you visit; Full Dump walks the entire game (long!). Convert Sheets splits whole-sheet packs into per-sprite files. Full guide: Dumping & Full Dump." };

		private static bool _wikiProbed;

		private static string _wikiRoot;

		private static readonly string[] _pillarError = new string[TabNames.Length];

		private static int _pillarErrorFrame = -1;

		public static Rect WindowRect => _windowRect;

		private static string ResolveWikiPage(string pageId)
		{
			if (!_wikiProbed)
			{
				_wikiProbed = true;
				try
				{
					string[] directories = Directory.GetDirectories(Paths.PluginPath, "StitchworkWiki", SearchOption.AllDirectories);
					int num = 0;
					if (num < directories.Length)
					{
						_wikiRoot = directories[num];
					}
				}
				catch (IOException)
				{
				}
				catch (UnauthorizedAccessException)
				{
				}
			}
			if (_wikiRoot == null)
			{
				return null;
			}
			string text = Path.Combine(_wikiRoot, pageId + ".html");
			if (!File.Exists(text))
			{
				return null;
			}
			return text;
		}

		private static void DrawHelpPanel(int tab)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (tab >= 0 && tab < HelpFallbacks.Length)
			{
				GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
				Color contentColor = GUI.contentColor;
				GUI.contentColor = GUIHelper.ColMuted;
				GUILayout.Label(Loc.T("help:" + TabNames[tab], HelpFallbacks[tab]), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = contentColor;
				string text = ResolveWikiPage(HelpWikiPages[tab]);
				if (text != null && GUIHelper.GhostButton(Loc.T("Open full guide"), GUIHelper.Width(140f)))
				{
					IOUtil.OpenPath(text);
				}
				GUILayout.EndVertical();
				GUIHelper.Space(4f);
			}
		}

		public static void Draw()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized || ((Rect)(ref _windowRect)).width < 1f)
			{
				float num = Plugin.Config?.DevHubX ?? 0f;
				float num2 = Plugin.Config?.DevHubY ?? 0f;
				_windowRect = (Rect)((num > 0f || num2 > 0f) ? new Rect(num, num2, GUIHelper.Scaled(720f), GUIHelper.Scaled(620f)) : GUIHelper.ScaledRect(30f, 30f, 720f, 620f));
				_initialized = true;
			}
			Vector2 val = TabSizes[Mathf.Clamp(Plugin.DevHubTab, 0, TabSizes.Length - 1)];
			if (_lastSizedTab != Plugin.DevHubTab)
			{
				((Rect)(ref _windowRect)).width = GUIHelper.Scaled(val.x);
				((Rect)(ref _windowRect)).height = GUIHelper.Scaled(val.y);
				_lastSizedTab = Plugin.DevHubTab;
			}
			Rect windowRect = _windowRect;
			object obj = <>O.<0>__DrawWindow;
			if (obj == null)
			{
				WindowFunction val2 = DrawWindow;
				<>O.<0>__DrawWindow = val2;
				obj = (object)val2;
			}
			_windowRect = GUILayout.Window(6980, windowRect, (WindowFunction)obj, Loc.T("Stitchwork Dev Hub"), GUIHelper.WindowStyle, GUIHelper.WindowLayout(val.x, val.y));
			_windowRect = GUIHelper.ClampToScreen(_windowRect);
		}

		private static void DrawWindow(int windowID)
		{
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			GUIHelper.Space(16f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			for (int i = 0; i < TabNames.Length; i++)
			{
				bool num = Plugin.DevHubTab == i;
				Color backgroundColor = GUI.backgroundColor;
				if (num)
				{
					GUI.backgroundColor = new Color(0.25f, 0.55f, 1f);
				}
				if (GUILayout.Button(Loc.T(TabNames[i]), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(92f),
					GUIHelper.Height(28f)
				}))
				{
					Plugin.DevHubTab = i;
				}
				GUI.backgroundColor = backgroundColor;
			}
			GUILayout.FlexibleSpace();
			if (GUIHelper.GhostButton("i", GUIHelper.Width(24f), GUIHelper.Height(28f)))
			{
				_helpOn = !_helpOn;
			}
			if (GUILayout.Button("×", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(28f),
				GUIHelper.Height(28f)
			}))
			{
				Plugin.ShowDevHub = false;
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(6f);
			if (_helpOn)
			{
				DrawHelpPanel(Plugin.DevHubTab);
			}
			int devHubTab = Plugin.DevHubTab;
			if (_pillarError[devHubTab] != null)
			{
				if (Time.frameCount > _pillarErrorFrame)
				{
					DrawPillarErrorPanel(devHubTab);
				}
			}
			else
			{
				try
				{
					switch (devHubTab)
					{
					case 0:
						DashboardPillar.Draw();
						break;
					case 1:
						GraphicsPillar.Draw();
						break;
					case 2:
						TextPillar.Draw();
						break;
					case 3:
						VideoPillar.Draw();
						break;
					case 4:
						AudioPillar.Draw();
						break;
					case 5:
						DebugPillar.Draw();
						break;
					}
				}
				catch (Exception ex)
				{
					_pillarError[devHubTab] = ex.GetType().Name + ": " + ex.Message;
					_pillarErrorFrame = Time.frameCount;
					Plugin.Logger.LogError((object)$"[DevHub] '{Loc.T(TabNames[devHubTab])}' tab draw failed — contained, tab latched until Retry.\n{ex}");
				}
			}
			GUIHelper.DrawTooltip();
			GUI.DragWindow(GUIHelper.DragRect);
		}

		private static void DrawPillarErrorPanel(int tab)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUIHelper.Space();
			Color contentColor = GUI.contentColor;
			GUI.contentColor = GUIHelper.ColWarn;
			GUILayout.Label(Loc.T("This tab hit a draw error and was stopped."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = contentColor;
			GUILayout.Label(_pillarError[tab], GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(Loc.T("Full details are in the BepInEx log."), GUIHelper.MutedLabelStyle, Array.Empty<GUILayoutOption>());
			GUIHelper.Space(8f);
			if (GUILayout.Button(Loc.T("Retry"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(120f),
				GUIHelper.Height(28f)
			}))
			{
				_pillarError[tab] = null;
			}
			GUILayout.EndVertical();
		}

		public static void OpenAt(int tab)
		{
			Plugin.ShowDevHub = true;
			Plugin.DevHubTab = tab;
		}

		public static void ToggleAt(int tab)
		{
			if (Plugin.ShowDevHub && Plugin.DevHubTab == tab)
			{
				Plugin.ShowDevHub = false;
			}
			else
			{
				OpenAt(tab);
			}
		}
	}
	public static class DevProfiler
	{
		private sealed class HeapCaptureOp
		{
			public int Count;

			public float TotalMs;

			public float MaxMs;

			public long AllocBytes;

			public int CollectsInside;
		}

		private struct GcStallSample
		{
			public float T;

			public string Scene;

			public float FrameMs;

			public float UnityFrameMs;

			public float UpdateMs;

			public float EnforceMs;

			public float UninitMs;

			public long TcHeap;

			public long GcHeap;

			public long TcTotal;

			public double ThresholdMB;

			public long FileBytes;

			public long SheetBytes;

			public long OriginalBytes;

			public int Collects;

			public long FrameHeapDelta;

			public long LabelledAllocBytes;

			public int UninitRefreshTotal;
		}

		private struct GcStallAllocEvent
		{
			public float T;

			public string Label;

			public long Bytes;
		}

		private struct GcStallEvent
		{
			public float T;

			public string Text;
		}

		private struct GcStallFrame
		{
			public float T;

			public float FrameMs;

			public float UnityFrameMs;

			public long GcHeap;

			public int Collects;

			public long FrameHeapDelta;

			public long LabelledAllocBytes;
		}

		private const int FrameSampleCount = 120;

		private const float GraphHeight = 50f;

		private const float GraphBarWidth = 2f;

		private static readonly float[] FrameTimes = new float[120];

		private static int frameIndex;

		private static int sampleCount;

		private static float fps;

		private static float frameTimeMs;

		private static float unityFrameTimeMs;

		private static float minFps = float.MaxValue;

		private static float maxFps;

		private static float worstFrameTimeMs;

		private static long _lastFrameWallTimestamp;

		private static readonly Stopwatch SceneLoadTimer = new Stopwatch();

		private static string lastSceneLoadTime = "-";

		private static string lastSceneLoaded = "-";

		private static readonly Stopwatch UpdateTimer = new Stopwatch();

		private static float lastUpdateMs;

		private static readonly Stopwatch OpTimer = new Stopwatch();

		private const int SpikeLogCapacity = 20;

		private const float SpikeThresholdMs = 5f;

		private const float NoisySpikeCooldownSec = 5f;

		private const float IncrementalCollectSpikeMs = 25f;

		private static readonly string[] _spikeLabels = new string[20];

		private static readonly float[] _spikeDurations = new float[20];

		private static readonly float[] _spikeTimes = new float[20];

		private static int _spikeHead;

		private static int _spikeCount;

		private static Vector2 _spikeScroll;

		private static readonly Dictionary<string, float> _lastNoisySpikeByLabel = new Dictionary<string, float>(StringComparer.Ordinal);

		private static float _maxEnforceMs;

		private static float _maxUninitMs;

		private static float _lastEnforceMs;

		private static float _lastUninitMs;

		private static int _opStartGen2;

		private static long _opStartHeapBytes;

		private static int _opsWithCollect;

		private static bool _lastOpHadCollect;

		private static readonly Dictionary<string, long> _opAllocBytesWindow = new Dictionary<string, long>(StringComparer.Ordinal);

		private static long _uninitWindowSrSum;

		private static long _uninitWindowImgSum;

		private static int _uninitWindowSrAssigns;

		private static int _uninitWindowImgAssigns;

		private static int _uninitWindowFrames;

		private static int _uninitWindowRefreshes;

		private static int _uninitRefreshTotal;

		private static int _frameStartGen2;

		private static int _lastFrameCollects;

		private static int _sessionCollectsBase;

		private static int _sessionCollectsSeen;

		private static long _frameStartHeapBytes;

		private static long _lastFrameHeapDelta;

		private static readonly bool[] _spikeHadCollect = new bool[20];

		private const float MemLogIntervalSec = 5f;

		private static float _memLogWindowStart;

		private static long _memLogWindowStartHeap;

		private static long _memLogWindowAllocBytes;

		private static long _memLogWindowFreedBytes;

		private static int _memLogWindowCollects;

		private static float _lastEmittedMemTime;

		private const float MemHeartbeatForceSec = 30f;

		private const float MemHeartbeatRateThresholdMBs = 5f;

		private static float _lastCollectTime;

		private static string _pendingCollectReason;

		private static float _lastSceneUnloadTime = -100f;

		private static bool _memLogInitialized;

		private const float HeapCaptureSampleIntervalSec = 0.25f;

		private static bool _heapCaptureActive;

		private static float _heapCaptureStartTime;

		private static float _heapCaptureEndTime;

		private static float _heapCaptureNextSampleTime;

		private static string _heapCapturePath;

		private static string _heapCaptureStartScene;

		private static DateTime _heapCaptureStartedAt;

		private static int _heapCaptureFrameCount;

		private static int _heapCaptureStartGen2;

		private static int _heapCaptureCollects;

		private static long _heapCaptureStartTcHeap;

		private static long _heapCaptureEndTcHeap;

		private static long _heapCaptureMinTcHeap;

		private static long _heapCaptureMaxTcHeap;

		private static long _heapCaptureStartGcHeap;

		private static long _heapCaptureEndGcHeap;

		private static long _heapCaptureMinGcHeap;

		private static long _heapCaptureMaxGcHeap;

		private static double _heapCaptureStartThreshold;

		private static double _heapCaptureEndThreshold;

		private static long _heapCaptureStartFileBytes;

		private static long _heapCaptureStartSheetBytes;

		private static long _heapCaptureStartOriginalBytes;

		private static long _heapCaptureEndFileBytes;

		private static long _heapCaptureEndSheetBytes;

		private static long _heapCaptureEndOriginalBytes;

		private static float _heapCaptureWorstFrameMs;

		private static float _heapCaptureWorstUpdateMs;

		private static readonly Dictionary<string, HeapCaptureOp> _heapCaptureOps = new Dictionary<string, HeapCaptureOp>(StringComparer.Ordinal);

		private static readonly StringBuilder _heapCaptureSamples = new StringBuilder();

		private static readonly StringBuilder _heapCaptureEvents = new StringBuilder();

		private const float GcStallSampleIntervalSec = 0.25f;

		private const float GcStallPreWindowSec = 15f;

		private const float GcStallPostWindowSec = 5f;

		private const int GcStallSampleCapacity = 96;

		private const int GcStallAllocEventCapacity = 65536;

		private const int GcStallEventCapacity = 256;

		private const int GcStallFrameCapacity = 8192;

		private static readonly GcStallSample[] _gcStallSamples = new GcStallSample[96];

		private static readonly GcStallAllocEvent[] _gcStallAllocEvents = new GcStallAllocEvent[65536];

		private static readonly GcStallEvent[] _gcStallEvents = new GcStallEvent[256];

		private static readonly GcStallFrame[] _gcStallFrames = new GcStallFrame[8192];

		private static int _gcStallSampleHead;

		private static int _gcStallSampleCount;

		private static int _gcStallAllocHead;

		private static int _gcStallAllocCount;

		private static int _gcStallEventHead;

		private static int _gcStallEventCount;

		private static int _gcStallFrameHead;

		private static int _gcStallFrameCount;

		private static float _gcStallNextSampleTime;

		private static long _gcStallLabelledAllocSinceSample;

		private static long _gcStallLabelledAllocSinceFrame;

		private static bool _gcStallArmed;

		private static bool _gcStallActive;

		private static float _gcStallTriggerTime;

		private static float _gcStallEndTime;

		private static DateTime _gcStallTriggeredAt;

		private static string _gcStallPath;

		private static string _gcStallTriggerReason;

		private static string _gcStallTriggerScene;

		private static int _gcStallTriggerCollects;

		private static float _gcStallTriggerFrameMs;

		private static long _gcStallTriggerHeapAfter;

		private static long _gcStallTriggerFreedBytes;

		private static int _gcStallTriggerThresholdMs;

		private static Texture2D graphTex;

		private static Texture2D barTex;

		private static readonly bool[] ReloadFrames = new bool[120];

		public static void Initialize()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
			SceneManager.sceneUnloaded += OnSceneUnloading;
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			SceneLoadTimer.Stop();
			lastSceneLoadTime = $"{SceneLoadTimer.ElapsedMilliseconds}ms";
			lastSceneLoaded = ((Scene)(ref scene)).name;
		}

		private static void OnSceneUnloading(Scene scene)
		{
			SceneLoadTimer.Restart();
			_lastSceneUnloadTime = Time.realtimeSinceStartup;
		}

		public static void MarkExpectedCollect(string reason)
		{
			_pendingCollectReason = reason;
		}

		public static void BeginUpdateTiming()
		{
			UpdateTimer.Restart();
		}

		public static void EndUpdateTiming()
		{
			UpdateTimer.Stop();
			lastUpdateMs = (float)UpdateTimer.Elapsed.TotalMilliseconds;
		}

		public static void RecordFrame()
		{
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			unityFrameTimeMs = unscaledDeltaTime * 1000f;
			long timestamp = Stopwatch.GetTimestamp();
			float num = unscaledDeltaTime;
			if (_lastFrameWallTimestamp != 0L)
			{
				long num2 = timestamp - _lastFrameWallTimestamp;
				if (num2 > 0)
				{
					num = (float)((double)num2 / (double)Stopwatch.Frequency);
				}
			}
			_lastFrameWallTimestamp = timestamp;
			FrameTimes[frameIndex] = num;
			ReloadFrames[frameIndex] = false;
			frameIndex = (frameIndex + 1) % 120;
			if (sampleCount < 120)
			{
				sampleCount++;
			}
			frameTimeMs = num * 1000f;
			fps = ((num > 0f) ? (1f / num) : 0f);
			if (fps > 0.5f)
			{
				if (fps < minFps)
				{
					minFps = fps;
				}
				if (fps > maxFps)
				{
					maxFps = fps;
				}
				if (frameTimeMs > worstFrameTimeMs)
				{
					worstFrameTimeMs = frameTimeMs;
				}
			}
			int num3 = GC.CollectionCount(GC.MaxGeneration);
			long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
			if (_sessionCollectsBase == 0 && num3 > 0)
			{
				_sessionCollectsBase = num3;
			}
			_lastFrameCollects = num3 - _frameStartGen2;
			_lastFrameHeapDelta = ((_frameStartHeapBytes > 0) ? (totalMemory - _frameStartHeapBytes) : 0);
			_sessionCollectsSeen = num3 - _sessionCollectsBase;
			_frameStartGen2 = num3;
			_frameStartHeapBytes = totalMemory;
			CaptureGcStallFrame(Time.realtimeSinceStartup, totalMemory);
			if (_lastFrameCollects > 0)
			{
				_lastOpHadCollect = true;
				if (!GCUtil.IsIncrementalMode || frameTimeMs >= 25f)
				{
					RecordSpike((_lastFrameCollects == 1) ? "gen-max collect (frame)" : $"gen-max collects ×{_lastFrameCollects} (frame)", frameTimeMs);
				}
			}
			TickMemoryLog();
			TickHeapCapture();
			TickGcStallRecorder();
		}

		private static void TickMemoryLog()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!_memLogInitialized)
			{
				_memLogInitialized = true;
				_memLogWindowStart = realtimeSinceStartup;
				_memLogWindowStartHeap = _frameStartHeapBytes;
				_lastCollectTime = realtimeSinceStartup;
				return;
			}
			if (_lastFrameHeapDelta > 0)
			{
				_memLogWindowAllocBytes += _lastFrameHeapDelta;
			}
			else if (_lastFrameHeapDelta < 0)
			{
				_memLogWindowFreedBytes += -_lastFrameHeapDelta;
			}
			if (_lastFrameCollects > 0)
			{
				_memLogWindowCollects += _lastFrameCollects;
				LogCollectEvent(realtimeSinceStartup, _lastFrameCollects);
			}
			if (realtimeSinceStartup - _memLogWindowStart >= 5f)
			{
				LogPeriodicEvent(realtimeSinceStartup);
				_memLogWindowStart = realtimeSinceStartup;
				_memLogWindowStartHeap = _frameStartHeapBytes;
				_memLogWindowAllocBytes = 0L;
				_memLogWindowFreedBytes = 0L;
				_memLogWindowCollects = 0;
			}
		}

		private static void LogPeriodicEvent(float now)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			long frameStartHeapBytes = _frameStartHeapBytes;
			long bytes = frameStartHeapBytes - _memLogWindowStartHeap;
			float num = now - _memLogWindowStart;
			float num2 = (float)_memLogWindowAllocBytes / 1024f / 1024f / Mathf.Max(num, 0.001f);
			long num3 = (GCUtil.BridgeAvailable ? (GCUtil.TCMonoHeapTotal >> 20) : 0);
			double num4 = (GCUtil.BridgeAvailable ? GCUtil.TCHeapThresholdMB : 0.0);
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			bool num5 = num2 >= 5f || _memLogWindowCollects > 0;
			bool flag = now - _lastEmittedMemTime >= 30f;
			bool flag2 = num5 || flag;
			if (flag2)
			{
				_lastEmittedMemTime = now;
				long totalBytes = FileCache.TotalBytes;
				long spritesheetOverrideBytes = T2DLoader.SpritesheetOverrideBytes;
				long originalTextureDataBytes = T2DLoader.OriginalTextureDataBytes;
				long atlasVramBytes = SpriteLoader.AtlasVramBytes;
				int atlasRTCount = SpriteLoader.AtlasRTCount;
				Log.Verbose($"[Mem] t={now:F1} heap={frameStartHeapBytes >> 20}/{num3}MB(thr={num4:F0}) " + $"net={SignedMB(bytes)} positiveHeap={_memLogWindowAllocBytes >> 20}MB/{num:F1}s " + $"growthRate={num2:F1}MB/s freed={_memLogWindowFreedBytes >> 20}MB " + $"sw-cache=file:{totalBytes >> 20}MB sheet:{spritesheetOverrideBytes >> 20}MB orig:{originalTextureDataBytes >> 20}MB " + $"collects={_memLogWindowCollects} scene={name} " + $"vram={atlasRTCount}RT/{atlasVramBytes >> 20}MB " + $"enf={_lastEnforceMs:F1}ms unin={_lastUninitMs:F1}ms");
			}
			if (_opAllocBytesWindow.Count > 0)
			{
				if (flag2)
				{
					string text = BuildTopAllocLine();
					if (!string.IsNullOrEmpty(text))
					{
						Log.Verbose($"[Mem-Op] t={now:F1} top-positive-net-heap {text}");
					}
				}
				_opAllocBytesWindow.Clear();
			}
			if (_uninitWindowFrames > 0)
			{
				if (flag2)
				{
					long num6 = _uninitWindowSrSum / _uninitWindowFrames;
					long num7 = _uninitWindowImgSum / _uninitWindowFrames;
					Log.Verbose($"[Uninit] t={now:F1} avg-sr={num6} avg-img={num7} " + $"assigns/win sr={_uninitWindowSrAssigns} img={_uninitWindowImgAssigns} " + $"frames={_uninitWindowFrames} refreshes={_uninitWindowRefreshes}");
				}
				_uninitWindowSrSum = 0L;
				_uninitWindowImgSum = 0L;
				_uninitWindowSrAssigns = 0;
				_uninitWindowImgAssigns = 0;
				_uninitWindowFrames = 0;
				_uninitWindowRefreshes = 0;
			}
		}

		private static string BuildTopAllocLine()
		{
			string[] array = new string[3];
			long[] array2 = new long[3];
			foreach (KeyValuePair<string, long> item in _opAllocBytesWindow)
			{
				if (item.Value < 1048576)
				{
					continue;
				}
				int num = 0;
				for (int i = 1; i < 3; i++)
				{
					if (array2[i] < array2[num])
					{
						num = i;
					}
				}
				if (item.Value > array2[num])
				{
					array2[num] = item.Value;
					array[num] = item.Key;
				}
			}
			for (int j = 0; j < 3; j++)
			{
				for (int k = j + 1; k < 3; k++)
				{
					if (array2[k] > array2[j])
					{
						ref long reference = ref array2[j];
						ref long reference2 = ref array2[k];
						long num2 = array2[k];
						long num3 = array2[j];
						reference = num2;
						reference2 = num3;
						ref string reference3 = ref array[j];
						ref string reference4 = ref array[k];
						string text = array[k];
						string text2 = array[j];
						reference3 = text;
						reference4 = text2;
					}
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int l = 0; l < 3 && array2[l] >= 1048576; l++)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(',');
				}
				stringBuilder.Append(array[l]).Append('=').Append(array2[l] >> 20)
					.Append("MB");
			}
			return stringBuilder.ToString();
		}

		private static void LogCollectEvent(float now, int countThisFrame)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			long frameStartHeapBytes = _frameStartHeapBytes;
			long num = ((_lastFrameHeapDelta < 0) ? (-_lastFrameHeapDelta) : 0);
			float num2 = now - _lastCollectTime;
			string text;
			if (string.IsNullOrEmpty(_pendingCollectReason))
			{
				text = ((!(now - _lastSceneUnloadTime < 2f)) ? (GCUtil.IsIncrementalMode ? "auto(incremental)" : "auto") : "transition-adjacent(inferred)");
			}
			else
			{
				text = _pendingCollectReason;
				_pendingCollectReason = null;
			}
			_lastCollectTime = now;
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			string arg = ((countThisFrame == 1) ? $"collect#{_sessionCollectsSeen}" : $"collect#{_sessionCollectsSeen - countThisFrame + 1}..{_sessionCollectsSeen}(×{countThisFrame})");
			string text2 = $"[Mem-GC] t={now:F1} {arg} heap-after={frameStartHeapBytes >> 20}MB " + $"freed>={num >> 20}MB interval={num2:F1}s reason={text} " + $"scene={name} frame-ms={frameTimeMs:F1} unity-ms={unityFrameTimeMs:F1}";
			if (GCUtil.IsIncrementalMode)
			{
				Log.Verbose(text2);
			}
			else
			{
				Plugin.Logger.LogInfo((object)text2);
			}
			RecordGcStallEvent(now, $"GC count={countThisFrame} heapAfter={frameStartHeapBytes >> 20}MB " + $"freedAtLeast={num >> 20}MB interval={num2:F1}s " + $"reason={text} scene={name} frameMs={frameTimeMs:F1} unityMs={unityFrameTimeMs:F1}");
			CaptureGcStallSample(now, force: true);
			MaybeTriggerGcStallCapture(now, countThisFrame, text, name, frameStartHeapBytes, num);
			if (_heapCaptureActive)
			{
				_heapCaptureCollects += countThisFrame;
				_heapCaptureEvents.AppendLine($"GC t={HeapCaptureElapsed(now):F2}s count={countThisFrame} " + $"heapAfter={frameStartHeapBytes >> 20}MB freedAtLeast={num >> 20}MB " + $"interval={num2:F1}s reason={text} scene={name} frameMs={frameTimeMs:F1} unityMs={unityFrameTimeMs:F1}");
			}
		}

		private static string SignedMB(long bytes)
		{
			long num = bytes / 1048576;
			if (num < 0)
			{
				return $"{num}MB";
			}
			return $"+{num}MB";
		}

		public static void StartOp()
		{
			OpTimer.Restart();
			_opStartGen2 = GC.CollectionCount(GC.MaxGeneration);
			_opStartHeapBytes = GC.GetTotalMemory(forceFullCollection: false);
		}

		public static float StopOp(string label)
		{
			OpTimer.Stop();
			float num = (float)OpTimer.Elapsed.TotalMilliseconds;
			_lastOpHadCollect = GC.CollectionCount(GC.MaxGeneration) > _opStartGen2;
			if (_lastOpHadCollect)
			{
				_opsWithCollect++;
			}
			long num2 = GC.GetTotalMemory(forceFullCollection: false) - _opStartHeapBytes;
			CaptureHeapOp(label, num, num2, _lastOpHadCollect);
			if (num2 > 0 && !string.IsNullOrEmpty(label) && !_lastOpHadCollect)
			{
				RecordGcStallAlloc(label, num2);
				if (_opAllocBytesWindow.TryGetValue(label, out var value))
				{
					_opAllocBytesWindow[label] = value + num2;
				}
				else
				{
					_opAllocBytesWindow[label] = num2;
				}
			}
			if (num >= 5f && !string.IsNullOrEmpty(label))
			{
				RecordSpike(label, num);
			}
			return num;
		}

		public static void RecordSpike(string label, float durationMs)
		{
			bool lastOpHadCollect = _lastOpHadCollect;
			bool flag = ShouldSuppressSpikeEntry(label, lastOpHadCollect);
			CaptureHeapSpike(label, durationMs, lastOpHadCollect, flag);
			RecordGcStallEvent(Time.realtimeSinceStartup, $"SPIKE label={label} ms={durationMs:F1} gc={lastOpHadCollect} displayed={!flag}");
			if (flag)
			{
				_lastOpHadCollect = false;
				return;
			}
			_spikeLabels[_spikeHead] = label;
			_spikeDurations[_spikeHead] = durationMs;
			_spikeTimes[_spikeHead] = Time.realtimeSinceStartup;
			_spikeHadCollect[_spikeHead] = lastOpHadCollect;
			_spikeHead = (_spikeHead + 1) % 20;
			if (_spikeCount < 20)
			{
				_spikeCount++;
			}
			_lastOpHadCollect = false;
			int num = ((frameIndex - 1) % 120 + 120) % 120;
			ReloadFrames[num] = true;
		}

		private static bool ShouldSuppressSpikeEntry(string label, bool hadCollect)
		{
			if (hadCollect || !IsNoisyPerFrameSpikeLabel(label))
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_lastNoisySpikeByLabel.TryGetValue(label, out var value) && realtimeSinceStartup - value < 5f)
			{
				return true;
			}
			_lastNoisySpikeByLabel[label] = realtimeSinceStartup;
			return false;
		}

		private static bool IsNoisyPerFrameSpikeLabel(string label)
		{
			return string.Equals(label, "UninitCheck", StringComparison.Ordinal);
		}

		public static void RecordEnforceMs(float ms)
		{
			_lastEnforceMs = ms;
			if (ms > _maxEnforceMs)
			{
				_maxEnforceMs = ms;
			}
		}

		public static void RecordUninitMs(float ms)
		{
			_lastUninitMs = ms;
			if (ms > _maxUninitMs)
			{
				_maxUninitMs = ms;
			}
		}

		public static void AddOpAlloc(string label, long bytes)
		{
			if (bytes > 0 && !string.IsNullOrEmpty(label))
			{
				RecordGcStallAlloc(label, bytes);
				if (_heapCaptureActive)
				{
					GetHeapCaptureOp(label).AllocBytes += bytes;
				}
				if (_opAllocBytesWindow.TryGetValue(label, out var value))
				{
					_opAllocBytesWindow[label] = value + bytes;
				}
				else
				{
					_opAllocBytesWindow[label] = bytes;
				}
			}
		}

		public static long SnapshotHeapBytes()
		{
			return GC.GetTotalMemory(forceFullCollection: false);
		}

		public static void AddOpPositiveNetHeapDelta(string label, long heapBefore)
		{
			AddOpAlloc(label, GC.GetTotalMemory(forceFullCollection: false) - heapBefore);
		}

		public static void RecordUninitCounts(int srCount, int imgCount, int srAssigns, int imgAssigns)
		{
			_uninitWindowSrSum += srCount;
			_uninitWindowImgSum += imgCount;
			_uninitWindowSrAssigns += srAssigns;
			_uninitWindowImgAssigns += imgAssigns;
			_uninitWindowFrames++;
		}

		public static void RecordUninitRefresh()
		{
			_uninitWindowRefreshes++;
			_uninitRefreshTotal++;
		}

		public static void DrawPillarContent()
		{
			DrawContent();
		}

		private static void DrawContent()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			SectionHeader("Performance");
			Color color = ((fps >= 55f) ? Color.green : ((fps >= 30f) ? Color.yellow : Color.red));
			ColorLabel($"FPS: {fps:F0}  ({frameTimeMs:F1}ms)", color);
			Label($"Min/Max FPS: {minFps:F0} / {maxFps:F0}");
			Label($"Worst frame: {worstFrameTimeMs:F1}ms");
			Label($"Plugin.Update: {lastUpdateMs:F2}ms");
			if (GUILayout.Button("Reset Stats", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				minFps = float.MaxValue;
				maxFps = 0f;
				worstFrameTimeMs = 0f;
				_maxEnforceMs = 0f;
				_maxUninitMs = 0f;
			}
			Label($"Enforce T2D: {_lastEnforceMs:F2}ms  (max {_maxEnforceMs:F2}ms)");
			Label($"Uninit check: {_lastUninitMs:F2}ms  (max {_maxUninitMs:F2}ms)");
			GUIHelper.Space(4f);
			DrawFrameGraph();
			GUIHelper.Space(8f);
			SectionHeader("Spike Log");
			if (_spikeCount == 0)
			{
				Label("No spikes recorded (threshold: 5ms).");
			}
			else
			{
				if (GUILayout.Button("Clear", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(20f) }))
				{
					_spikeCount = 0;
					_spikeHead = 0;
				}
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				float num = GUIHelper.Scaled(120f);
				_spikeScroll = GUILayout.BeginScrollView(_spikeScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(num) });
				for (int i = 0; i < _spikeCount; i++)
				{
					int num2 = ((_spikeHead - 1 - i) % 20 + 20) % 20;
					float num3 = _spikeDurations[num2];
					float num4 = realtimeSinceStartup - _spikeTimes[num2];
					bool num5 = _spikeHadCollect[num2];
					Color color2 = (Color)((num3 >= 33.3f) ? Color.red : ((num3 >= 16.7f) ? Color.yellow : new Color(1f, 0.65f, 0.2f)));
					string text = (num5 ? "  [GC]" : "");
					ColorLabel($"{num4:F1}s ago  {_spikeLabels[num2]}  {num3:F1}ms{text}", color2);
				}
				GUILayout.EndScrollView();
			}
			GUIHelper.Space(8f);
			SectionHeader("Memory");
			if (GCUtil.BridgeAvailable)
			{
				long tCMonoHeapUsed = GCUtil.TCMonoHeapUsed;
				long tCMonoHeapTotal = GCUtil.TCMonoHeapTotal;
				long tCMemUsed = GCUtil.TCMemUsed;
				long tCMemTotal = GCUtil.TCMemTotal;
				double tCHeapThresholdMB = GCUtil.TCHeapThresholdMB;
				if (tCMonoHeapTotal > 0)
				{
					_ = (float)tCMonoHeapUsed / (float)tCMonoHeapTotal;
				}
				Color color3 = (((double)tCMonoHeapUsed / 1048576.0 > tCHeapThresholdMB * 0.9) ? Color.red : (((double)tCMonoHeapUsed / 1048576.0 > tCHeapThresholdMB * 0.7) ? Color.yellow : Color.green));
				ColorLabel($"Mono heap: {tCMonoHeapUsed >> 20}MB / {tCMonoHeapTotal >> 20}MB  (TC threshold {tCHeapThresholdMB:F0}MB)", color3);
				Label($"Unity memory: {tCMemUsed >> 20}MB used / {tCMemTotal >> 20}MB reserved");
			}
			else
			{
				long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
				Label($"Mono heap: {totalMemory >> 20}MB  (TC bridge unavailable)");
			}
			Label($"GC collections: gen0={GC.CollectionCount(0)}  gen1={GC.CollectionCount(1)}  gen2={GC.CollectionCount(2)}");
			string text2 = ((_lastFrameCollects > 0) ? "<color=#FFBF33>" : "<color=#888888>");
			Label($"Session gen-max collects: {_sessionCollectsSeen}");
			Label(string.Format("Last frame: {0}{1} collect(s){2}, heap delta {3}", text2, _lastFrameCollects, "</color>", FormatAllocDelta(_lastFrameHeapDelta)));
			Label($"Ops caught with collect inside: {_opsWithCollect}");
			GUIHelper.Space(8f);
			SectionHeader("Scene");
			Scene activeScene = SceneManager.GetActiveScene();
			Label("Active: " + ((Scene)(ref activeScene)).name);
			Label("Last load: " + lastSceneLoaded + " (" + lastSceneLoadTime + ")");
			Label($"Loaded scenes: {SceneManager.sceneCount}");
			GUIHelper.Space(8f);
			SectionHeader("Stitchwork Assets");
			Label($"Audio clips cached: {AudioHandler.CachedClipCount}");
			Label($"Text sheets cached: {DialogueHandler.CachedSheetCount} ({DialogueHandler.CachedKeyCount} keys)");
			Label($"FileCache bytes: {FileCache.TotalBytes >> 20}MB retained  ({FileCache.Count} live)");
			Label($"T2D sheet PNG bytes: {T2DLoader.SpritesheetOverrideBytes >> 20}MB  originals: {T2DLoader.OriginalTextureDataBytes >> 20}MB");
			if (DialogueHandler.StaleKeyCount > 0)
			{
				ColorLabel($"  ⚠ {DialogueHandler.StaleKeyCount} stale text key(s)", Color.yellow);
			}
			Label($"Plugin packs: {PackManager.AllPacks.Count((PackInfo p) => p.IsEnabled)} active / {PackManager.AllPacks.Count} total");
			foreach (PackInfo item in PackManager.AllPacks.Where((PackInfo p) => p.IsEnabled))
			{
				Label("  • " + item.Name);
			}
			GUIHelper.Space(8f);
			SectionHeader("Utilities");
			if (Plugin.Config != null)
			{
				float num6 = Mathf.Clamp(Plugin.Config.UninitCheckCacheRefreshSeconds, 0.01f, 10f);
				string text3 = (Plugin.Config.DisableUninitCheck ? "DISABLED" : $"enabled, scan refresh every {num6:F2}s");
				Label("UninitCheck probe: " + text3);
				if (GUILayout.Button(Plugin.Config.DisableUninitCheck ? "Enable UninitCheck" : "Disable UninitCheck", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					Plugin.Config.DisableUninitCheck = !Plugin.Config.DisableUninitCheck;
					T2DLoader.InvalidateUninitCache();
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button("Uninit 0.10s", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					Plugin.Config.UninitCheckCacheRefreshSeconds = 0.1f;
					T2DLoader.InvalidateUninitCache();
				}
				if (GUILayout.Button("0.30s", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					Plugin.Config.UninitCheckCacheRefreshSeconds = 0.3f;
					T2DLoader.InvalidateUninitCache();
				}
				if (GUILayout.Button("1.00s", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					Plugin.Config.UninitCheckCacheRefreshSeconds = 1f;
					T2DLoader.InvalidateUninitCache();
				}
				GUILayout.EndHorizontal();
			}
			if (GUILayout.Button("Force GC Collect", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				MarkExpectedCollect("manual-button");
				GCUtil.ForceCollect();
			}
			if (_heapCaptureActive)
			{
				float num7 = Mathf.Max(0f, _heapCaptureEndTime - Time.realtimeSinceStartup);
				Label($"Heap capture: {num7:F1}s remaining");
			}
			if (_gcStallActive)
			{
				float num8 = Mathf.Max(0f, _gcStallEndTime - Time.realtimeSinceStartup);
				Label($"GC stall capture: post-window {num8:F1}s remaining");
			}
			else if (_gcStallArmed)
			{
				int num9 = Mathf.Clamp(Plugin.Config?.GcStallCaptureThresholdMs ?? 50, 1, 1000);
				Label($"GC stall capture armed: waiting for collect frame >= {num9}ms");
			}
			bool enabled = GUI.enabled;
			GUI.enabled = enabled && !_heapCaptureActive;
			int num10 = Mathf.Clamp(Plugin.Config?.HeapCaptureWindowSeconds ?? 10, 1, 120);
			if (GUILayout.Button($"Capture Heap Window ({num10}s)", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				StartHeapCapture(num10);
			}
			GUI.enabled = enabled;
			int num11 = Mathf.Clamp(Plugin.Config?.GcStallCaptureThresholdMs ?? 50, 1, 1000);
			if (_gcStallArmed || _gcStallActive)
			{
				if (GUILayout.Button("Cancel GC Stall Capture", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					CancelGcStallCapture();
				}
			}
			else if (GUILayout.Button($"Arm GC Stall Capture (>={num11}ms)", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				ArmGcStallCapture(num11);
			}
			if (GUILayout.Button("Reload All Sprites", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				FileCache.BeginCycle();
				try
				{
					SpriteLoader.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
			}
			if (GUILayout.Button("Reload Audio", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				FileCache.BeginCycle();
				try
				{
					AudioHandler.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
			}
			if (GUILayout.Button("Reload Text", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				FileCache.BeginCycle();
				try
				{
					DialogueHandler.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
			}
			if (GUILayout.Button("Log Scene Hierarchy", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				LogSceneHierarchy();
			}
		}

		private static void StartHeapCapture(int durationSec)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			_heapCaptureActive = true;
			_heapCaptureStartedAt = DateTime.Now;
			_heapCaptureStartTime = Time.realtimeSinceStartup;
			_heapCaptureEndTime = _heapCaptureStartTime + (float)Mathf.Clamp(durationSec, 1, 120);
			_heapCaptureNextSampleTime = _heapCaptureStartTime;
			Scene activeScene = SceneManager.GetActiveScene();
			_heapCaptureStartScene = ((Scene)(ref activeScene)).name;
			_heapCaptureFrameCount = 0;
			_heapCaptureCollects = 0;
			_heapCaptureStartGen2 = GC.CollectionCount(GC.MaxGeneration);
			_heapCaptureStartTcHeap = CurrentTcHeapBytes();
			_heapCaptureEndTcHeap = _heapCaptureStartTcHeap;
			_heapCaptureMinTcHeap = _heapCaptureStartTcHeap;
			_heapCaptureMaxTcHeap = _heapCaptureStartTcHeap;
			_heapCaptureStartGcHeap = GC.GetTotalMemory(forceFullCollection: false);
			_heapCaptureEndGcHeap = _heapCaptureStartGcHeap;
			_heapCaptureMinGcHeap = _heapCaptureStartGcHeap;
			_heapCaptureMaxGcHeap = _heapCaptureStartGcHeap;
			_heapCaptureStartThreshold = (GCUtil.BridgeAvailable ? GCUtil.TCHeapThresholdMB : 0.0);
			_heapCaptureEndThreshold = _heapCaptureStartThreshold;
			_heapCaptureStartFileBytes = FileCache.TotalBytes;
			_heapCaptureStartSheetBytes = T2DLoader.SpritesheetOverrideBytes;
			_heapCaptureStartOriginalBytes = T2DLoader.OriginalTextureDataBytes;
			_heapCaptureEndFileBytes = _heapCaptureStartFileBytes;
			_heapCaptureEndSheetBytes = _heapCaptureStartSheetBytes;
			_heapCaptureEndOriginalBytes = _heapCaptureStartOriginalBytes;
			_heapCaptureWorstFrameMs = 0f;
			_heapCaptureWorstUpdateMs = 0f;
			_heapCaptureOps.Clear();
			_heapCaptureSamples.Clear();
			_heapCaptureEvents.Clear();
			string text = Path.Combine(Plugin.BasePath, "diagnostics");
			Directory.CreateDirectory(text);
			_heapCapturePath = Path.Combine(text, $"heap-window-{_heapCaptureStartedAt:yyyyMMdd-HHmmss}.txt");
			_heapCaptureSamples.AppendLine("t,scene,frameMs,unityFrameMs,updateMs,enforceMs,uninitMs,tcHeapMB,gcHeapMB,tcTotalMB,tcThresholdMB,fileMB,sheetMB,origMB,lastFrameCollects,lastFrameHeapDeltaMB");
			CaptureHeapSample(_heapCaptureStartTime);
			Plugin.Logger.LogInfo((object)$"[HeapCapture] Started {durationSec}s window; report will be written to {_heapCapturePath}");
		}

		private static void TickHeapCapture()
		{
			if (!_heapCaptureActive)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			_heapCaptureFrameCount++;
			if (frameTimeMs > _heapCaptureWorstFrameMs)
			{
				_heapCaptureWorstFrameMs = frameTimeMs;
			}
			if (lastUpdateMs > _heapCaptureWorstUpdateMs)
			{
				_heapCaptureWorstUpdateMs = lastUpdateMs;
			}
			long num = CurrentTcHeapBytes();
			long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
			if (num >= 0)
			{
				if (_heapCaptureMinTcHeap < 0 || num < _heapCaptureMinTcHeap)
				{
					_heapCaptureMinTcHeap = num;
				}
				if (num > _heapCaptureMaxTcHeap)
				{
					_heapCaptureMaxTcHeap = num;
				}
			}
			if (totalMemory < _heapCaptureMinGcHeap)
			{
				_heapCaptureMinGcHeap = totalMemory;
			}
			if (totalMemory > _heapCaptureMaxGcHeap)
			{
				_heapCaptureMaxGcHeap = totalMemory;
			}
			if (realtimeSinceStartup >= _heapCaptureNextSampleTime)
			{
				CaptureHeapSample(realtimeSinceStartup);
				_heapCaptureNextSampleTime = realtimeSinceStartup + 0.25f;
			}
			if (realtimeSinceStartup >= _heapCaptureEndTime)
			{
				FinishHeapCapture(realtimeSinceStartup);
			}
		}

		private static void CaptureHeapSample(float now)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			long bytes = CurrentTcHeapBytes();
			long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
			long bytes2 = (GCUtil.BridgeAvailable ? GCUtil.TCMonoHeapTotal : (-1));
			double num = (GCUtil.BridgeAvailable ? GCUtil.TCHeapThresholdMB : 0.0);
			StringBuilder heapCaptureSamples = _heapCaptureSamples;
			string[] array = new string[5];
			object arg = HeapCaptureElapsed(now);
			Scene activeScene = SceneManager.GetActiveScene();
			array[0] = $"{arg:F2},{((Scene)(ref activeScene)).name},";
			array[1] = $"{frameTimeMs:F1},{unityFrameTimeMs:F1},{lastUpdateMs:F2},{_lastEnforceMs:F2},{_lastUninitMs:F2},";
			array[2] = $"{ToMB(bytes)},{ToMB(totalMemory)},{ToMB(bytes2)},{num:F0},";
			array[3] = $"{ToMB(FileCache.TotalBytes)},{ToMB(T2DLoader.SpritesheetOverrideBytes)},";
			array[4] = $"{ToMB(T2DLoader.OriginalTextureDataBytes)},{_lastFrameCollects},{ToSignedMB(_lastFrameHeapDelta)}";
			heapCaptureSamples.AppendLine(string.Concat(array));
		}

		private static void FinishHeapCapture(float now)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			_heapCaptureEndTcHeap = CurrentTcHeapBytes();
			_heapCaptureEndGcHeap = GC.GetTotalMemory(forceFullCollection: false);
			_heapCaptureEndThreshold = (GCUtil.BridgeAvailable ? GCUtil.TCHeapThresholdMB : 0.0);
			_heapCaptureEndFileBytes = FileCache.TotalBytes;
			_heapCaptureEndSheetBytes = T2DLoader.SpritesheetOverrideBytes;
			_heapCaptureEndOriginalBytes = T2DLoader.OriginalTextureDataBytes;
			int num = GC.CollectionCount(GC.MaxGeneration) - _heapCaptureStartGen2;
			_heapCaptureActive = false;
			StringBuilder stringBuilder = new StringBuilder(16384);
			stringBuilder.AppendLine("# Stitchwork Heap Window Capture");
			stringBuilder.AppendLine($"started={_heapCaptureStartedAt:O}");
			stringBuilder.AppendLine($"durationSec={HeapCaptureElapsed(now):F2}");
			stringBuilder.AppendLine($"frames={_heapCaptureFrameCount}");
			stringBuilder.AppendLine("sceneStart=" + _heapCaptureStartScene);
			Scene activeScene = SceneManager.GetActiveScene();
			stringBuilder.AppendLine("sceneEnd=" + ((Scene)(ref activeScene)).name);
			stringBuilder.AppendLine($"dropFileCacheBytesAfterReload={Plugin.Config?.DropFileCacheBytesAfterReload}");
			stringBuilder.AppendLine($"heapCaptureWindowSeconds={Plugin.Config?.HeapCaptureWindowSeconds}");
			stringBuilder.AppendLine("packs=" + BuildActivePackLine());
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Summary");
			stringBuilder.AppendLine($"tcMonoHeapMB start={ToMB(_heapCaptureStartTcHeap)} end={ToMB(_heapCaptureEndTcHeap)} delta={ToSignedMB(_heapCaptureEndTcHeap - _heapCaptureStartTcHeap)} min={ToMB(_heapCaptureMinTcHeap)} max={ToMB(_heapCaptureMaxTcHeap)}");
			stringBuilder.AppendLine($"gcGetTotalMemoryMB start={ToMB(_heapCaptureStartGcHeap)} end={ToMB(_heapCaptureEndGcHeap)} delta={ToSignedMB(_heapCaptureEndGcHeap - _heapCaptureStartGcHeap)} min={ToMB(_heapCaptureMinGcHeap)} max={ToMB(_heapCaptureMaxGcHeap)}");
			stringBuilder.AppendLine($"tcThresholdMB start={_heapCaptureStartThreshold:F0} end={_heapCaptureEndThreshold:F0} delta={_heapCaptureEndThreshold - _heapCaptureStartThreshold:F0}");
			stringBuilder.AppendLine($"genMaxCollects total={num} eventLogged={_heapCaptureCollects}");
			stringBuilder.AppendLine($"worstFrameMs={_heapCaptureWorstFrameMs:F1} worstPluginUpdateMs={_heapCaptureWorstUpdateMs:F2}");
			stringBuilder.AppendLine($"cacheMB file {ToMB(_heapCaptureStartFileBytes)}->{ToMB(_heapCaptureEndFileBytes)} delta={ToSignedMB(_heapCaptureEndFileBytes - _heapCaptureStartFileBytes)}");
			stringBuilder.AppendLine($"cacheMB sheet {ToMB(_heapCaptureStartSheetBytes)}->{ToMB(_heapCaptureEndSheetBytes)} delta={ToSignedMB(_heapCaptureEndSheetBytes - _heapCaptureStartSheetBytes)}");
			stringBuilder.AppendLine($"cacheMB orig {ToMB(_heapCaptureStartOriginalBytes)}->{ToMB(_heapCaptureEndOriginalBytes)} delta={ToSignedMB(_heapCaptureEndOriginalBytes - _heapCaptureStartOriginalBytes)}");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Operation Aggregates");
			foreach (KeyValuePair<string, HeapCaptureOp> item in from k in _heapCaptureOps
				orderby k.Value.AllocBytes descending, k.Value.MaxMs descending
				select k)
			{
				HeapCaptureOp value = item.Value;
				stringBuilder.AppendLine($"{item.Key}: count={value.Count} totalMs={value.TotalMs:F1} maxMs={value.MaxMs:F1} " + $"positiveNetHeapDeltaMB={ToMB(value.AllocBytes)} collectsInside={value.CollectsInside}");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Events");
			stringBuilder.Append((_heapCaptureEvents.Length > 0) ? _heapCaptureEvents.ToString() : "<none>\n");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Samples");
			stringBuilder.Append(_heapCaptureSamples);
			try
			{
				File.WriteAllText(_heapCapturePath, stringBuilder.ToString());
				Plugin.Logger.LogInfo((object)($"[HeapCapture] Wrote {_heapCaptureFrameCount} frame window to {_heapCapturePath} " + $"tcHeapDelta={ToSignedMB(_heapCaptureEndTcHeap - _heapCaptureStartTcHeap)}MB " + $"gcHeapDelta={ToSignedMB(_heapCaptureEndGcHeap - _heapCaptureStartGcHeap)}MB " + $"collects={num}"));
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[HeapCapture] Failed to write report '" + _heapCapturePath + "': " + ex.Message));
			}
		}

		private static void CaptureHeapOp(string label, float ms, long allocDelta, bool hadCollect)
		{
			if (_heapCaptureActive && !string.IsNullOrEmpty(label))
			{
				HeapCaptureOp heapCaptureOp = GetHeapCaptureOp(label);
				heapCaptureOp.Count++;
				heapCaptureOp.TotalMs += ms;
				if (ms > heapCaptureOp.MaxMs)
				{
					heapCaptureOp.MaxMs = ms;
				}
				if (allocDelta > 0 && !hadCollect)
				{
					heapCaptureOp.AllocBytes += allocDelta;
				}
				if (hadCollect)
				{
					heapCaptureOp.CollectsInside++;
				}
			}
		}

		private static HeapCaptureOp GetHeapCaptureOp(string label)
		{
			if (_heapCaptureOps.TryGetValue(label, out var value))
			{
				return value;
			}
			value = new HeapCaptureOp();
			_heapCaptureOps[label] = value;
			return value;
		}

		private static void CaptureHeapSpike(string label, float durationMs, bool hadCollect, bool suppressed)
		{
			if (_heapCaptureActive)
			{
				_heapCaptureEvents.AppendLine($"SPIKE t={HeapCaptureElapsed(Time.realtimeSinceStartup):F2}s " + $"label={label} ms={durationMs:F1} gc={hadCollect} displayed={!suppressed}");
			}
		}

		private static void ArmGcStallCapture(int thresholdMs)
		{
			_gcStallArmed = true;
			_gcStallActive = false;
			_gcStallTriggerThresholdMs = Mathf.Clamp(thresholdMs, 1, 1000);
			Plugin.Logger.LogInfo((object)$"[GCStallCapture] Armed; next gen-max collect frame >= {_gcStallTriggerThresholdMs}ms will write a report");
		}

		private static void CancelGcStallCapture()
		{
			_gcStallArmed = false;
			_gcStallActive = false;
			Plugin.Logger.LogInfo((object)"[GCStallCapture] Cancelled");
		}

		private static void MaybeTriggerGcStallCapture(float now, int countThisFrame, string reason, string scene, long heapAfter, long freedBytes)
		{
			if (_gcStallArmed && !_gcStallActive && !(frameTimeMs < (float)_gcStallTriggerThresholdMs))
			{
				_gcStallArmed = false;
				_gcStallActive = true;
				_gcStallTriggerTime = now;
				_gcStallEndTime = now + 5f;
				_gcStallTriggeredAt = DateTime.Now;
				_gcStallTriggerReason = reason;
				_gcStallTriggerScene = scene;
				_gcStallTriggerCollects = countThisFrame;
				_gcStallTriggerFrameMs = frameTimeMs;
				_gcStallTriggerHeapAfter = heapAfter;
				_gcStallTriggerFreedBytes = freedBytes;
				_gcStallTriggerThresholdMs = Mathf.Clamp(Plugin.Config?.GcStallCaptureThresholdMs ?? _gcStallTriggerThresholdMs, 1, 1000);
				string text = Path.Combine(Plugin.BasePath, "diagnostics");
				Directory.CreateDirectory(text);
				_gcStallPath = Path.Combine(text, $"gc-stall-{_gcStallTriggeredAt:yyyyMMdd-HHmmss}.txt");
				Plugin.Logger.LogInfo((object)($"[GCStallCapture] Triggered by {frameTimeMs:F1}ms collect frame in {scene}; " + $"writing report after {5f:F0}s post-window to {_gcStallPath}"));
			}
		}

		private static void TickGcStallRecorder()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_gcStallNextSampleTime <= 0f)
			{
				_gcStallNextSampleTime = realtimeSinceStartup;
			}
			if (realtimeSinceStartup >= _gcStallNextSampleTime)
			{
				CaptureGcStallSample(realtimeSinceStartup, force: false);
				_gcStallNextSampleTime = realtimeSinceStartup + 0.25f;
			}
			if (_gcStallActive && realtimeSinceStartup >= _gcStallEndTime)
			{
				FinishGcStallCapture(realtimeSinceStartup);
			}
		}

		private static void CaptureGcStallSample(float now, bool force)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (force || !(now < _gcStallNextSampleTime))
			{
				GcStallSample[] gcStallSamples = _gcStallSamples;
				int gcStallSampleHead = _gcStallSampleHead;
				GcStallSample gcStallSample = new GcStallSample
				{
					T = now
				};
				Scene activeScene = SceneManager.GetActiveScene();
				gcStallSample.Scene = ((Scene)(ref activeScene)).name;
				gcStallSample.FrameMs = frameTimeMs;
				gcStallSample.UnityFrameMs = unityFrameTimeMs;
				gcStallSample.UpdateMs = lastUpdateMs;
				gcStallSample.EnforceMs = _lastEnforceMs;
				gcStallSample.UninitMs = _lastUninitMs;
				gcStallSample.TcHeap = CurrentTcHeapBytes();
				gcStallSample.GcHeap = GC.GetTotalMemory(forceFullCollection: false);
				gcStallSample.TcTotal = (GCUtil.BridgeAvailable ? GCUtil.TCMonoHeapTotal : (-1));
				gcStallSample.ThresholdMB = (GCUtil.BridgeAvailable ? GCUtil.TCHeapThresholdMB : 0.0);
				gcStallSample.FileBytes = FileCache.TotalBytes;
				gcStallSample.SheetBytes = T2DLoader.SpritesheetOverrideBytes;
				gcStallSample.OriginalBytes = T2DLoader.OriginalTextureDataBytes;
				gcStallSample.Collects = _lastFrameCollects;
				gcStallSample.FrameHeapDelta = _lastFrameHeapDelta;
				gcStallSample.LabelledAllocBytes = _gcStallLabelledAllocSinceSample;
				gcStallSample.UninitRefreshTotal = _uninitRefreshTotal;
				gcStallSamples[gcStallSampleHead] = gcStallSample;
				_gcStallSampleHead = (_gcStallSampleHead + 1) % 96;
				if (_gcStallSampleCount < 96)
				{
					_gcStallSampleCount++;
				}
				_gcStallLabelledAllocSinceSample = 0L;
				if (force)
				{
					_gcStallNextSampleTime = now + 0.25f;
				}
			}
		}

		private static void CaptureGcStallFrame(float now, long heapNow)
		{
			_gcStallFrames[_gcStallFrameHead] = new GcStallFrame
			{
				T = now,
				FrameMs = frameTimeMs,
				UnityFrameMs = unityFrameTimeMs,
				GcHeap = heapNow,
				Collects = _lastFrameCollects,
				FrameHeapDelta = _lastFrameHeapDelta,
				LabelledAllocBytes = _gcStallLabelledAllocSinceFrame
			};
			_gcStallFrameHead = (_gcStallFrameHead + 1) % 8192;
			if (_gcStallFrameCount < 8192)
			{
				_gcStallFrameCount++;
			}
			_gcStallLabelledAllocSinceFrame = 0L;
		}

		private static void RecordGcStallAlloc(string label, long bytes)
		{
			if (bytes > 0 && !string.IsNullOrEmpty(label))
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				_gcStallLabelledAllocSinceSample += bytes;
				_gcStallLabelledAllocSinceFrame += bytes;
				_gcStallAllocEvents[_gcStallAllocHead] = new GcStallAllocEvent
				{
					T = realtimeSinceStartup,
					Label = label,
					Bytes = bytes
				};
				_gcStallAllocHead = (_gcStallAllocHead + 1) % 65536;
				if (_gcStallAllocCount < 65536)
				{
					_gcStallAllocCount++;
				}
			}
		}

		private static void RecordGcStallEvent(float now, string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				_gcStallEvents[_gcStallEventHead] = new GcStallEvent
				{
					T = now,
					Text = text
				};
				_gcStallEventHead = (_gcStallEventHead + 1) % 256;
				if (_gcStallEventCount < 256)
				{
					_gcStallEventCount++;
				}
			}
		}

		private static void FinishGcStallCapture(float now)
		{
			_gcStallActive = false;
			CaptureGcStallSample(now, force: true);
			float num = _gcStallTriggerTime - 15f;
			List<GcStallSample> gcStallSamples = GetGcStallSamples(num, now);
			List<GcStallAllocEvent> gcStallAllocEvents = GetGcStallAllocEvents(num, now);
			List<GcStallEvent> gcStallEvents = GetGcStallEvents(num, now);
			List<GcStallFrame> gcStallFrames = GetGcStallFrames(num, now);
			long num2 = 0L;
			Dictionary<string, long> dictionary = new Dictionary<string, long>(StringComparer.Ordinal);
			foreach (GcStallAllocEvent item in gcStallAllocEvents)
			{
				num2 += item.Bytes;
				if (dictionary.TryGetValue(item.Label, out var value))
				{
					dictionary[item.Label] = value + item.Bytes;
				}
				else
				{
					dictionary[item.Label] = item.Bytes;
				}
			}
			long num3 = 0L;
			long bytes = 0L;
			long num4 = -1L;
			long num5 = -1L;
			if (gcStallSamples.Count > 0)
			{
				bytes = gcStallSamples[gcStallSamples.Count - 1].GcHeap - gcStallSamples[0].GcHeap;
				num4 = gcStallSamples[0].GcHeap;
				num5 = gcStallSamples[0].GcHeap;
				for (int i = 0; i < gcStallSamples.Count; i++)
				{
					long gcHeap = gcStallSamples[i].GcHeap;
					if (gcHeap < num4)
					{
						num4 = gcHeap;
					}
					if (gcHeap > num5)
					{
						num5 = gcHeap;
					}
					if (i > 0)
					{
						long num6 = gcHeap - gcStallSamples[i - 1].GcHeap;
						if (num6 > 0)
						{
							num3 += num6;
						}
					}
				}
			}
			long num7 = 0L;
			string[] array = new string[3] { "Plugin.Update.Total", "Plugin.LateUpdate.Total", "Plugin.OnGUI.Total" };
			foreach (string key in array)
			{
				if (dictionary.TryGetValue(key, out var value2))
				{
					num7 += value2;
				}
			}
			float num8 = ((gcStallFrames.Count > 1) ? (gcStallFrames[gcStallFrames.Count - 1].T - gcStallFrames[0].T) : 0f);
			float num9 = ((num8 > 0f) ? ((float)(gcStallFrames.Count - 1) / num8) : 0f);
			float num10 = ((gcStallAllocEvents.Count > 1) ? (gcStallAllocEvents[gcStallAllocEvents.Count - 1].T - gcStallAllocEvents[0].T) : 0f);
			bool flag = gcStallAllocEvents.Count == 65536 && gcStallAllocEvents.Count > 0 && gcStallAllocEvents[0].T > num + 0.01f;
			int num11 = ((gcStallSamples.Count > 1) ? (gcStallSamples[gcStallSamples.Count - 1].UninitRefreshTotal - gcStallSamples[0].UninitRefreshTotal) : 0);
			float num12 = ((gcStallSamples.Count > 1) ? (gcStallSamples[gcStallSamples.Count - 1].T - gcStallSamples[0].T) : 0f);
			float num13 = ((num12 > 0f) ? ((float)num11 / num12) : 0f);
			StringBuilder stringBuilder = new StringBuilder(32768);
			stringBuilder.AppendLine("# Stitchwork GC Stall Capture");
			stringBuilder.AppendLine($"triggered={_gcStallTriggeredAt:O}");
			stringBuilder.AppendLine($"preWindowSec={15f:F0}");
			stringBuilder.AppendLine($"postWindowSec={5f:F0}");
			stringBuilder.AppendLine("triggerScene=" + _gcStallTriggerScene);
			stringBuilder.AppendLine("triggerReason=" + _gcStallTriggerReason);
			stringBuilder.AppendLine($"triggerFrameMs={_gcStallTriggerFrameMs:F1}");
			stringBuilder.AppendLine("frameMsSource=Stopwatch wall-clock delta");
			stringBuilder.AppendLine($"triggerThresholdMs={_gcStallTriggerThresholdMs}");
			stringBuilder.AppendLine($"triggerCollects={_gcStallTriggerCollects}");
			stringBuilder.AppendLine($"triggerHeapAfterMB={ToMB(_gcStallTriggerHeapAfter)}");
			stringBuilder.AppendLine($"triggerFreedAtLeastMB={ToMB(_gcStallTriggerFreedBytes)}");
			stringBuilder.AppendLine("packs=" + BuildActivePackLine());
			stringBuilder.AppendLine($"dropFileCacheBytesAfterReload={Plugin.Config?.DropFileCacheBytesAfterReload}");
			stringBuilder.AppendLine($"disableHeapThresholdBump={Plugin.Config?.DisableHeapThresholdBump}");
			stringBuilder.AppendLine($"disableUninitCheck={Plugin.Config?.DisableUninitCheck}");
			stringBuilder.AppendLine($"uninitCheckCacheRefreshSeconds={Plugin.Config?.UninitCheckCacheRefreshSeconds:F2}");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Attribution");
			stringBuilder.AppendLine($"sampleCount={gcStallSamples.Count}");
			stringBuilder.AppendLine($"frameTraceCount={gcStallFrames.Count}");
			stringBuilder.AppendLine($"frameTraceSpanSec={num8:F2}");
			stringBuilder.AppendLine($"frameTraceFps={num9:F1}");
			stringBuilder.AppendLine($"labelledPositiveNetHeapEventCount={gcStallAllocEvents.Count}");
			stringBuilder.AppendLine($"labelledPositiveNetHeapEventSpanSec={num10:F2}");
			stringBuilder.AppendLine($"labelledPositiveNetHeapMayBeTruncated={flag}");
			stringBuilder.AppendLine($"uninitRefreshes={num11}");
			stringBuilder.AppendLine($"uninitRefreshesPerSec={num13:F2}");
			stringBuilder.AppendLine($"heapDeltaMB={ToSignedMB(bytes)}");
			stringBuilder.AppendLine($"positiveHeapGrowthMB={ToMB(num3)}");
			stringBuilder.AppendLine($"labelledPositiveNetHeapDeltaInclusiveMB={ToMB(num2)}");
			stringBuilder.AppendLine("labelledPositiveNetHeapDeltaNote=nested labels overlap; scopes containing a gen-max collect are omitted; do not subtract this total from heap growth");
			stringBuilder.AppendLine($"instrumentedPluginLoopPositiveNetHeapDeltaMB={ToMB(num7)}");
			stringBuilder.AppendLine($"heapMinMB={ToMB(num4)} heapMaxMB={ToMB(num5)}");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Top Labelled Positive Net Heap Deltas");
			foreach (KeyValuePair<string, long> item2 in dictionary.OrderByDescending((KeyValuePair<string, long> k) => k.Value).Take(12))
			{
				stringBuilder.AppendLine($"{item2.Key}={ToMB(item2.Value)}MB bytes={item2.Value}");
			}
			if (dictionary.Count == 0)
			{
				stringBuilder.AppendLine("<none>");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Events");
			foreach (GcStallEvent item3 in gcStallEvents)
			{
				stringBuilder.AppendLine($"t={item3.T - _gcStallTriggerTime:F2}s {item3.Text}");
			}
			if (gcStallEvents.Count == 0)
			{
				stringBuilder.AppendLine("<none>");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Samples");
			stringBuilder.AppendLine("tRel,scene,frameMs,unityFrameMs,updateMs,enforceMs,uninitMs,tcHeapMB,gcHeapMB,tcTotalMB,tcThresholdMB,fileMB,sheetMB,origMB,lastFrameCollects,lastFrameHeapDeltaMB,labelledPositiveNetHeapDeltaInclusiveSinceLastSampleMB,uninitRefreshTotal");
			foreach (GcStallSample item4 in gcStallSamples)
			{
				stringBuilder.AppendLine($"{item4.T - _gcStallTriggerTime:F2},{item4.Scene}," + $"{item4.FrameMs:F1},{item4.UnityFrameMs:F1},{item4.UpdateMs:F2},{item4.EnforceMs:F2},{item4.UninitMs:F2}," + $"{ToMB(item4.TcHeap)},{ToMB(item4.GcHeap)},{ToMB(item4.TcTotal)},{item4.ThresholdMB:F0}," + $"{ToMB(item4.FileBytes)},{ToMB(item4.SheetBytes)},{ToMB(item4.OriginalBytes)}," + $"{item4.Collects},{ToSignedMB(item4.FrameHeapDelta)},{ToMB(item4.LabelledAllocBytes)},{item4.UninitRefreshTotal}");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("## Frame Heap Trace");
			stringBuilder.AppendLine("tRel,frameMs,unityFrameMs,gcHeapMB,lastFrameCollects,lastFrameHeapDeltaBytes,lastFrameHeapDeltaMB,labelledPositiveNetHeapDeltaInclusiveSinceLastFrameBytes,labelledPositiveNetHeapDeltaInclusiveSinceLastFrameMB");
			foreach (GcStallFrame item5 in gcStallFrames)
			{
				stringBuilder.AppendLine($"{item5.T - _gcStallTriggerTime:F3}," + $"{item5.FrameMs:F1},{item5.UnityFrameMs:F1},{ToMB(item5.GcHeap)}," + $"{item5.Collects},{item5.FrameHeapDelta},{ToSignedMB(item5.FrameHeapDelta)}," + $"{item5.LabelledAllocBytes},{ToMB(item5.LabelledAllocBytes)}");
			}
			try
			{
				File.WriteAllText(_gcStallPath, stringBuilder.ToString());
				Plugin.Logger.LogInfo((object)($"[GCStallCapture] Wrote {gcStallSamples.Count} samples to {_gcStallPath} " + $"heapGrowth={ToMB(num3)}MB pluginLoopPositiveNetHeap={ToMB(num7)}MB " + $"inclusiveLabelPositiveNetHeap={ToMB(num2)}MB"));
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[GCStallCapture] Failed to write report '" + _gcStallPath + "': " + ex.Message));
			}
		}

		private static List<GcStallSample> GetGcStallSamples(float start, float end)
		{
			List<GcStallSample> list = new List<GcStallSample>(_gcStallSampleCount);
			int num = (_gcStallSampleHead - _gcStallSampleCount + 96) % 96;
			for (int i = 0; i < _gcStallSampleCount; i++)
			{
				GcStallSample item = _gcStallSamples[(num + i) % 96];
				if (item.T >= start && item.T <= end)
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static List<GcStallAllocEvent> GetGcStallAllocEvents(float start, float end)
		{
			List<GcStallAllocEvent> list = new List<GcStallAllocEvent>(_gcStallAllocCount);
			int num = (_gcStallAllocHead - _gcStallAllocCount + 65536) % 65536;
			for (int i = 0; i < _gcStallAllocCount; i++)
			{
				GcStallAllocEvent item = _gcStallAllocEvents[(num + i) % 65536];
				if (item.T >= start && item.T <= end)
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static List<GcStallEvent> GetGcStallEvents(float start, float end)
		{
			List<GcStallEvent> list = new List<GcStallEvent>(_gcStallEventCount);
			int num = (_gcStallEventHead - _gcStallEventCount + 256) % 256;
			for (int i = 0; i < _gcStallEventCount; i++)
			{
				GcStallEvent item = _gcStallEvents[(num + i) % 256];
				if (item.T >= start && item.T <= end)
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static List<GcStallFrame> GetGcStallFrames(float start, float end)
		{
			List<GcStallFrame> list = new List<GcStallFrame>(_gcStallFrameCount);
			int num = (_gcStallFrameHead - _gcStallFrameCount + 8192) % 8192;
			for (int i = 0; i < _gcStallFrameCount; i++)
			{
				GcStallFrame item = _gcStallFrames[(num + i) % 8192];
				if (item.T >= start && item.T <= end)
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static long CurrentTcHeapBytes()
		{
			if (!GCUtil.BridgeAvailable)
			{
				return -1L;
			}
			return GCUtil.TCMonoHeapUsed;
		}

		private static float HeapCaptureElapsed(float now)
		{
			return now - _heapCaptureStartTime;
		}

		private static long ToMB(long bytes)
		{
			if (bytes >= 0)
			{
				return bytes / 1048576;
			}
			return -1L;
		}

		private static long ToSignedMB(long bytes)
		{
			return bytes / 1048576;
		}

		private static string BuildActivePackLine()
		{
			List<string> list = (from p in PackManager.AllPacks
				where p.IsEnabled
				select p.Name).ToList();
			if (list.Count != 0)
			{
				return string.Join(", ", list);
			}
			return "<none>";
		}

		private static void DrawFrameGraph()
		{
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			float num = GUIHelper.Scaled(50f);
			Rect rect = GUILayoutUtility.GetRect(0f, float.MaxValue, num, num);
			if ((Object)(object)graphTex == (Object)null)
			{
				graphTex = new Texture2D(1, 1)
				{
					hideFlags = (HideFlags)32
				};
				graphTex.SetPixel(0, 0, new Color(0.15f, 0.15f, 0.15f, 0.8f));
				graphTex.Apply();
			}
			GUI.DrawTexture(rect, (Texture)(object)graphTex);
			if ((Object)(object)barTex == (Object)null)
			{
				barTex = new Texture2D(1, 1)
				{
					hideFlags = (HideFlags)32
				};
				barTex.SetPixel(0, 0, Color.white);
				barTex.Apply();
			}
			if (sampleCount < 2)
			{
				return;
			}
			float num2 = ((Rect)(ref rect)).width / 120f;
			int num3 = Mathf.Min(sampleCount, 120);
			Color color = default(Color);
			for (int i = 0; i < num3; i++)
			{
				int num4 = ((frameIndex - 1 - i) % 120 + 120) % 120;
				float num5 = FrameTimes[num4] * 1000f;
				float num6 = Mathf.Clamp01(num5 / 50f) * ((Rect)(ref rect)).height;
				if (ReloadFrames[num4])
				{
					((Color)(ref color))..ctor(1f, 0.55f, 0f);
				}
				else
				{
					color = ((!(num5 <= 16.667f)) ? ((!(num5 <= 33.33f)) ? Color.red : Color.yellow) : Color.green);
				}
				GUI.color = color;
				GUI.DrawTexture(new Rect(((Rect)(ref rect)).xMax - (float)(i + 1) * num2, ((Rect)(ref rect)).yMax - num6, num2 - 1f, num6), (Texture)(object)barTex);
			}
			GUI.color = new Color(1f, 1f, 1f, 0.3f);
			float num7 = ((Rect)(ref rect)).yMax - 0.33334f * ((Rect)(ref rect)).height;
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, num7, ((Rect)(ref rect)).width, 1f), (Texture)(object)barTex);
			GUI.color = Color.white;
		}

		private static void LogSceneHierarchy()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			Plugin.Logger.LogInfo((object)("[DevProfiler] Scene hierarchy for '" + ((Scene)(ref activeScene)).name + "':"));
			GameObject[] rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			for (int i = 0; i < rootGameObjects.Length; i++)
			{
				LogGameObject(rootGameObjects[i], 0);
			}
		}

		private static void LogGameObject(GameObject go, int depth)
		{
			string text = new string(' ', depth * 2);
			int num = go.GetComponents<Component>().Length;
			Plugin.Logger.LogInfo((object)$"[DevProfiler] {text}{((Object)go).name} ({num} components, active={go.activeSelf})");
			if (depth < 3)
			{
				for (int i = 0; i < go.transform.childCount; i++)
				{
					LogGameObject(((Component)go.transform.GetChild(i)).gameObject, depth + 1);
				}
			}
		}

		private static void SectionHeader(string text)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label("--- " + text + " ---", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}

		private static void Label(string text)
		{
			GUILayout.Label(text, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		}

		private static void ColorLabel(string text, Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			GUI.contentColor = color;
			GUILayout.Label(text, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}

		private static string FormatAllocDelta(long bytes)
		{
			if (bytes == 0L)
			{
				return "0B";
			}
			long num = ((bytes < 0) ? (-bytes) : bytes);
			string arg = ((bytes < 0) ? "-" : "+");
			if (num < 1024)
			{
				return $"{arg}{num}B";
			}
			if (num < 1048576)
			{
				return $"{arg}{num / 1024}KB";
			}
			return $"{arg}{num / 1048576}MB";
		}
	}
	public static class DialogueEditor
	{
		private class DialogueEntry
		{
			public string Sheet;

			public string Key;

			public string CurrentText;

			public DateTime LastSeen;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static WindowFunction <0>__DrawWindow;
		}

		private const float WindowWidth = 520f;

		private const float WindowHeight = 500f;

		private static Rect windowRect;

		private static bool initialized;

		private static Vector2 entryListScroll;

		private static Vector2 editAreaScroll;

		private static readonly List<DialogueEntry> Entries = new List<DialogueEntry>();

		private static readonly Dictionary<string, DialogueEntry> EntryLookup = new Dictionary<string, DialogueEntry>();

		private static DialogueEntry selectedEntry;

		private static string editText = "";

		private static bool hasUnsavedChanges;

		private static string searchText = "";

		private static string statusMessage = "";

		private static float statusTime;

		private static float _deleteArmedAt = -1f;

		private static string _deleteArmedKey;

		private static float _deleteArmTime;

		private const string SearchFieldControlName = "Stitchwork.DialogueEditor.Search";

		private const string EditAreaControlName = "Stitchwork.DialogueEditor.EditArea";

		private static readonly (string Tag, string Label)[] PrimaryTags = new(string, string)[3]
		{
			("<page>", "NPC"),
			("<hpage>", "Hornet"),
			("<br>", "line break")
		};

		private static readonly string[] ExtraTags = new string[5] { "<page=S>", "<page=T>", "<page=L>", "<page=B>", "<page=M>" };

		private static bool _showExtraTags;

		private const int SoftWrapVisualThreshold = 32;

		private static GUIStyle _tagButtonStyle;

		private static int lastCursorIndex;

		private static int _pendingCaret = -1;

		private static GUIStyle TagButtonStyle
		{
			get
			{
				//IL_0021: 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_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				int num = GUIHelper.FontSize(12);
				if (_tagButtonStyle == null || _tagButtonStyle.fontSize != num)
				{
					_tagButtonStyle = new GUIStyle(GUIHelper.ButtonStyle)
					{
						richText = false,
						fontSize = num
					};
				}
				return _tagButtonStyle;
			}
		}

		private static string SmartWrap(string canonical)
		{
			if (string.IsNullOrEmpty(canonical))
			{
				return canonical;
			}
			string text = canonical.Replace("\r\n", "").Replace("\n", "").Replace("\r", "");
			StringBuilder stringBuilder = new StringBuilder(text.Length + 16);
			int num = 0;
			int num2 = 0;
			bool flag = false;
			while (num2 < text.Length)
			{
				if (text[num2] == '<')
				{
					int num3 = text.IndexOf('>', num2);
					if (num3 > num2)
					{
						string text2 = text.Substring(num2, num3 - num2 + 1);
						if (IsBreakTag(text2))
						{
							if (stringBuilder.Length > 0 && !flag)
							{
								stringBuilder.Append('\n');
								num = 0;
							}
							stringBuilder.Append(text2);
							num += text2.Length;
							flag = true;
							num2 = num3 + 1;
							continue;
						}
					}
				}
				char c = text[num2];
				stringBuilder.Append(c);
				num += VisualWidth(c);
				flag = false;
				num2++;
				if ((c == '。' || c == '！' || c == '？') && num >= 32 && num2 < text.Length && text[num2] != '<')
				{
					stringBuilder.Append('\n');
					num = 0;
				}
			}
			return stringBuilder.ToString();
		}

		private static int VisualWidth(char c)
		{
			if (c >= '\u3000' && c <= '鿿')
			{
				return 2;
			}
			if (c >= '가' && c <= '\ud7af')
			{
				return 2;
			}
			if (c >= '豈' && c <= '\ufaff')
			{
				return 2;
			}
			if (c >= '\uff00' && c <= '\uffef')
			{
				return 2;
			}
			return 1;
		}

		private static string StripSoftWraps(string editorText)
		{
			if (string.IsNullOrEmpty(editorText))
			{
				return editorText;
			}
			return editorText.Replace("\r\n", "").Replace("\n", "").Replace("\r", "");
		}

		private static bool IsBreakTag(string tag)
		{
			if (string.IsNullOrEmpty(tag) || tag.Length < 4)
			{
				return false;
			}
			switch (tag)
			{
			case "<br>":
			case "<page>":
			case "<hpage>":
				return true;
			default:
				if (tag.StartsWith("<page=") && tag.EndsWith(">"))
				{
					return true;
				}
				return false;
			}
		}

		private static void InsertTagAtCursor(string tag)
		{
			int num = Mathf.Clamp(lastCursorIndex, 0, editText.Length);
			string text = ((!IsBreakTag(tag) || num <= 0 || editText[num - 1] == '\n' || EndsWithBreakTag(editText, num)) ? tag : ("\n" + tag));
			editText = editText.Insert(num, text);
			lastCursorIndex = num + text.Length;
			_pendingCaret = lastCursorIndex;
			GUI.FocusControl("Stitchwork.DialogueEditor.EditArea");
			hasUnsavedChanges = true;
		}

		private static void DrawTagRow()
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			(string, string)[] primaryTags = PrimaryTags;
			for (int i = 0; i < primaryTags.Length; i++)
			{
				var (text, text2) = primaryTags[i];
				if (GUILayout.Button(text + "  " + text2, TagButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(24f),
					GUILayout.ExpandWidth(true)
				}))
				{
					InsertTagAtCursor(text);
				}
			}
			GUILayout.Space(GUIHelper.Scaled(6f));
			if (GUILayout.Button(_showExtraTags ? "▼ More" : "▶ More", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(72f),
				GUIHelper.Height(24f)
			}))
			{
				_showExtraTags = !_showExtraTags;
			}
			GUILayout.EndHorizontal();
			if (!_showExtraTags)
			{
				return;
			}
			GUIHelper.Space(2f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("Extra:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(40f) });
			GUI.contentColor = Color.white;
			string[] extraTags = ExtraTags;
			foreach (string text3 in extraTags)
			{
				if (GUILayout.Button(text3, TagButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(20f) }))
				{
					InsertTagAtCursor(text3);
				}
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
		}

		private static bool EndsWithBreakTag(string text, int endExclusive)
		{
			if (string.IsNullOrEmpty(text) || endExclusive <= 0)
			{
				return false;
			}
			if (endExclusive > text.Length)
			{
				endExclusive = text.Length;
			}
			if (text[endExclusive - 1] != '>')
			{
				return false;
			}
			int num = Math.Max(0, endExclusive - 12);
			int num2 = text.LastIndexOf('<', endExclusive - 1, endExclusive - num);
			if (num2 < 0)
			{
				return false;
			}
			return IsBreakTag(text.Substring(num2, endExclusive - num2));
		}

		private static void SyncEditorCaret()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (GUI.GetNameOfFocusedControl() != "Stitchwork.DialogueEditor.EditArea")
			{
				return;
			}
			TextEditor val = (TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), GUIUtility.keyboardControl);
			if (val != null)
			{
				if (_pendingCaret >= 0)
				{
					int num = (val.selectIndex = (val.cursorIndex = Mathf.Clamp(_pendingCaret, 0, editText.Length)));
					_pendingCaret = -1;
					lastCursorIndex = num;
				}
				else
				{
					lastCursorIndex = val.cursorIndex;
				}
			}
		}

		public static void Draw()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			if (!initialized || ((Rect)(ref windowRect)).width < 1f)
			{
				windowRect = GUIHelper.ScaledRectFromRight(10f, 10f, 520f, 500f);
				initialized = true;
			}
			Rect val = windowRect;
			object obj = <>O.<0>__DrawWindow;
			if (obj == null)
			{
				WindowFunction val2 = DrawWindow;
				<>O.<0>__DrawWindow = val2;
				obj = (object)val2;
			}
			windowRect = GUILayout.Window(6977, val, (WindowFunction)obj, "Stitchwork Dialogue Editor", GUIHelper.WindowStyle, GUIHelper.WindowLayout(520f, 500f));
		}

		public static void DrawEditorSurface()
		{
			DrawEditPane();
		}

		public static void TrackText(string sheet, string key, string text)
		{
			string key2 = sheet + "|" + key;
			if (EntryLookup.TryGetValue(key2, out var value))
			{
				value.CurrentText = text;
				value.LastSeen = DateTime.Now;
				return;
			}
			DialogueEntry dialogueEntry = new DialogueEntry
			{
				Sheet = sheet,
				Key = key,
				CurrentText = text,
				LastSeen = DateTime.Now
			};
			Entries.Add(dialogueEntry);
			EntryLookup[key2] = dialogueEntry;
		}

		public static void SelectEntry(string sheet, string key, string currentText = null)
		{
			string key2 = sheet + "|" + key;
			if (!EntryLookup.TryGetValue(key2, out var value))
			{
				value = new DialogueEntry
				{
					Sheet = sheet,
					Key = key,
					CurrentText = (currentText ?? ""),
					LastSeen = DateTime.Now
				};
				Entries.Add(value);
				EntryLookup[key2] = value;
			}
			selectedEntry = value;
			editText = SmartWrap(value.CurrentText);
			hasUnsavedChanges = false;
			searchText = "";
		}

		private static void DrawWindow(int windowID)
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_069b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			GUIHelper.Space(16f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(Loc.T("Search:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(55f) });
			searchText = GUIHelper.TextField("Stitchwork.DialogueEditor.Search", searchText, GUIHelper.Width(300f), GUIHelper.Height(24f));
			GUILayout.FlexibleSpace();
			if (GUILayout.Button(Loc.T("Clear"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				Entries.Clear();
				EntryLookup.Clear();
				selectedEntry = null;
				editText = "";
				hasUnsavedChanges = false;
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			List<DialogueEntry> list = (string.IsNullOrEmpty(searchText) ? Entries : Entries.Where((DialogueEntry e) => e.Key.ToLower().Contains(searchText.ToLower()) || e.Sheet.ToLower().Contains(searchText.ToLower()) || e.CurrentText.ToLower().Contains(searchText.ToLower())).ToList());
			GUILayout.Label(string.Format(Loc.T("{0} entries"), list.Count), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			entryListScroll = GUILayout.BeginScrollView(entryListScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GUIHelper.Scaled(180f)) });
			foreach (DialogueEntry item in list)
			{
				bool num = item == selectedEntry;
				string text = (num ? "▶ " : "  ");
				Dictionary<string, Dictionary<string, string>> value;
				Dictionary<string, string> value2;
				Color contentColor = (Color)((DialogueHandler.TextCache.TryGetValue(((object)Language.CurrentLanguage()/*cast due to .constrained prefix*/).ToString(), out value) && value.TryGetValue(item.Sheet, out value2) && value2.ContainsKey(item.Key)) ? new Color(0.5f, 1f, 0.5f) : Color.white);
				if (num)
				{
					((Color)(ref contentColor))..ctor(1f, 0.9f, 0.4f);
				}
				GUI.contentColor = contentColor;
				string text2 = item.CurrentText.Replace("\n", "\\n");
				if (text2.Length > 40)
				{
					text2 = text2.Substring(0, 37) + "...";
				}
				if (GUILayout.Button(text + item.Sheet + "." + item.Key + ": " + text2, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>()))
				{
					if (hasUnsavedChanges && selectedEntry != null)
					{
						_ = selectedEntry;
					}
					selectedEntry = item;
					editText = SmartWrap(item.CurrentText);
					hasUnsavedChanges = false;
				}
			}
			GUI.contentColor = Color.white;
			GUILayout.EndScrollView();
			GUIHelper.Space(6f);
			if (selectedEntry != null)
			{
				GUI.contentColor = new Color(0.6f, 0.85f, 1f);
				GUILayout.Label(string.Format(Loc.T("Sheet: {0}  |  Key: {1}"), selectedEntry.Sheet, selectedEntry.Key), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				GUIHelper.Space(2f);
				editAreaScroll = GUILayout.BeginScrollView(editAreaScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GUIHelper.Scaled(140f)) });
				string text3 = GUIHelper.TextArea("Stitchwork.DialogueEditor.EditArea", editText, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
				if (text3 != editText)
				{
					editText = text3;
					hasUnsavedChanges = true;
				}
				SyncEditorCaret();
				GUILayout.EndScrollView();
				GUI.contentColor = GUIHelper.ColMuted;
				GUILayout.Label("Tip: line breaks are display-only; stripped on save. Use <br>/<page> tags for real breaks.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				GUIHelper.Space(4f);
				DrawTagRow();
				GUIHelper.Space(4f);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string text4 = selectedEntry.Sheet + "|" + selectedEntry.Key;
				bool flag = _deleteArmedKey == text4 && Time.realtimeSinceStartup - _deleteArmTime < 3f;
				Color backgroundColor = GUI.backgroundColor;
				GUI.backgroundColor = GUIHelper.ColDanger;
				if (GUILayout.Button(flag ? Loc.T("Confirm Delete?") : Loc.T("Delete Override"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(150f)
				}))
				{
					if (flag)
					{
						DeleteOverride(selectedEntry);
						_deleteArmedKey = null;
					}
					else
					{
						_deleteArmedKey = text4;
						_deleteArmTime = Time.realtimeSinceStartup;
					}
				}
				GUI.backgroundColor = backgroundColor;
				GUILayout.FlexibleSpace();
				if (GUILayout.Button(Loc.T("Revert"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(90f)
				}))
				{
					editText = SmartWrap(selectedEntry.CurrentText);
					hasUnsavedChanges = false;
					_deleteArmedKey = null;
				}
				GUI.backgroundColor = GUIHelper.ColConfirm;
				if (GUILayout.Button(hasUnsavedChanges ? (Loc.T("Save") + " *") : Loc.T("Save"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(90f)
				}))
				{
					SaveEntry(selectedEntry, editText);
					_deleteArmedKey = null;
				}
				GUI.backgroundColor = backgroundColor;
				GUILayout.EndHorizontal();
				if (!string.IsNullOrEmpty(statusMessage) && Time.realtimeSinceStartup - statusTime < 4f)
				{
					GUIHelper.Space(2f);
					GUI.contentColor = (statusMessage.StartsWith("Error") ? new Color(1f, 0.4f, 0.4f) : new Color(0.4f, 1f, 0.4f));
					GUILayout.Label(statusMessage, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
					GUI.contentColor = Color.white;
				}
			}
			else
			{
				GUIHelper.Space(8f);
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label(Loc.T("Select a text entry above to edit it.\nEntries appear as the game requests dialogue text."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUI.DragWindow(GUIHelper.DragRect);
		}

		private static void DrawEditPane()
		{
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			if (selectedEntry != null)
			{
				GUI.contentColor = new Color(0.6f, 0.85f, 1f);
				GUILayout.Label(string.Format(Loc.T("Sheet: {0}  |  Key: {1}"), selectedEntry.Sheet, selectedEntry.Key), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				GUIHelper.Space(2f);
				editAreaScroll = GUILayout.BeginScrollView(editAreaScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GUIHelper.Scaled(140f)) });
				string text = GUIHelper.TextArea("Stitchwork.DialogueEditor.EditArea", editText, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true));
				if (text != editText)
				{
					editText = text;
					hasUnsavedChanges = true;
				}
				SyncEditorCaret();
				GUILayout.EndScrollView();
				GUI.contentColor = GUIHelper.ColMuted;
				GUILayout.Label("Tip: line breaks are display-only; stripped on save. Use <br>/<page> tags for real breaks.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				GUIHelper.Space(4f);
				DrawTagRow();
				GUIHelper.Space(4f);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				bool flag = _deleteArmedAt > 0f && Time.realtimeSinceStartup - _deleteArmedAt < 3f;
				if (!flag)
				{
					_deleteArmedAt = -1f;
				}
				Color backgroundColor = GUI.backgroundColor;
				GUI.backgroundColor = (flag ? GUIHelper.ColWarn : Color.Lerp(backgroundColor, GUIHelper.ColWarn, 0.35f));
				if (GUILayout.Button(flag ? Loc.T("Delete? click again") : Loc.T("Delete Override"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(150f)
				}))
				{
					if (flag)
					{
						DeleteOverride(selectedEntry);
						_deleteArmedAt = -1f;
					}
					else
					{
						_deleteArmedAt = Time.realtimeSinceStartup;
					}
				}
				GUI.backgroundColor = backgroundColor;
				GUILayout.FlexibleSpace();
				if (GUILayout.Button(Loc.T("Revert"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(90f)
				}))
				{
					editText = SmartWrap(selectedEntry.CurrentText);
					hasUnsavedChanges = false;
				}
				GUIHelper.Space(6f);
				GUI.backgroundColor = (hasUnsavedChanges ? GUIHelper.ColConfirm : backgroundColor);
				if (GUILayout.Button(hasUnsavedChanges ? (Loc.T("Save") + " *") : Loc.T("Save"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(90f)
				}))
				{
					SaveEntry(selectedEntry, editText);
				}
				GUI.backgroundColor = backgroundColor;
				GUILayout.EndHorizontal();
				if (!string.IsNullOrEmpty(statusMessage) && Time.realtimeSinceStartup - statusTime < 4f)
				{
					GUIHelper.Space(2f);
					GUI.contentColor = (statusMessage.StartsWith("Error") ? new Color(1f, 0.4f, 0.4f) : new Color(0.4f, 1f, 0.4f));
					GUILayout.Label(statusMessage, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
					GUI.contentColor = Color.white;
				}
			}
			else
			{
				GUIHelper.Space(8f);
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label(Loc.T("Click a text entry on the left to edit it."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
		}

		private static void SaveEntry(DialogueEntry entry, string text)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string text2 = StripSoftWraps(text);
				string text3 = ((object)Language.CurrentLanguage()/*cast due to .constrained prefix*/).ToString();
				string text4 = Path.Combine(DialogueHandler.TextLoadPath, entry.Sheet);
				IOUtil.EnsureDirectoryExists(text4);
				string path = Path.Combine(text4, text3 + ".yml");
				List<string> list = new List<string>();
				bool flag = false;
				string text5 = "\"" + text2.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
				if (File.Exists(path))
				{
					string[] array = File.ReadAllLines(path);
					foreach (string text6 in array)
					{
						if (!text6.StartsWith("#") && !string.IsNullOrWhiteSpace(text6))
						{
							int num = text6.IndexOf(':');
							if (num != -1 && text6.Substring(0, num).Trim() == entry.Key)
							{
								list.Add(entry.Key + ": " + text5);
								flag = true;
								continue;
							}
						}
						list.Add(text6);
					}
				}
				if (!flag)
				{
					list.Add(entry.Key + ": " + text5);
				}
				File.WriteAllLines(path, list);
				DialogueHandler.InvalidateCache(entry.Sheet, text3);
				Language.SwitchLanguage(text3);
				entry.CurrentText = text2;
				hasUnsavedChanges = false;
				SetStatus("Saved " + entry.Sheet + "." + entry.Key + " — re-trigger dialogue to see");
				Plugin.Logger.LogInfo((object)("[Stitchwork] Dialogue editor saved: " + entry.Sheet + "." + entry.Key + " (" + text3 + ")"));
			}
			catch (Exception ex)
			{
				SetStatus("Error: " + ex.Message);
				Plugin.Logger.LogError((object)$"[Stitchwork] Dialogue editor save failed: {ex}");
			}
		}

		private static void DeleteOverride(DialogueEntry entry)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string text = ((object)Language.CurrentLanguage()/*cast due to .constrained prefix*/).ToString();
				string path = Path.Combine(DialogueHandler.TextLoadPath, entry.Sheet, text + ".yml");
				if (!File.Exists(path))
				{
					SetStatus("No override file exists");
					return;
				}
				List<string> list = File.ReadAllLines(path).ToList();
				bool flag = false;
				for (int num = list.Count - 1; num >= 0; num--)
				{
					if (!list[num].StartsWith("#") && !string.IsNullOrWhiteSpace(list[num]))
					{
						int num2 = list[num].IndexOf(':');
						if (num2 != -1 && list[num].Substring(0, num2).Trim() == entry.Key)
						{
							list.RemoveAt(num);
							flag = true;
						}
					}
				}
				if (!flag)
				{
					SetStatus("Key not found in override file");
					return;
				}
				if (list.Any((string l) => !l.StartsWith("#") && !string.IsNullOrWhiteSpace(l)))
				{
					File.WriteAllLines(path, list);
				}
				else
				{
					File.Delete(path);
				}
				DialogueHandler.InvalidateCache(entry.Sheet, text);
				Language.SwitchLanguage(text);
				SetStatus("Deleted override for " + entry.Sheet + "." + entry.Key + " — re-trigger dialogue to see");
				Plugin.Logger.LogInfo((object)("[Stitchwork] Dialogue editor deleted override: " + entry.Sheet + "." + entry.Key + " (" + text + ")"));
			}
			catch (Exception ex)
			{
				SetStatus("Error: " + ex.Message);
				Plugin.Logger.LogError((object)$"[Stitchwork] Dialogue editor delete failed: {ex}");
			}
		}

		private static void SetStatus(string msg)
		{
			statusMessage = msg;
			statusTime = Time.realtimeSinceStartup;
		}
	}
	internal static class DumpProgressOverlay
	{
		private static Texture2D _fill;

		private static GUIStyle _title;

		private static GUIStyle _detail;

		private static Texture2D Fill
		{
			get
			{
				//IL_000f: 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: Expected O, but got Unknown
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_fill == (Object)null)
				{
					_fill = new Texture2D(1, 1)
					{
						hideFlags = (HideFlags)32
					};
					_fill.SetPixel(0, 0, Color.white);
					_fill.Apply();
				}
				return _fill;
			}
		}

		public static void Draw()
		{
			if (SceneTraverser.IsTraversing)
			{
				int total = SceneTraverser.Total;
				int processed = SceneTraverser.Processed;
				float frac = ((total > 0) ? Mathf.Clamp01((float)processed / (float)total) : 0f);
				float num = (Time.realtimeSinceStartup - SceneTraverser.StartedAt) / 60f;
				string text = SceneTraverser.CurrentScene;
				if (!string.IsNullOrEmpty(SceneTraverser.SubProgress))
				{
					text = text + "   ·   " + string.Format(Loc.T("collections {0}"), SceneTraverser.SubProgress);
				}
				DrawPanel(string.Format(Loc.T("Full dump: scene {0}/{1} · {2:F1} min"), processed, total, num), frac, text);
			}
			else if (AnimCanvasBatch.IsRunning)
			{
				float frac2 = ((AnimCanvasBatch.Total > 0) ? Mathf.Clamp01((float)AnimCanvasBatch.Processed / (float)AnimCanvasBatch.Total) : 0f);
				float num2 = (Time.realtimeSinceStartup - AnimCanvasBatch.StartedAt) / 60f;
				string titleText = string.Format((AnimCanvasBatch.Mode == AnimCanvasBatch.BatchMode.Extract) ? Loc.T("Canvas extract: clip {0}/{1} · {2:F1} min") : Loc.T("Canvas compile: clip {0}/{1} · {2:F1} min"), AnimCanvasBatch.Processed, AnimCanvasBatch.Total, num2);
				string text2 = AnimCanvasBatch.CurrentClip;
				if (AnimCanvasBatch.Skipped > 0 || AnimCanvasBatch.Failed > 0)
				{
					text2 += $"   ·   {AnimCanvasBatch.Ok} ok / {AnimCanvasBatch.Skipped} skipped / {AnimCanvasBatch.Failed} failed";
				}
				DrawPanel(titleText, frac2, text2);
			}
			else if (SpriteLoader.IsReloadingSliced)
			{
				float frac3 = ((SpriteLoader.SlicedTotal > 0) ? Mathf.Clamp01((float)SpriteLoader.SlicedProcessed / (float)SpriteLoader.SlicedTotal) : 0f);
				float num3 = Time.realtimeSinceStartup - SpriteLoader.SlicedStartedAt;
				DrawPanel(string.Format(Loc.T("Applying sprites: {0}/{1} · {2:F1} s"), SpriteLoader.SlicedProcessed, SpriteLoader.SlicedTotal, num3), frac3, SpriteLoader.SlicedCurrent);
			}
		}

		private static void DrawPanel(string titleText, float frac, string detail)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			EnsureStyles();
			float num = GUIHelper.Scaled(480f);
			float num2 = GUIHelper.Scaled(74f);
			float num3 = ((float)Screen.width - num) * 0.5f;
			float num4 = GUIHelper.Scaled(16f);
			float num5 = GUIHelper.Scaled(10f);
			GUI.color = new Color(0.05f, 0.05f, 0.06f, 0.88f);
			GUI.DrawTexture(new Rect(num3, num4, num, num2), (Texture)(object)Fill);
			GUI.color = GUIHelper.ColBorderHi;
			GUI.DrawTexture(new Rect(num3, num4, num, 1f), (Texture)(object)Fill);
			GUI.DrawTexture(new Rect(num3, num4 + num2 - 1f, num, 1f), (Texture)(object)Fill);
			GUI.color = Color.white;
			GUI.Label(new Rect(num3 + num5, num4 + GUIHelper.Scaled(6f), num - 2f * num5, GUIHelper.Scaled(20f)), titleText, _title);
			float num6 = num4 + GUIHelper.Scaled(30f);
			float num7 = GUIHelper.Scaled(10f);
			GUI.color = GUIHelper.ColBorder;
			GUI.DrawTexture(new Rect(num3 + num5, num6, num - 2f * num5, num7), (Texture)(object)Fill);
			GUI.color = GUIHelper.ColConfirm;
			GUI.DrawTexture(new Rect(num3 + num5, num6, (num - 2f * num5) * frac, num7), (Texture)(object)Fill);
			GUI.color = Color.white;
			GUI.contentColor = GUIHelper.ColMuted;
			GUI.Label(new Rect(num3 + num5, num6 + num7 + GUIHelper.Scaled(4f), num - 2f * num5, GUIHelper.Scaled(20f)), detail, _detail);
			GUI.contentColor = Color.white;
		}

		private static void EnsureStyles()
		{
			//IL_002e: 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)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			int num = GUIHelper.FontSize();
			int num2 = GUIHelper.FontSize(12);
			if (_title == null || _title.fontSize != num)
			{
				_title = new GUIStyle(GUI.skin.label)
				{
					fontSize = num,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4
				};
			}
			if (_detail == null || _detail.fontSize != num2)
			{
				_detail = new GUIStyle(GUI.skin.label)
				{
					fontSize = num2,
					alignment = (TextAnchor)4
				};
			}
		}
	}
	public static class FabricUI
	{
		private static Canvas _rootCanvas;

		private static CanvasScaler _scaler;

		private static GameObject _rootGO;

		private static EventSystem _eventSystem;

		private static Font _font;

		private static readonly Dictionary<(int, int), Sprite> _roundedSpriteCache = new Dictionary<(int, int), Sprite>();

		private static readonly Dictionary<(int, int, int), Sprite> _borderSpriteCache = new Dictionary<(int, int, int), Sprite>();

		private static EventSystem _previousEventSystem;

		public static Canvas RootCanvas
		{
			get
			{
				if (!((Object)(object)_rootCanvas != (Object)null))
				{
					return Init();
				}
				return _rootCanvas;
			}
		}

		public static Font GameFont
		{
			get
			{
				if ((Object)(object)_font == (Object)null)
				{
					_font = FindGameFont();
				}
				return _font;
			}
		}

		public static bool IsReady => (Object)(object)_rootCanvas != (Object)null;

		public static Canvas Init()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if ((Object)(object)_rootCanvas != (Object)null)
			{
				return _rootCanvas;
			}
			_font = FindGameFont();
			_rootGO = new GameObject("StitchworkCanvas");
			Object.DontDestroyOnLoad((Object)(object)_rootGO);
			_rootCanvas = _rootGO.AddComponent<Canvas>();
			_rootCanvas.renderMode = (RenderMode)0;
			_rootCanvas.sortingOrder = 100;
			_rootCanvas.pixelPerfect = false;
			_scaler = _rootGO.AddComponent<CanvasScaler>();
			_scaler.uiScaleMode = (ScaleMode)0;
			_scaler.scaleFactor = 1f;
			_rootGO.AddComponent<GraphicRaycaster>();
			EnsureEventSystem();
			return _rootCanvas;
		}

		private static Font FindGameFont()
		{
			try
			{
				Font[] array = Resources.FindObjectsOfTypeAll<Font>();
				Font[] array2 = array;
				foreach (Font val in array2)
				{
					if (!((Object)(object)val == (Object)null) && ((Object)val).name.ToUpperInvariant().Contains("ARIAL"))
					{
						return val;
					}
				}
				array2 = array;
				foreach (Font val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[FabricUI] Font search failed: " + ex.Message));
			}
			return Font.CreateDynamicFontFromOSFont("Arial", 14);
		}

		private static void EnsureEventSystem()
		{
			//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_001e: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_eventSystem != (Object)null))
			{
				GameObject val = new GameObject("StitchworkEventSystem");
				Object.DontDestroyOnLoad((Object)val);
				_eventSystem = val.AddComponent<EventSystem>();
				val.AddComponent<StandaloneInputModule>();
				val.SetActive(false);
			}
		}

		internal static void MakeEventSystemCurrent()
		{
			EnsureEventSystem();
			if (!((Object)(object)_eventSystem == (Object)null))
			{
				((Component)_eventSystem).gameObject.SetActive(true);
				EventSystem current = EventSystem.current;
				if ((Object)(object)current != (Object)null && (Object)(object)current != (Object)(object)_eventSystem)
				{
					_previousEventSystem = current;
				}
				EventSystem.current = _eventSystem;
			}
		}

		internal static void RestoreEventSystem()
		{
			if ((Object)(object)_previousEventSystem != (Object)null && (Object)(object)EventSystem.current == (Object)(object)_eventSystem)
			{
				EventSystem.current = _previousEventSystem;
			}
			_previousEventSystem = null;
			if ((Object)(object)_eventSystem != (Object)null)
			{
				_eventSystem.SetSelectedGameObject((GameObject)null);
				((Component)_eventSystem).gameObject.SetActive(false);
			}
		}

		public static float S(float v)
		{
			return v * GUIHelper.Scale;
		}

		public static int SI(float v)
		{
			return Mathf.RoundToInt(v * GUIHelper.Scale);
		}

		public static int FontSize(int baseSize)
		{
			return Mathf.Max(8, SI(baseSize));
		}

		public static RectTransform SetStretch(RectTransform rt, float left = 0f, float right = 0f, float top = 0f, float bottom = 0f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = new Vector2(left, bottom);
			rt.offsetMax = new Vector2(0f - right, 0f - top);
			return rt;
		}

		public static RectTransform SetStretchLeft(RectTransform rt, float width, float top = 0f, float bottom = 0f, float left = 0f)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0f, 0f);
			rt.anchorMax = new Vector2(0f, 1f);
			rt.pivot = new Vector2(0f, 0.5f);
			rt.offsetMin = new Vector2(left, bottom);
			rt.offsetMax = new Vector2(left + width, 0f - top);
			return rt;
		}

		public static GameObject CreatePanel(Transform parent, string name, Color color)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = true;
			return val;
		}

		public static GameObject CreateText(Transform parent, string name, string text, int baseFontSize = 14, Color? color = null, TextAnchor alignment = (TextAnchor)3)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			Text obj = val.AddComponent<Text>();
			obj.text = text;
			obj.font = GameFont;
			obj.fontSize = FontSize(baseFontSize);
			((Graphic)obj).color = (Color)(((??)color) ?? Color.white);
			obj.alignment = alignment;
			obj.horizontalOverflow = (HorizontalWrapMode)1;
			obj.verticalOverflow = (VerticalWrapMode)1;
			((Graphic)obj).raycastTarget = false;
			return val;
		}

		public static GameObject CreateButton(Transform parent, string name, string text, Action onClick, Color? bgColor = null, Color? textColor = null, Color? borderColor = null)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00c9: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			Color color = (Color)(((??)bgColor) ?? GUIHelper.ColSurface2);
			Color value = (Color)(((??)textColor) ?? GUIHelper.ColText);
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			val2.sprite = CreateRoundedSprite(SI(4f), SI(16f));
			val2.type = (Type)1;
			((Graphic)val2).color = color;
			((Graphic)val2).raycastTarget = true;
			AddBorder(val, (Color)(((??)borderColor) ?? GUIHelper.ColBorderHi));
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			((Selectable)val3).transition = (Transition)1;
			ColorBlock colors = ((Selectable)val3).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.3f, 1.3f, 1.3f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.8f, 0.8f, 0.8f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)val3).colors = colors;
			if (onClick != null)
			{
				((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
			}
			GameObject obj = CreateText(val.transform, name + "_Text", text, 14, value, (TextAnchor)4);
			SetStretch(obj.GetComponent<RectTransform>());
			((Graphic)obj.GetComponent<Text>()).raycastTarget = false;
			return val;
		}

		public static GameObject CreateInputField(Transform parent, string name, string placeholder = "", Action<string> onChange = null)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(GUIHelper.ColSurface.r * 1.4f, GUIHelper.ColSurface.g * 1.4f, GUIHelper.ColSurface.b * 1.4f, 1f);
			((Graphic)val2).raycastTarget = true;
			GameObject val3 = new GameObject(name + "_TextArea", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			SetStretch(val3.GetComponent<RectTransform>(), S(6f), S(6f), S(2f), S(2f));
			val3.AddComponent<RectMask2D>();
			GameObject val4 = new GameObject(name + "_ChildText", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(val3.transform, false);
			Text val5 = val4.AddComponent<Text>();
			val5.font = GameFont;
			val5.fontSize = FontSize(13);
			((Graphic)val5).color = Color.white;
			val5.alignment = (TextAnchor)3;
			val5.horizontalOverflow = (HorizontalWrapMode)1;
			val5.verticalOverflow = (VerticalWrapMode)1;
			val5.supportRichText = false;
			SetStretch(val4.GetComponent<RectTransform>());
			GameObject val6 = new GameObject(name + "_Placeholder", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(val3.transform, false);
			Text val7 = val6.AddComponent<Text>();
			val7.font = GameFont;
			val7.fontSize = FontSize(13);
			((Graphic)val7).color = GUIHelper.ColMuted;
			val7.alignment = (TextAnchor)3;
			val7.horizontalOverflow = (HorizontalWrapMode)1;
			val7.verticalOverflow = (VerticalWrapMode)1;
			val7.fontStyle = (FontStyle)2;
			val7.text = placeholder;
			SetStretch(val6.GetComponent<RectTransform>());
			InputField val8 = val.AddComponent<InputField>();
			((Selectable)val8).targetGraphic = (Graphic)(object)val2;
			val8.textComponent = val5;
			val8.placeholder = (Graphic)(object)val7;
			val8.caretColor = GUIHelper.ColAccent;
			val8.selectionColor = new Color(GUIHelper.ColAccent.r, GUIHelper.ColAccent.g, GUIHelper.ColAccent.b, 0.3f);
			val8.characterLimit = 0;
			if (onChange != null)
			{
				((UnityEvent<string>)(object)val8.onValueChanged).AddListener((UnityAction<string>)delegate(string obj)
				{
					onChange(obj);
				});
			}
			return val;
		}

		public static GameObject CreateScrollView(Transform parent, string name)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Expected O, but got Unknown
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			ScrollRect val2 = val.AddComponent<ScrollRect>();
			((Graphic)val.AddComponent<Image>()).color = Color.clear;
			GameObject val3 = new GameObject(name + "_Viewport", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			((Graphic)val3.AddComponent<Image>()).color = Color.clear;
			val3.AddComponent<RectMask2D>();
			RectTransform component = val3.GetComponent<RectTransform>();
			SetStretch(component, 0f, S(8f));
			GameObject val4 = new GameObject(name + "_Content", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(val3.transform, false);
			RectTransform component2 = val4.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(0f, 1f);
			component2.anchoredPosition = Vector2.zero;
			component2.sizeDelta = new Vector2(0f, 0f);
			ContentSizeFitter obj = val4.AddComponent<ContentSizeFitter>();
			obj.verticalFit = (FitMode)2;
			obj.horizontalFit = (FitMode)0;
			VerticalLayoutGroup obj2 = val4.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = S(3f);
			((LayoutGroup)obj2).padding = new RectOffset(SI(4f), SI(10f), SI(4f), SI(4f));
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			GameObject val5 = new GameObject(name + "_Scrollbar", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent(val.transform, false);
			((Graphic)val5.AddComponent<Image>()).color = new Color(GUIHelper.ColSurface.r, GUIHelper.ColSurface.g, GUIHelper.ColSurface.b, 0.5f);
			RectTransform component3 = val5.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(1f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(1f, 0.5f);
			component3.sizeDelta = new Vector2(S(6f), 0f);
			component3.anchoredPosition = Vector2.zero;
			GameObject val6 = new GameObject(name + "_HandleArea", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(val5.transform, false);
			SetStretch(val6.GetComponent<RectTransform>());
			GameObject val7 = new GameObject(name + "_Handle", new Type[1] { typeof(RectTransform) });
			val7.transform.SetParent(val6.transform, false);
			Image val8 = val7.AddComponent<Image>();
			((Graphic)val8).color = GUIHelper.ColBorder;
			SetStretch(val7.GetComponent<RectTransform>());
			Scrollbar val9 = val5.AddComponent<Scrollbar>();
			val9.handleRect = val7.GetComponent<RectTransform>();
			((Selectable)val9).targetGraphic = (Graphic)(object)val8;
			val9.direction = (Direction)2;
			val2.viewport = component;
			val2.content = component2;
			val2.verticalScrollbar = val9;
			val2.verticalScrollbarVisibility = (ScrollbarVisibility)2;
			val2.horizontal = false;
			val2.vertical = true;
			val2.movementType = (MovementType)2;
			val2.scrollSensitivity = S(30f);
			return val;
		}

		public static GameObject CreateHorizontalGroup(Transform parent, string name, float spacing = 0f, RectOffset padding = null)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = S(spacing);
			((LayoutGroup)obj).padding = (RectOffset)(((object)padding) ?? ((object)new RectOffset(0, 0, 0, 0)));
			((LayoutGroup)obj).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			return val;
		}

		public static GameObject CreateVerticalGroup(Transform parent, string name, float spacing = 0f, RectOffset padding = null)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = S(spacing);
			((LayoutGroup)obj).padding = (RectOffset)(((object)padding) ?? ((object)new RectOffset(0, 0, 0, 0)));
			((LayoutGroup)obj).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			return val;
		}

		public static Sprite CreateRoundedSprite(int radius, int size)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			(int, int) key = (radius, size);
			if (_roundedSpriteCache.TryGetValue(key, out var value))
			{
				return value;
			}
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false);
			((Object)val).hideFlags = (HideFlags)32;
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color[] array = (Color[])(object)new Color[size * size];
			float num = radius;
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num2 = 1f;
					if ((float)j < num && (float)i < num)
					{
						num2 = CornerAlpha(j, i, num);
					}
					else if ((float)j > (float)(size - 1) - num && (float)i < num)
					{
						num2 = CornerAlpha(size - 1 - j, i, num);
					}
					else if ((float)j < num && (float)i > (float)(size - 1) - num)
					{
						num2 = CornerAlpha(j, size - 1 - i, num);
					}
					else if ((float)j > (float)(size - 1) - num && (float)i > (float)(size - 1) - num)
					{
						num2 = CornerAlpha(size - 1 - j, size - 1 - i, num);
					}
					array[i * size + j] = new Color(1f, 1f, 1f, num2);
				}
			}
			val.SetPixels(array);
			val.Apply();
			Vector4 val2 = default(Vector4);
			((Vector4)(ref val2))..ctor((float)radius, (float)radius, (float)radius, (float)radius);
			Sprite val3 = Sprite.Create(val, new Rect(0f, 0f, (float)size, (float)size), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, val2);
			((Object)val3).hideFlags = (HideFlags)32;
			_roundedSpriteCache[key] = val3;
			return val3;
		}

		private static float CornerAlpha(float px, float py, float r)
		{
			float num = r - px;
			float num2 = r - py;
			float num3 = Mathf.Sqrt(num * num + num2 * num2);
			return Mathf.Clamp01(r - num3 + 0.5f);
		}

		public static Sprite CreateBorderSprite(int radius, int thickness, int size)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			(int, int, int) key = (radius, thickness, size);
			if (_borderSpriteCache.TryGetValue(key, out var value))
			{
				return value;
			}
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false);
			((Object)val).hideFlags = (HideFlags)32;
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color[] array = (Color[])(object)new Color[size * size];
			float half = (float)(size - 1) * 0.5f;
			float r = radius;
			float r2 = Mathf.Max((float)(radius - thickness), 0f);
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num = Mathf.Clamp01(0.5f - RoundedRectSDF(j, i, half, half, r));
					float num2 = Mathf.Clamp01(0.5f - RoundedRectSDF(j, i, half - (float)thickness, half - (float)thickness, r2));
					array[i * size + j] = new Color(1f, 1f, 1f, Mathf.Clamp01(num - num2));
				}
			}
			val.SetPixels(array);
			val.Apply();
			int num3 = Mathf.Max(radius, thickness) + 1;
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)size, (float)size), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4((float)num3, (float)num3, (float)num3, (float)num3));
			((Object)val2).hideFlags = (HideFlags)32;
			_borderSpriteCache[key] = val2;
			return val2;
			float RoundedRectSDF(float px, float py, float hw, float hh, float num5)
			{
				float num4 = Mathf.Abs(px - half) - (hw - num5);
				float num6 = Mathf.Abs(py - half) - (hh - num5);
				float num7 = Mathf.Max(num4, 0f);
				float num8 = Mathf.Max(num6, 0f);
				float num9 = Mathf.Sqrt(num7 * num7 + num8 * num8);
				float num10 = Mathf.Min(Mathf.Max(num4, num6), 0f);
				return num9 + num10 - num5;
			}
		}

		public static Image AddBorder(GameObject go, Color color, int baseRadius = 4, int baseThickness = 1)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(((Object)go).name + "_Border", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(go.transform, false);
			Image obj = val.AddComponent<Image>();
			obj.sprite = CreateBorderSprite(SI(baseRadius), Mathf.Max(SI(baseThickness), 1), SI(24f));
			obj.type = (Type)1;
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = false;
			SetStretch(val.GetComponent<RectTransform>());
			AddLayout(val, -1f, -1f, -1f, -1f, -1f, -1f, ignoreLayout: true);
			return obj;
		}

		public static LayoutElement AddLayout(GameObject go, float preferredWidth = -1f, float preferredHeight = -1f, float minWidth = -1f, float minHeight = -1f, float flexibleWidth = -1f, float flexibleHeight = -1f, bool ignoreLayout = false)
		{
			LayoutElement val = go.GetComponent<LayoutElement>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<LayoutElement>();
			}
			if (preferredWidth >= 0f)
			{
				val.preferredWidth = preferredWidth;
			}
			if (preferredHeight >= 0f)
			{
				val.preferredHeight = preferredHeight;
			}
			if (minWidth >= 0f)
			{
				val.minWidth = minWidth;
			}
			if (minHeight >= 0f)
			{
				val.minHeight = minHeight;
			}
			if (flexibleWidth >= 0f)
			{
				val.flexibleWidth = flexibleWidth;
			}
			if (flexibleHeight >= 0f)
			{
				val.flexibleHeight = flexibleHeight;
			}
			val.ignoreLayout = ignoreLayout;
			return val;
		}

		public static GameObject CreateSeparator(Transform parent, string name = "Separator")
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreatePanel(parent, name, new Color(GUIHelper.ColBorder.r, GUIHelper.ColBorder.g, GUIHelper.ColBorder.b, 0.6f));
			AddLayout(obj, -1f, S(1f), -1f, -1f, 1f);
			return obj;
		}

		public static ContentSizeFitter AddFitter(GameObject go, FitMode horizontal = (FitMode)0, FitMode vertical = (FitMode)2)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ContentSizeFitter val = go.GetComponent<ContentSizeFitter>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<ContentSizeFitter>();
			}
			val.horizontalFit = horizontal;
			val.verticalFit = vertical;
			return val;
		}

		public static GameObject CreateSwitch(Transform parent, string name, bool isOn, Action onClick)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			float num = S(36f);
			float preferredHeight = S(19f);
			float num2 = S(14f);
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			val2.sprite = CreateRoundedSprite(SI(9.5f), SI(20f));
			val2.type = (Type)1;
			((Graphic)val2).color = (isOn ? new Color(GUIHelper.ColConfirm.r * 0.86f, GUIHelper.ColConfirm.g * 0.86f, GUIHelper.ColConfirm.b * 0.86f, 1f) : new Color(0.227f, 0.227f, 0.247f, 1f));
			((Graphic)val2).raycastTarget = true;
			AddBorder(val, new Color(1f, 1f, 1f, 0.14f), 9).sprite = CreateBorderSprite(SI(9.5f), Mathf.Max(SI(1f), 1), SI(24f));
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			((Selectable)val3).transition = (Transition)1;
			ColorBlock colors = ((Selectable)val3).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.15f, 1.15f, 1.15f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.85f, 0.85f, 0.85f, 1f);
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)val3).colors = colors;
			if (onClick != null)
			{
				((UnityEvent)val3.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
			}
			GameObject val4 = new GameObject(name + "_Knob", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(val.transform, false);
			Image obj = val4.AddComponent<Image>();
			obj.sprite = CreateRoundedSprite(SI(7f), SI(14f));
			obj.type = (Type)1;
			((Graphic)obj).color = (isOn ? GUIHelper.ColText : GUIHelper.ColFaint);
			((Graphic)obj).raycastTarget = false;
			RectTransform component = val4.GetComponent<RectTransform>();
			Vector2 val5 = default(Vector2);
			((Vector2)(ref val5))..ctor(isOn ? 1f : 0f, 0.5f);
			component.anchorMax = val5;
			component.anchorMin = val5;
			component.pivot = new Vector2(isOn ? 1f : 0f, 0.5f);
			component.anchoredPosition = new Vector2(isOn ? (0f - S(2.5f)) : S(2.5f), 0f);
			component.sizeDelta = new Vector2(num2, num2);
			float minWidth = num;
			AddLayout(val, num, preferredHeight, minWidth);
			return val;
		}

		public static void ClearChildren(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)parent.GetChild(num)).gameObject);
			}
		}
	}
	public static class FlagEditorPanel
	{
		private static Vector2 _scroll;

		private static string _filter = "";

		private static bool _storyOnly = true;

		private static string _openEnumField;

		private static readonly Dictionary<string, string> _edit = new Dictionary<string, string>();

		public static void DrawSurface()
		{
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(string.Format(Loc.T("Changed: {0}"), DialogueFlagTracker.Count), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(86f) });
			_filter = GUIHelper.TextField("FlagEditor.Filter", _filter, GUILayout.ExpandWidth(true));
			_storyOnly = GUIHelper.ToggleButton(_storyOnly, Loc.T("Story flags"), GUIHelper.Width(100f), GUIHelper.Height(22f));
			if (GUILayout.Button(Loc.T("Reset all"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(78f),
				GUIHelper.Height(22f)
			}))
			{
				DialogueFlagTracker.RevertAll();
			}
			if (GUILayout.Button(Loc.T("Clear"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(52f),
				GUIHelper.Height(22f)
			}))
			{
				DialogueFlagTracker.ClearLog();
				_edit.Clear();
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(2f);
			List<FlagChange> list = (from c in DialogueFlagTracker.Changes.Values
				where !_storyOnly || c.Story
				where string.IsNullOrEmpty(_filter) || c.Name.IndexOf(_filter, StringComparison.OrdinalIgnoreCase) >= 0
				orderby c.LastChange descending
				select c).ToList();
			_scroll = GUILayout.BeginScrollView(_scroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			if (list.Count == 0)
			{
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label((DialogueFlagTracker.Count == 0) ? Loc.T("No PlayerData flags changed yet. First-meetings, story beats and quest steps set flags — repeatable greetings usually set none.") : (_storyOnly ? Loc.T("No story/NPC flags changed. Untick \"Story flags\" to see all changes.") : Loc.T("No rows match the current filter.")), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			foreach (FlagChange item in list)
			{
				DrawRow(item);
			}
			GUILayout.EndScrollView();
		}

		private static void DrawRow(FlagChange c)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = !object.Equals(c.Current, c.Original);
			bool story = c.Story;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = (flag ? new Color(1f, 0.85f, 0.4f) : (story ? new Color(0.55f, 0.85f, 1f) : new Color(0.6f, 0.6f, 0.6f)));
			GUILayout.Label(c.Name, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.contentColor = Color.white;
			GUILayout.Label(string.Format(Loc.T("orig: {0}"), c.Original), GUIHelper.MutedLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(120f) });
			switch (c.Kind)
			{
			case FlagKind.Bool:
			{
				object current = c.Current;
				bool flag3 = default(bool);
				int num;
				if (current is bool)
				{
					flag3 = (bool)current;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool flag4 = (byte)((uint)num & (flag3 ? 1u : 0u)) != 0;
				if (GUILayout.Button(flag4 ? "● True" : "○ False", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(92f),
					GUIHelper.Height(22f)
				}))
				{
					DialogueFlagTracker.TrySet(c.Name, c.Kind, !flag4);
				}
				break;
			}
			case FlagKind.Int:
			case FlagKind.String:
			{
				if (!_edit.TryGetValue(c.Name, out var value))
				{
					value = c.Current?.ToString() ?? "";
				}
				value = GUIHelper.TextField("FlagEditor.v." + c.Name, value, GUIHelper.Width(90f));
				_edit[c.Name] = value;
				if (GUILayout.Button(Loc.T("Set"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(44f),
					GUIHelper.Height(22f)
				}))
				{
					if (c.Kind == FlagKind.Int && int.TryParse(value, out var result))
					{
						DialogueFlagTracker.TrySet(c.Name, c.Kind, result);
					}
					else if (c.Kind == FlagKind.String)
					{
						DialogueFlagTracker.TrySet(c.Name, c.Kind, value);
					}
				}
				GUI.enabled = flag;
				if (GUILayout.Button("↺", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(26f),
					GUIHelper.Height(22f)
				}))
				{
					DialogueFlagTracker.RevertToOriginal(c.Name);
					_edit.Remove(c.Name);
				}
				GUI.enabled = true;
				break;
			}
			case FlagKind.Enum:
			{
				bool flag2 = _openEnumField == c.Name;
				if (c.Current != null && GUILayout.Button((flag2 ? "▾ " : "▸ ") + c.Current, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(150f),
					GUIHelper.Height(22f)
				}))
				{
					_openEnumField = (flag2 ? null : c.Name);
				}
				GUI.enabled = flag;
				if (GUILayout.Button("↺", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(26f),
					GUIHelper.Height(22f)
				}))
				{
					DialogueFlagTracker.RevertToOriginal(c.Name);
					_openEnumField = null;
				}
				GUI.enabled = true;
				break;
			}
			}
			GUILayout.EndHorizontal();
			if (c.Kind == FlagKind.Enum && _openEnumField == c.Name)
			{
				DrawEnumOptions(c);
			}
		}

		private static void DrawEnumOptions(FlagChange c)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			Type type = c.Current?.GetType();
			if (type == null || !type.IsEnum)
			{
				return;
			}
			foreach (object value in Enum.GetValues(type))
			{
				bool num = object.Equals(value, c.Current);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Space(GUIHelper.Scaled(24f));
				GUI.contentColor = (num ? GUIHelper.ColConfirm : Color.white);
				if (GUILayout.Button((num ? "● " : "   ") + value, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
				{
					DialogueFlagTracker.TrySet(c.Name, c.Kind, value);
					_openEnumField = null;
				}
				GUI.contentColor = Color.white;
				GUILayout.EndHorizontal();
			}
		}
	}
	public static class GUIHelper
	{
		public enum DotState
		{
			None,
			Partial,
			Full
		}

		private const float BaseHeight = 1080f;

		private const float MinScale = 0.75f;

		private const float MaxScale = 2.5f;

		private static float? cachedScale;

		private static int lastScreenHeight;

		private static GUIStyle _windowStyle;

		private static GUIStyle _labelStyle;

		private static GUIStyle _buttonStyle;

		private static GUIStyle _textFieldStyle;

		private static int _cachedFontSize;

		private static readonly Dictionary<int, (GUIStyle track, GUIStyle thumb)> _sliderStyleCache = new Dictionary<int, (GUIStyle, GUIStyle)>();

		private static GUIStyle _borderlessStyle;

		private static int _cachedBorderlessFontSize;

		public static readonly Color ColSurface = new Color(0.102f, 0.102f, 0.106f, 1f);

		public static readonly Color ColSurface1 = new Color(0.133f, 0.133f, 0.145f, 1f);

		public static readonly Color ColSurface2 = new Color(0.157f, 0.157f, 0.169f, 1f);

		public static readonly Color ColBorder = new Color(0.2f, 0.2f, 0.22f, 1f);

		public static readonly Color ColBorderHi = new Color(0.255f, 0.255f, 0.278f, 1f);

		public static readonly Color ColText = new Color(0.949f, 0.945f, 0.933f, 1f);

		public static readonly Color ColAccent = new Color(0.91f, 0.46f, 0.19f, 1f);

		public static readonly Color ColAccentSoft = new Color(0.8f, 0.33f, 0.13f, 1f);

		public static readonly Color ColMuted = new Color(0.725f, 0.722f, 0.761f, 1f);

		public static readonly Color ColFaint = new Color(0.561f, 0.561f, 0.592f, 1f);

		public static readonly Color ColConfirm = new Color(0.2f, 0.67f, 0.53f, 1f);

		public static readonly Color ColSuccess = new Color(0.2f, 0.67f, 0.53f, 1f);

		public static readonly Color ColWarn = new Color(1f, 0.75f, 0.2f, 1f);

		public static readonly Color ColDanger = new Color(0.8f, 0.2f, 0.4f, 1f);

		public static readonly Color ColPackBlue = new Color(0.45f, 0.7f, 1f, 1f);

		public static readonly Color ColBone = new Color(0.87f, 0.85f, 0.82f, 1f);

		public static readonly Color ColPop1 = new Color(0.24f, 0.73f, 0.48f, 1f);

		public static readonly Color ColPop2 = new Color(0.24f, 0.56f, 0.73f, 1f);

		public static readonly Color StripRed = new Color(0.8f, 0.13f, 0.13f, 1f);

		public static readonly Color StripBone = new Color(0.87f, 0.85f, 0.82f, 1f);

		private static readonly (float t, Color color)[] StripStops = new(float, Color)[10]
		{
			(0f, new Color(0.902f, 0.882f, 0.847f)),
			(0.26f, new Color(0.867f, 0.847f, 0.816f)),
			(0.34f, new Color(0.91f, 0.878f, 0.824f)),
			(0.385f, new Color(1f, 0.914f, 0.761f)),
			(0.41f, new Color(1f, 0.541f, 0.302f)),
			(0.44f, new Color(1f, 0.357f, 0.196f)),
			(0.48f, new Color(0.878f, 0.227f, 0.141f)),
			(0.56f, new Color(0.69f, 0.125f, 0.125f)),
			(0.78f, new Color(0.659f, 0.114f, 0.114f)),
			(1f, new Color(0.604f, 0.102f, 0.102f))
		};

		private static Texture2D _vertStripTex;

		private static int _vertStripH;

		private static Texture2D _horzStripTex;

		private static int _horzStripW;

		private const float StripCornerRadius = 6f;

		private static GUIStyle _cardStyleTransparent;

		private static int _cachedCardTransPad;

		private static GUIStyle _chipStyle;

		private static int _cachedChipFontSize;

		private static GUIStyle _mutedLabelStyle;

		private static int _cachedMutedFontSize;

		private static GUIStyle _sectionHeaderStyle;

		private static int _cachedSectionFontSize;

		private static GUIStyle _labelCenteredStyle;

		private static float _backdropAlpha = -1f;

		private static float _backdropPersisted = -1f;

		private static int _backdropWhite = -1;

		private static bool _imguiTextFieldFocused;

		private static int _activeKeyboardControl;

		private static int _lastFieldFocusFrame = -100;

		private static string _pendingFocusControlName;

		private static MethodInfo _setCursorVisibleMethod;

		private static object _inputHandlerInstance;

		private static Texture2D _softwareCursorTex;

		private static GUIStyle _tooltipStyle;

		private static int _cachedTooltipFontSize;

		private static Texture2D _dotFill;

		private static Texture2D _dotRing;

		private static bool _inputSystemAvailable;

		private static bool _actionsDisabled;

		private static PropertyInfo _systemActionsProp;

		private static PropertyInfo _assetActionMapsProp;

		private static PropertyInfo _mapEnabledProp;

		private static MethodInfo _mapDisableMethod;

		private static MethodInfo _mapEnableMethod;

		private static readonly List<object> _disabledMaps = new List<object>();

		private static float _nextFocusProbe;

		public static GUIStyle LabelStyle
		{
			get
			{
				//IL_0021: 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_0032: Expected O, but got Unknown
				int num = FontSize();
				if (_labelStyle == null || _cachedFontSize != num)
				{
					_labelStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = num
					};
					_cachedFontSize = num;
				}
				return _labelStyle;
			}
		}

		public static GUIStyle ButtonStyle
		{
			get
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				int num = FontSize();
				if (_buttonStyle == null || _buttonStyle.fontSize != num)
				{
					_buttonStyle = new GUIStyle(GUI.skin.button)
					{
						fontSize = num
					};
				}
				return _buttonStyle;
			}
		}

		public static GUIStyle SliderTrackStyle => SliderStyles(18f).track;

		public static GUIStyle SliderThumbStyle => SliderStyles(18f).thumb;

		public static GUIStyle SliderTrackStyleCompact => SliderStyles(12f).track;

		public static GUIStyle SliderThumbStyleCompact => SliderStyles(12f).thumb;

		public static GUIStyle WindowStyle
		{
			get
			{
				//IL_0029: 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)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Expected O, but got Unknown
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Expected O, but got Unknown
				int num = FontSize();
				if (_windowStyle == null || _windowStyle.fontSize != num)
				{
					_windowStyle = new GUIStyle(GUI.skin.window)
					{
						fontSize = num,
						padding = new RectOffset(ScaledInt(10), ScaledInt(10), ScaledInt(16), ScaledInt(10)),
						contentOffset = new Vector2(0f, (float)ScaledInt(-4)),
						onNormal = GUI.skin.window.normal,
						onFocused = GUI.skin.window.normal,
						onActive = GUI.skin.window.normal,
						focused = GUI.skin.window.normal,
						active = GUI.skin.window.normal
					};
				}
				return _windowStyle;
			}
		}

		public static GUIStyle BorderlessWindowStyle
		{
			get
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				//IL_0045: Expected O, but got Unknown
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				int num = FontSize();
				if (_borderlessStyle == null || _cachedBorderlessFontSize != num)
				{
					_cachedBorderlessFontSize = num;
					_borderlessStyle = new GUIStyle(GUIStyle.none)
					{
						fontSize = num,
						padding = new RectOffset(0, 0, 0, 0)
					};
					Texture2D background = MakeTex(ColSurface);
					_borderlessStyle.normal.background = background;
					_borderlessStyle.onNormal.background = background;
					_borderlessStyle.focused.background = background;
					_borderlessStyle.onFocused.background = background;
					_borderlessStyle.active.background = background;
					_borderlessStyle.onActive.background = background;
					_borderlessStyle.normal.textColor = Color.white;
				}
				return _borderlessStyle;
			}
		}

		public static GUIStyle TextFieldStyle
		{
			get
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Expected O, but got Unknown
				//IL_005a: Expected O, but got Unknown
				int num = FontSize();
				if (_textFieldStyle == null || _textFieldStyle.fontSize != num)
				{
					_textFieldStyle = new GUIStyle(GUI.skin.textField)
					{
						fontSize = num,
						padding = new RectOffset(ScaledInt(6), ScaledInt(6), ScaledInt(4), ScaledInt(4))
					};
				}
				return _textFieldStyle;
			}
		}

		public static GUIStyle CardStyleTransparent
		{
			get
			{
				//IL_0021: 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_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//IL_0044: Expected O, but got Unknown
				int num = ScaledInt(6);
				if (_cardStyleTransparent == null || _cachedCardTransPad != num)
				{
					_cachedCardTransPad = num;
					_cardStyleTransparent = new GUIStyle(GUIStyle.none)
					{
						padding = new RectOffset(num, num, ScaledInt(4), ScaledInt(4))
					};
				}
				return _cardStyleTransparent;
			}
		}

		public static GUIStyle ChipStyle
		{
			get
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				//IL_0065: Expected O, but got Unknown
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				int num = FontSize(11);
				if (_chipStyle == null || _cachedChipFontSize != num)
				{
					_cachedChipFontSize = num;
					_chipStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = num,
						alignment = (TextAnchor)4,
						padding = new RectOffset(ScaledInt(5), ScaledInt(5), ScaledInt(2), ScaledInt(2))
					};
					_chipStyle.normal.textColor = ColMuted;
					_chipStyle.normal.background = MakeTex(new Color(0.22f, 0.22f, 0.28f, 1f));
				}
				return _chipStyle;
			}
		}

		public static GUIStyle MutedLabelStyle
		{
			get
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				int num = FontSize(12);
				if (_mutedLabelStyle == null || _cachedMutedFontSize != num)
				{
					_cachedMutedFontSize = num;
					_mutedLabelStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = num
					};
					_mutedLabelStyle.normal.textColor = ColMuted;
				}
				return _mutedLabelStyle;
			}
		}

		public static GUIStyle SectionHeaderStyle
		{
			get
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: 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)
				//IL_003f: Expected O, but got Unknown
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				int num = FontSize(12);
				if (_sectionHeaderStyle == null || _cachedSectionFontSize != num)
				{
					_cachedSectionFontSize = num;
					_sectionHeaderStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = num,
						fontStyle = (FontStyle)1
					};
					_sectionHeaderStyle.normal.textColor = ColAccent;
				}
				return _sectionHeaderStyle;
			}
		}

		public static float Scale
		{
			get
			{
				if (!cachedScale.HasValue || lastScreenHeight != Screen.height)
				{
					lastScreenHeight = Screen.height;
					cachedScale = Mathf.Clamp((float)Screen.height / 1080f, 0.75f, 2.5f);
				}
				return cachedScale.Value;
			}
		}

		public static GUIStyle LabelCenteredStyle
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				GUIStyle labelStyle = LabelStyle;
				if (_labelCenteredStyle == null || _labelCenteredStyle.fontSize != labelStyle.fontSize)
				{
					_labelCenteredStyle = new GUIStyle(labelStyle)
					{
						alignment = (TextAnchor)4,
						wordWrap = false
					};
				}
				return _labelCenteredStyle;
			}
		}

		public static Rect DragRect => new Rect(0f, 0f, 10000f, Scaled(24f));

		public static float PreviewBackdropAlpha
		{
			get
			{
				if (_backdropAlpha < 0f)
				{
					_backdropAlpha = (_backdropPersisted = Mathf.Clamp01(Plugin.Config?.PreviewBackdropOpacity ?? 0.6f));
				}
				return _backdropAlpha;
			}
			set
			{
				_backdropAlpha = Mathf.Clamp01(value);
			}
		}

		public static bool PreviewBackdropWhite
		{
			get
			{
				if (_backdropWhite < 0)
				{
					_backdropWhite = ((Plugin.Config?.PreviewBackdropWhite ?? false) ? 1 : 0);
				}
				return _backdropWhite == 1;
			}
			set
			{
				_backdropWhite = (value ? 1 : 0);
				if (Plugin.Config != null)
				{
					Plugin.Config.PreviewBackdropWhite = value;
				}
			}
		}

		public static bool IsTextFieldFocused
		{
			get
			{
				if (!_imguiTextFieldFocused)
				{
					return IsCanvasInputFieldFocused();
				}
				return true;
			}
		}

		public static string ActiveTextControlName { get; private set; }

		public static bool InputBlockingAvailable => _inputSystemAvailable;

		public static (GUIStyle track, GUIStyle thumb) SliderStyles(float height)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0079: Expected O, but got Unknown
			int num = Mathf.RoundToInt(Scaled(height));
			if (!_sliderStyleCache.TryGetValue(num, out (GUIStyle, GUIStyle) value) || value.Item1 == null)
			{
				value = (new GUIStyle(GUI.skin.horizontalSlider)
				{
					fixedHeight = num,
					margin = new RectOffset(4, 4, 4, 4)
				}, new GUIStyle(GUI.skin.horizontalSliderThumb)
				{
					fixedWidth = Mathf.RoundToInt((float)num * 1.25f),
					fixedHeight = num
				});
				_sliderStyleCache[num] = value;
			}
			return value;
		}

		private static Color EvalStrip(float t)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			t = Mathf.Clamp01(t);
			for (int i = 1; i < StripStops.Length; i++)
			{
				if (t <= StripStops[i].t)
				{
					float num = StripStops[i].t - StripStops[i - 1].t;
					float num2 = ((num > 0f) ? ((t - StripStops[i - 1].t) / num) : 1f);
					return Color.Lerp(StripStops[i - 1].color, StripStops[i].color, num2);
				}
			}
			return StripStops[StripStops.Length - 1].color;
		}

		internal static Texture2D GetVerticalStripTex(int texW, int texH)
		{
			if ((Object)(object)_vertStripTex != (Object)null && _vertStripH == texH)
			{
				return _vertStripTex;
			}
			if ((Object)(object)_vertStripTex != (Object)null)
			{
				Object.Destroy((Object)(object)_vertStripTex);
			}
			_vertStripTex = GenerateStripTexture(texW, texH, horizontal: false);
			_vertStripH = texH;
			return _vertStripTex;
		}

		private static Texture2D GetHorizontalStripTex(int texW, int texH)
		{
			if ((Object)(object)_horzStripTex != (Object)null && _horzStripW == texW)
			{
				return _horzStripTex;
			}
			if ((Object)(object)_horzStripTex != (Object)null)
			{
				Object.Destroy((Object)(object)_horzStripTex);
			}
			_horzStripTex = GenerateStripTexture(texW, texH, horizontal: true);
			_horzStripW = texW;
			return _horzStripTex;
		}

		private static Texture2D GenerateStripTexture(int w, int h, bool horizontal)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(w, h, (TextureFormat)4, false);
			((Object)val).hideFlags = (HideFlags)32;
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color[] array = (Color[])(object)new Color[w * h];
			int num = (horizontal ? w : h);
			int num2 = (horizontal ? h : w);
			float num3 = (horizontal ? Mathf.Min(Scaled(3f), (float)num2 * 0.4f) : Scaled(6f));
			float num4 = (horizontal ? 0.6f : 1f);
			for (int i = 0; i < h; i++)
			{
				for (int j = 0; j < w; j++)
				{
					float num5 = (horizontal ? ((float)j) : ((float)(h - 1 - i)));
					float num6 = (horizontal ? ((float)(h - 1 - i)) : ((float)j));
					float num7 = num5 / (float)Mathf.Max(num - 1, 1);
					Color val2 = EvalStrip(num7);
					float num8 = num6 / (float)Mathf.Max(num2 - 1, 1);
					float num9 = 1f + 0.12f * (1f - num8);
					((Color)(ref val2))..ctor(Mathf.Clamp01(val2.r * num9), Mathf.Clamp01(val2.g * num9), Mathf.Clamp01(val2.b * num9), val2.a);
					float num10 = 1f;
					if (num5 < num3 && num6 < num3)
					{
						float num11 = num3 - num6;
						float num12 = num3 - num5;
						float num13 = Mathf.Sqrt(num11 * num11 + num12 * num12);
						num10 = Mathf.Clamp01(num3 - num13 + 0.5f);
					}
					else if (num5 > (float)(num - 1) - num3 && num6 < num3)
					{
						float num14 = num3 - num6;
						float num15 = num3 - ((float)(num - 1) - num5);
						float num16 = Mathf.Sqrt(num14 * num14 + num15 * num15);
						num10 = Mathf.Clamp01(num3 - num16 + 0.5f);
					}
					if (horizontal && num7 > num4)
					{
						float num17 = 1f - (num7 - num4) / (1f - num4);
						num10 *= Mathf.Clamp01(num17) * 0.85f;
					}
					else if (horizontal)
					{
						num10 *= 0.85f;
					}
					val2.a = num10;
					array[i * w + j] = val2;
				}
			}
			val.SetPixels(array);
			val.Apply();
			return val;
		}

		public static void DrawCassetteStripVertical(Rect windowRect, float stripWidth)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			float num = Scaled(stripWidth);
			float num2 = 0f;
			float num3 = 0f;
			float height = ((Rect)(ref windowRect)).height;
			int texW = Mathf.Max(Mathf.RoundToInt(num), 2);
			int texH = Mathf.Max(Mathf.RoundToInt(height), 2);
			Texture2D verticalStripTex = GetVerticalStripTex(texW, texH);
			Color color = GUI.color;
			GUI.color = Color.white;
			GUI.DrawTexture(new Rect(num2, num3, num, height), (Texture)(object)verticalStripTex);
			GUI.color = color;
		}

		public static void DrawCassetteStripHorizontal(Rect area, float stripHeight)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			float num = Scaled(stripHeight);
			float num2 = ((Rect)(ref area)).yMax - num - Scaled(2f);
			float num3 = ((Rect)(ref area)).width - Scaled(4f);
			float num4 = ((Rect)(ref area)).x + Scaled(2f);
			int texW = Mathf.Max(Mathf.RoundToInt(num3), 2);
			int texH = Mathf.Max(Mathf.RoundToInt(num), 2);
			Texture2D horizontalStripTex = GetHorizontalStripTex(texW, texH);
			Color color = GUI.color;
			GUI.color = Color.white;
			GUI.DrawTexture(new Rect(num4, num2, num3, num), (Texture)(object)horizontalStripTex);
			GUI.color = color;
		}

		public static void DrawBorder(Rect rect, Color color, float thickness = 1f)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			float num = Scaled(thickness);
			GUI.color = color;
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, num), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).yMax - num, ((Rect)(ref rect)).width, num), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, num, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).xMax - num, ((Rect)(ref rect)).y, num, ((Rect)(ref rect)).height), (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
		}

		public static Texture2D MakeTex(Color c)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1)
			{
				hideFlags = (HideFlags)32
			};
			val.SetPixel(0, 0, c);
			val.Apply();
			return val;
		}

		public static void DrawSeparator()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = GUILayoutUtility.GetRect(0f, Scaled(1f), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.color = new Color(ColBorder.r, ColBorder.g, ColBorder.b, 0.6f);
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
		}

		public static float Scaled(float value)
		{
			return value * Scale;
		}

		public static int ScaledInt(int value)
		{
			return Mathf.RoundToInt((float)value * Scale);
		}

		public static Rect ScaledRect(float x, float y, float width, float height)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Rect(Scaled(x), Scaled(y), Scaled(width), Scaled(height));
		}

		public static Rect ScaledRectFromRight(float rightMargin, float y, float width, float height)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Rect((float)Screen.width - Scaled(rightMargin + width), Scaled(y), Scaled(width), Scaled(height));
		}

		public static Rect ClampToScreen(Rect r)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			((Rect)(ref r)).x = Mathf.Clamp(((Rect)(ref r)).x, 0f - ((Rect)(ref r)).width + 40f, (float)Screen.width - 40f);
			((Rect)(ref r)).y = Mathf.Clamp(((Rect)(ref r)).y, 0f, (float)Screen.height - 40f);
			return r;
		}

		public static GUILayoutOption[] WindowLayout(float minWidth = 300f, float minHeight = 200f)
		{
			return (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.MinWidth(Scaled(minWidth)),
				GUILayout.MinHeight(Scaled(minHeight))
			};
		}

		public static int FontSize(int baseSize = 14)
		{
			return ScaledInt(baseSize);
		}

		public static bool GhostButton(string label, params GUILayoutOption[] options)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			GUIContent val = new GUIContent(label);
			Rect rect = GUILayoutUtility.GetRect(val, ButtonStyle, options);
			bool num = ((Rect)(ref rect)).Contains(Event.current.mousePosition);
			if (num)
			{
				GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture, (ScaleMode)0, true, 0f, new Color(ColSurface2.r, ColSurface2.g, ColSurface2.b, 0.9f), 0f, Scaled(4f));
				GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture, (ScaleMode)0, true, 0f, new Color(ColBorderHi.r, ColBorderHi.g, ColBorderHi.b, 0.9f), 1f, Scaled(4f));
			}
			Color contentColor = GUI.contentColor;
			GUI.contentColor = (num ? ColText : ColMuted);
			bool result = GUI.Button(rect, val, LabelCenteredStyle);
			GUI.contentColor = contentColor;
			return result;
		}

		public static void DrawPreviewBackdrop(Rect r)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			float previewBackdropAlpha = PreviewBackdropAlpha;
			if (!(previewBackdropAlpha <= 0.01f))
			{
				float num = (PreviewBackdropWhite ? 1f : 0f);
				Color color = GUI.color;
				GUI.color = new Color(num, num, num, previewBackdropAlpha);
				GUI.DrawTexture(r, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = color;
			}
		}

		public static void DrawBackdropSliderRow()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Invalid comparison between Unknown and I4
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = (Color)(PreviewBackdropWhite ? Color.white : new Color(0.12f, 0.12f, 0.13f));
			if (GUILayout.Button(Loc.T("BG"), ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				Width(36f),
				GUILayout.Height(Scaled(20f))
			}))
			{
				PreviewBackdropWhite = !PreviewBackdropWhite;
			}
			GUI.backgroundColor = backgroundColor;
			float num = GUILayout.HorizontalSlider(PreviewBackdropAlpha, 0f, 1f, SliderTrackStyleCompact, SliderThumbStyleCompact, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			if (!Mathf.Approximately(num, PreviewBackdropAlpha))
			{
				PreviewBackdropAlpha = num;
			}
			GUILayout.EndHorizontal();
			if ((int)Event.current.type == 7 && !Input.GetMouseButton(0) && !Mathf.Approximately(_backdropAlpha, _backdropPersisted) && Plugin.Config != null)
			{
				Plugin.Config.PreviewBackdropOpacity = _backdropAlpha;
				_backdropPersisted = _backdropAlpha;
			}
		}

		public static void Space(float basePixels = 10f)
		{
			GUILayout.Space(Scaled(basePixels));
		}

		public static GUILayoutOption Width(float baseWidth)
		{
			return GUILayout.Width(Scaled(baseWidth));
		}

		public static GUILayoutOption Height(float baseHeight)
		{
			return GUILayout.Height(Scaled(baseHeight));
		}

		private static bool IsCanvasInputFieldFocused()
		{
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return false;
			}
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			if ((Object)(object)currentSelectedGameObject == (Object)null)
			{
				return false;
			}
			InputField component = currentSelectedGameObject.GetComponent<InputField>();
			if ((Object)(object)component != (Object)null)
			{
				return component.isFocused;
			}
			return false;
		}

		public static void BeginOnGUI()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if ((int)Event.current.type == 7)
			{
				GUI.tooltip = "";
			}
			if (!string.IsNullOrEmpty(_pendingFocusControlName))
			{
				GUI.FocusControl(_pendingFocusControlName);
				_pendingFocusControlName = null;
			}
			string nameOfFocusedControl = GUI.GetNameOfFocusedControl();
			int keyboardControl = GUIUtility.keyboardControl;
			bool num = !string.IsNullOrEmpty(ActiveTextControlName) && nameOfFocusedControl == ActiveTextControlName && keyboardControl != 0 && keyboardControl == _activeKeyboardControl;
			bool flag = _imguiTextFieldFocused && Time.frameCount - _lastFieldFocusFrame > 1;
			if (!num || flag)
			{
				_imguiTextFieldFocused = false;
				ActiveTextControlName = null;
				_activeKeyboardControl = 0;
			}
		}

		public static void EndOnGUI()
		{
			DrawTooltip();
		}

		public static void InitCursor()
		{
			_setCursorVisibleMethod = AccessTools.Method(typeof(InputHandler), "SetCursorVisible", (Type[])null, (Type[])null);
			if (_setCursorVisibleMethod == null)
			{
				Plugin.Logger.LogWarning((object)"[GUIHelper] InputHandler.SetCursorVisible not found — hardware cursor call skipped");
			}
			_softwareCursorTex = BuildSoftwareCursorTex();
		}

		public static void ShowCursorForWindow()
		{
			if (!(_setCursorVisibleMethod == null))
			{
				if (_inputHandlerInstance == null || _inputHandlerInstance.Equals(null))
				{
					_inputHandlerInstance = Object.FindAnyObjectByType<InputHandler>();
				}
				if (_inputHandlerInstance != null)
				{
					_setCursorVisibleMethod.Invoke(_inputHandlerInstance, new object[1] { true });
				}
			}
		}

		private static Texture2D BuildSoftwareCursorTex()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(16, 16, (TextureFormat)4, false)
			{
				hideFlags = (HideFlags)32,
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			Color32[] array = (Color32[])(object)new Color32[256];
			Color32 val2 = default(Color32);
			for (int i = 0; i < 16; i++)
			{
				for (int j = 0; j < 16; j++)
				{
					float num = (float)j - 7.5f;
					float num2 = (float)i - 7.5f;
					float num3 = Mathf.Sqrt(num * num + num2 * num2);
					if (num3 < 5f)
					{
						((Color32)(ref val2))..ctor(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
					}
					else if (num3 < 6.5f)
					{
						((Color32)(ref val2))..ctor((byte)0, (byte)0, (byte)0, byte.MaxValue);
					}
					else
					{
						((Color32)(ref val2))..ctor((byte)0, (byte)0, (byte)0, (byte)0);
					}
					array[i * 16 + j] = val2;
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			return val;
		}

		public static void DrawSoftwareCursor()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0021: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_softwareCursorTex == (Object)null) && (int)Event.current.type == 7)
			{
				Vector2 mousePosition = Event.current.mousePosition;
				int num = (int)Scaled(16f);
				int num2 = num / 2;
				GUI.DrawTexture(new Rect(mousePosition.x - (float)num2, mousePosition.y - (float)num2, (float)num, (float)num), (Texture)(object)_softwareCursorTex, (ScaleMode)0, true);
			}
		}

		public static void DrawTooltip()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0084: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(GUI.tooltip) && (int)Event.current.type == 7)
			{
				int num = FontSize(12);
				if (_tooltipStyle == null || _cachedTooltipFontSize != num)
				{
					_cachedTooltipFontSize = num;
					_tooltipStyle = new GUIStyle(GUI.skin.box)
					{
						fontSize = num,
						alignment = (TextAnchor)0,
						wordWrap = true,
						padding = new RectOffset(ScaledInt(6), ScaledInt(6), ScaledInt(4), ScaledInt(4))
					};
					_tooltipStyle.normal.textColor = new Color(0.9f, 0.9f, 0.9f);
				}
				float num2 = Scaled(260f);
				float x = Event.current.mousePosition.x;
				float y = Event.current.mousePosition.y;
				GUIContent val = new GUIContent(GUI.tooltip);
				float num3 = _tooltipStyle.CalcHeight(val, num2);
				float num4 = Scaled(14f);
				float num5 = Scaled(18f);
				float num6 = x + num4;
				float num7 = y + num5;
				if (num6 + num2 > (float)Screen.width)
				{
					num6 = x - num2 - num4;
				}
				if (num7 + num3 > (float)Screen.height)
				{
					num7 = y - num3 - num5;
				}
				Rect val2 = new Rect(num6, num7, num2, num3);
				GUI.color = new Color(0f, 0f, 0f, 0.72f);
				GUI.DrawTexture(val2, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = Color.white;
				GUI.Box(val2, val, _tooltipStyle);
				GUI.tooltip = "";
			}
		}

		public static GUIContent TT(string label, string tooltip)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			return new GUIContent(label, tooltip);
		}

		public static void RequestFocus(string controlName)
		{
			if (!string.IsNullOrEmpty(controlName))
			{
				_pendingFocusControlName = controlName;
			}
		}

		public static void ReleaseFocus()
		{
			if (!string.IsNullOrEmpty(ActiveTextControlName))
			{
				GUI.FocusControl(string.Empty);
			}
			_imguiTextFieldFocused = false;
			ActiveTextControlName = null;
			_activeKeyboardControl = 0;
			_pendingFocusControlName = null;
		}

		public static void NotifyTextFieldFocused(string controlName)
		{
			ActiveTextControlName = controlName;
			_activeKeyboardControl = GUIUtility.keyboardControl;
			_imguiTextFieldFocused = true;
			_lastFieldFocusFrame = Time.frameCount;
			if (Event.current != null && Event.current.isKey)
			{
				Event.current.Use();
			}
		}

		private static void EnsureDotTextures()
		{
			//IL_0021: 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: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_dotFill != (Object)null && (Object)(object)_dotRing != (Object)null)
			{
				return;
			}
			_dotFill = new Texture2D(16, 16, (TextureFormat)4, false)
			{
				hideFlags = (HideFlags)32
			};
			_dotRing = new Texture2D(16, 16, (TextureFormat)4, false)
			{
				hideFlags = (HideFlags)32
			};
			float num = 7.5f;
			float num2 = 6.5f;
			float num3 = 4.5f;
			for (int i = 0; i < 16; i++)
			{
				for (int j = 0; j < 16; j++)
				{
					float num4 = Mathf.Sqrt(((float)j - num) * ((float)j - num) + ((float)i - num) * ((float)i - num));
					float num5 = Mathf.Clamp01(num2 - num4 + 0.5f);
					float num6 = Mathf.Min(num5, Mathf.Clamp01(num4 - num3 + 0.5f));
					_dotFill.SetPixel(j, i, new Color(1f, 1f, 1f, num5));
					_dotRing.SetPixel(j, i, new Color(1f, 1f, 1f, num6));
				}
			}
			_dotFill.Apply();
			_dotRing.Apply();
			Texture2D dotFill = _dotFill;
			Texture2D dotRing = _dotRing;
			FilterMode filterMode = (FilterMode)1;
			((Texture)dotRing).filterMode = (FilterMode)1;
			((Texture)dotFill).filterMode = filterMode;
		}

		public static void StatusDot(Rect r, DotState state, Color color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			EnsureDotTextures();
			Color color2 = GUI.color;
			GUI.color = color;
			switch (state)
			{
			case DotState.Full:
				GUI.DrawTexture(r, (Texture)(object)_dotFill);
				break;
			case DotState.None:
				GUI.DrawTexture(r, (Texture)(object)_dotRing);
				break;
			default:
			{
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width * 0.5f, ((Rect)(ref r)).height);
				Rect val2 = new Rect(((Rect)(ref r)).x + ((Rect)(ref r)).width * 0.5f, ((Rect)(ref r)).y, ((Rect)(ref r)).width * 0.5f, ((Rect)(ref r)).height);
				GUI.DrawTextureWithTexCoords(val, (Texture)(object)_dotFill, new Rect(0f, 0f, 0.5f, 1f));
				GUI.DrawTextureWithTexCoords(val2, (Texture)(object)_dotRing, new Rect(0.5f, 0f, 0.5f, 1f));
				break;
			}
			}
			GUI.color = color2;
		}

		public static void StatusDotSlot(DotState state, Color color, string tooltip)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			float num = Scaled(16f);
			float lineHeight = LabelStyle.lineHeight;
			Rect rect = GUILayoutUtility.GetRect(num, lineHeight, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.Height(lineHeight)
			});
			float num2 = Scaled(8f);
			StatusDot(new Rect(((Rect)(ref rect)).x + (((Rect)(ref rect)).width - num2) * 0.5f, ((Rect)(ref rect)).y + (((Rect)(ref rect)).height - num2) * 0.5f, num2, num2), state, color);
			GUI.Label(rect, new GUIContent("", tooltip), LabelStyle);
		}

		public static bool ToggleButton(bool value, string label, params GUILayoutOption[] options)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			Color backgroundColor = GUI.backgroundColor;
			Color contentColor = GUI.contentColor;
			if (value)
			{
				GUI.backgroundColor = ColConfirm;
			}
			else
			{
				GUI.contentColor = ColMuted;
			}
			bool num = GUILayout.Button((value ? "● " : "○ ") + label, ButtonStyle, options);
			GUI.backgroundColor = backgroundColor;
			GUI.contentColor = contentColor;
			if (!num)
			{
				return value;
			}
			return !value;
		}

		public static string TextField(string text, params GUILayoutOption[] options)
		{
			return TextField("Stitchwork.TextField.Default", text, options);
		}

		public static string TextField(string controlName, string text, params GUILayoutOption[] options)
		{
			GUI.SetNextControlName(controlName);
			string result = GUILayout.TextField(text, TextFieldStyle, options);
			if (GUI.GetNameOfFocusedControl() == controlName)
			{
				ActiveTextControlName = controlName;
				_activeKeyboardControl = GUIUtility.keyboardControl;
				_imguiTextFieldFocused = true;
				_lastFieldFocusFrame = Time.frameCount;
				if (Event.current != null && Event.current.isKey)
				{
					Event.current.Use();
				}
			}
			return result;
		}

		public static string TextArea(string text, params GUILayoutOption[] options)
		{
			return TextArea("Stitchwork.TextArea.Default", text, options);
		}

		public static string TextArea(string controlName, string text, params GUILayoutOption[] options)
		{
			GUI.SetNextControlName(controlName);
			string result = GUILayout.TextArea(text, TextFieldStyle, options);
			if (GUI.GetNameOfFocusedControl() == controlName)
			{
				ActiveTextControlName = controlName;
				_activeKeyboardControl = GUIUtility.keyboardControl;
				_imguiTextFieldFocused = true;
				_lastFieldFocusFrame = Time.frameCount;
				if (Event.current != null && Event.current.isKey)
				{
					Event.current.Use();
				}
			}
			return result;
		}

		public static void InitInputBlocking()
		{
			try
			{
				Type type = AccessTools.TypeByName("UnityEngine.InputSystem.InputSystem");
				Type type2 = AccessTools.TypeByName("UnityEngine.InputSystem.InputActionAsset");
				Type type3 = AccessTools.TypeByName("UnityEngine.InputSystem.InputActionMap");
				if (type != null && type2 != null && type3 != null)
				{
					_systemActionsProp = type.GetProperty("actions", BindingFlags.Static | BindingFlags.Public);
					_assetActionMapsProp = type2.GetProperty("actionMaps");
					_mapEnabledProp = type3.GetProperty("enabled");
					_mapDisableMethod = type3.GetMethod("Disable", Type.EmptyTypes);
					_mapEnableMethod = type3.GetMethod("Enable", Type.EmptyTypes);
				}
				bool flag = _systemActionsProp != null && _assetActionMapsProp != null && _mapEnabledProp != null && _mapDisableMethod != null && _mapEnableMethod != null;
				if (!flag)
				{
					Plugin.Logger.LogWarning((object)"[InputBlock] No usable Input System path found.");
					return;
				}
				_inputSystemAvailable = true;
				Plugin.Logger.LogInfo((object)$"[InputBlock] Ready (asset path: {flag})");
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogWarning((object)$"[InputBlock] Init failed: {arg}");
			}
		}

		public static void UpdateInputBlocking()
		{
			if (!_inputSystemAvailable)
			{
				return;
			}
			LogCanvasFocusProbe();
			try
			{
				if (IsTextFieldFocused && !_actionsDisabled)
				{
					DisableGameActions();
					_actionsDisabled = true;
				}
				else if (!IsTextFieldFocused && _actionsDisabled)
				{
					RestoreGameActions();
					_actionsDisabled = false;
				}
			}
			catch (Exception arg)
			{
				ForceRestoreGameActions();
				Plugin.Logger.LogWarning((object)$"[InputBlock] Update failed: {arg}");
			}
		}

		public static void DrawDashedRect(Rect r, Color c, float dash = 6f, float gap = 4f, float thickness = 2f)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			Texture2D whiteTexture = Texture2D.whiteTexture;
			Color color = GUI.color;
			GUI.color = c;
			for (float num = ((Rect)(ref r)).x; num < ((Rect)(ref r)).xMax; num += dash + gap)
			{
				float num2 = Mathf.Min(dash, ((Rect)(ref r)).xMax - num);
				GUI.DrawTexture(new Rect(num, ((Rect)(ref r)).y, num2, thickness), (Texture)(object)whiteTexture);
				GUI.DrawTexture(new Rect(num, ((Rect)(ref r)).yMax - thickness, num2, thickness), (Texture)(object)whiteTexture);
			}
			for (float num3 = ((Rect)(ref r)).y; num3 < ((Rect)(ref r)).yMax; num3 += dash + gap)
			{
				float num4 = Mathf.Min(dash, ((Rect)(ref r)).yMax - num3);
				GUI.DrawTexture(new Rect(((Rect)(ref r)).x, num3, thickness, num4), (Texture)(object)whiteTexture);
				GUI.DrawTexture(new Rect(((Rect)(ref r)).xMax - thickness, num3, thickness, num4), (Texture)(object)whiteTexture);
			}
			GUI.color = color;
		}

		public static void LogEventSystemInventory(string sceneName)
		{
			EventSystem[] array = Object.FindObjectsByType<EventSystem>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			EventSystem current = EventSystem.current;
			StringBuilder stringBuilder = new StringBuilder();
			EventSystem[] array2 = array;
			foreach (EventSystem val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append(((Object)((Component)val).gameObject).name).Append(((Component)val).gameObject.activeInHierarchy ? "(on" : "(off").Append(((Object)(object)val == (Object)(object)current) ? ",current)" : ")");
				}
			}
			Plugin.Logger.LogInfo((object)$"[InputProbe] Scene '{sceneName}': {array.Length} EventSystem(s): {stringBuilder}");
		}

		private static void LogCanvasFocusProbe()
		{
			if (!CanvasPackManager.IsVisible || Time.unscaledTime < _nextFocusProbe)
			{
				return;
			}
			_nextFocusProbe = Time.unscaledTime + 1f;
			EventSystem current = EventSystem.current;
			EventSystem[] array = Object.FindObjectsByType<EventSystem>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			string arg = (((Object)(object)current != (Object)null) ? ((Object)((Component)current).gameObject).name : "(null)");
			string arg2 = "(none)";
			string arg3 = "-";
			if ((Object)(object)current != (Object)null && (Object)(object)current.currentSelectedGameObject != (Object)null)
			{
				arg2 = ((Object)current.currentSelectedGameObject).name;
				InputField component = current.currentSelectedGameObject.GetComponent<InputField>();
				if ((Object)(object)component != (Object)null)
				{
					arg3 = (component.isFocused ? "focused" : "selected-not-focused");
				}
			}
			Plugin.Logger.LogInfo((object)($"[InputProbe] ES.current='{arg}' esCount={array.Length} " + $"selected='{arg2}' inputField={arg3} blocking={_actionsDisabled}"));
		}

		private static void DisableGameActions()
		{
			_disabledMaps.Clear();
			if (!(_systemActionsProp != null) || !(_assetActionMapsProp != null) || !(_mapEnabledProp != null) || !(_mapDisableMethod != null))
			{
				return;
			}
			object value = _systemActionsProp.GetValue(null);
			if (value == null || !(_assetActionMapsProp.GetValue(value) is IEnumerable enumerable))
			{
				return;
			}
			foreach (object item in enumerable)
			{
				bool flag = false;
				try
				{
					flag = (bool)_mapEnabledProp.GetValue(item);
				}
				catch (Exception)
				{
				}
				if (flag)
				{
					try
					{
						_mapDisableMethod.Invoke(item, null);
						_disabledMaps.Add(item);
					}
					catch (Exception ex2)
					{
						Plugin.Logger.LogDebug((object)("[InputBlock] Failed to disable map: " + ex2.Message));
					}
				}
			}
		}

		private static void RestoreGameActions()
		{
			if (_mapEnableMethod != null)
			{
				foreach (object disabledMap in _disabledMaps)
				{
					try
					{
						_mapEnableMethod.Invoke(disabledMap, null);
					}
					catch (Exception ex)
					{
						Plugin.Logger.LogWarning((object)($"[InputBlock] Failed to re-enable map '{disabledMap}': " + $"{(ex as TargetInvocationException)?.InnerException ?? ex}"));
					}
				}
			}
			_disabledMaps.Clear();
		}

		public static void ForceRestoreGameActions()
		{
			if (_actionsDisabled)
			{
				try
				{
					RestoreGameActions();
				}
				catch (Exception)
				{
				}
				_actionsDisabled = false;
			}
		}
	}
	[HarmonyPatch]
	internal static class SetCursorVisiblePatch
	{
		[HarmonyPatch(typeof(InputHandler), "SetCursorVisible")]
		[HarmonyPrefix]
		private static void Prefix(ref bool value)
		{
			if (!Plugin.ShowPackManager && !Plugin.ShowDevHub && !CanvasPackManager.IsVisible && !WorldPickMode.Active)
			{
				return;
			}
			value = true;
			try
			{
				UIManager instance = UIManager.instance;
				if ((Object)(object)instance != (Object)null && (Object)(object)instance.inputModule != (Object)null)
				{
					instance.inputModule.allowMouseInput = true;
				}
			}
			catch
			{
			}
		}
	}
	internal static class HotkeyController
	{
		internal static void Poll()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (GUIHelper.IsTextFieldFocused)
			{
				return;
			}
			if (ArchitectBridge.IsEditing)
			{
				if (WorldPickMode.Active)
				{
					WorldPickMode.Cancel("Architect edit mode");
				}
				return;
			}
			WorldPickMode.Update();
			if (WorldPickMode.Active && AnyStitchworkHotkeyDown())
			{
				WorldPickMode.Cancel("Stitchwork hotkey");
			}
			if (Input.GetKeyDown(Plugin.Config.FullDumpKey) && Plugin.Config.DumpSprites)
			{
				SceneTraverser.TraverseAllScenes();
			}
			if (Input.GetKeyDown(Plugin.Config.ShowPackManagerKey))
			{
				if (Plugin.Config.UseCanvasPackManager)
				{
					CanvasPackManager.Toggle();
				}
				else
				{
					Plugin.ShowPackManager = !Plugin.ShowPackManager;
				}
			}
			if (Input.GetKeyDown(Plugin.Config.DevHubDashboardKey))
			{
				DevHub.ToggleAt(0);
			}
			if (Input.GetKeyDown(Plugin.Config.DevHubGraphicsKey))
			{
				DevHub.ToggleAt(1);
			}
			if (Input.GetKeyDown(Plugin.Config.DevHubTextKey))
			{
				DevHub.ToggleAt(2);
			}
			if (Input.GetKeyDown(Plugin.Config.DevHubVideoKey))
			{
				DevHub.ToggleAt(3);
			}
			if (Input.GetKeyDown(Plugin.Config.DevHubAudioKey))
			{
				DevHub.ToggleAt(4);
			}
			if (Input.GetKeyDown(Plugin.Config.DevHubPerformanceKey))
			{
				DevHub.ToggleAt(5);
			}
		}

		private static bool AnyStitchworkHotkeyDown()
		{
			//IL_0007: 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)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			StitchworkConfig config = Plugin.Config;
			if (!Input.GetKeyDown(config.ShowPackManagerKey) && !Input.GetKeyDown(config.DevHubDashboardKey) && !Input.GetKeyDown(config.DevHubGraphicsKey) && !Input.GetKeyDown(config.DevHubTextKey) && !Input.GetKeyDown(config.DevHubVideoKey) && !Input.GetKeyDown(config.DevHubAudioKey) && !Input.GetKeyDown(config.DevHubPerformanceKey))
			{
				return Input.GetKeyDown(config.FullDumpKey);
			}
			return true;
		}
	}
	public static class PackManagerWindow
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static WindowFunction <0>__DrawWindow;
		}

		private const float WindowWidth = 460f;

		private const float WindowHeight = 520f;

		private const float LeftMargin = 20f;

		private const float TopMargin = 60f;

		private static Rect _windowRect;

		private static bool _initialized;

		private static Vector2 _scroll;

		private static Vector2 _profilesScroll;

		private static string _profileNameInput = "";

		private static List<PackInfo> _staged;

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

		private static string _openDropdownId = null;

		private static string _pdSearch = "";

		private static Vector2 _pdScrollPos = Vector2.zero;

		private const float StripW = 12f;

		private const float kOrColW = 38f;

		private const float kAndColW = 38f;

		private static readonly Color kJoinHl = GUIHelper.ColAccent;

		private static GUIStyle _bracketStyle;

		private const float ToggleSquare = 22f;

		private const float GearSquare = 22f;

		private const float InfoIndent = 30f;

		private static GUIStyle _titleStyle;

		private static int _cachedTitleFontSize;

		private static readonly Dictionary<string, PackInfo> _livePacksByPath = new Dictionary<string, PackInfo>(StringComparer.OrdinalIgnoreCase);

		private static bool _conflictsFoldout;

		private static bool HasChanges => _staged != null;

		private static GUIStyle BracketStyle
		{
			get
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected O, but got Unknown
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Expected O, but got Unknown
				if (_bracketStyle != null)
				{
					return _bracketStyle;
				}
				Texture2D val = new Texture2D(1, 1);
				val.SetPixel(0, 0, new Color(GUIHelper.ColPop2.r, GUIHelper.ColPop2.g, GUIHelper.ColPop2.b, 0.85f));
				val.Apply();
				_bracketStyle = new GUIStyle(GUIStyle.none);
				_bracketStyle.normal.background = val;
				return _bracketStyle;
			}
		}

		public static Rect WindowRect => _windowRect;

		private static GUIStyle TitleStyle
		{
			get
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: 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)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				int num = GUIHelper.FontSize();
				if (_titleStyle == null || _cachedTitleFontSize != num)
				{
					_cachedTitleFontSize = num;
					_titleStyle = new GUIStyle(GUI.skin.label)
					{
						fontSize = num,
						fontStyle = (FontStyle)1,
						alignment = (TextAnchor)4
					};
					_titleStyle.normal.textColor = GUIHelper.ColBone;
				}
				return _titleStyle;
			}
		}

		public static void Draw()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00ba: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized || ((Rect)(ref _windowRect)).width < 1f)
			{
				float num = Plugin.Config?.PackManagerX ?? 0f;
				float num2 = Plugin.Config?.PackManagerY ?? 0f;
				_windowRect = (Rect)((num > 0f || num2 > 0f) ? new Rect(num, num2, GUIHelper.Scaled(460f), GUIHelper.Scaled(520f)) : GUIHelper.ScaledRect(20f, 60f, 460f, 520f));
				_initialized = true;
			}
			Rect windowRect = _windowRect;
			object obj = <>O.<0>__DrawWindow;
			if (obj == null)
			{
				WindowFunction val = DrawWindow;
				<>O.<0>__DrawWindow = val;
				obj = (object)val;
			}
			_windowRect = GUILayout.Window(69761, windowRect, (WindowFunction)obj, "", GUIHelper.BorderlessWindowStyle, GUIHelper.WindowLayout(460f, 520f));
			_windowRect = GUIHelper.ClampToScreen(_windowRect);
		}

		private static void DrawWindow(int _)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			GUIHelper.DrawCassetteStripVertical(_windowRect, 12f);
			float num = GUIHelper.Scaled(20f);
			float num2 = GUIHelper.Scaled(10f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Space(num);
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.Space(GUIHelper.Scaled(8f));
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(Loc.T("Stitchwork — Resource Packs"), TitleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			List<PackInfo> list = _staged ?? PackManager.AllPacks.ToList();
			GUIHelper.Space(4f);
			DrawToolbar();
			GUIHelper.Space(6f);
			DrawPackList(list);
			GUIHelper.Space(4f);
			DrawProfilesSection();
			GUIHelper.Space(4f);
			DrawConflictsSection();
			GUIHelper.Space(6f);
			DrawActionBar(list);
			GUIHelper.Space(6f);
			DrawFooter();
			GUIHelper.Space(8f);
			GUILayout.EndVertical();
			GUILayout.Space(num2);
			GUILayout.EndHorizontal();
			GUI.DragWindow(GUIHelper.DragRect);
		}

		private static void DrawToolbar()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Rescan"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(72f) }))
			{
				PackManager.Rescan();
				_staged = null;
			}
			GUILayout.FlexibleSpace();
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = new Color(GUIHelper.ColDanger.r * 0.55f, GUIHelper.ColDanger.g * 0.55f, GUIHelper.ColDanger.b * 0.55f);
			if (GUILayout.Button("×", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(26f),
				GUIHelper.Height(22f)
			}))
			{
				Plugin.ShowPackManager = false;
			}
			GUI.backgroundColor = backgroundColor;
			GUILayout.EndHorizontal();
		}

		private static void DrawPackList(List<PackInfo> list)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			if (list.Count == 0)
			{
				GUILayout.Label(Loc.T("No packs found.\nDrop packs into Stitchwork/Packs/ or install via Thunderstore."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			}
			_livePacksByPath.Clear();
			foreach (PackInfo allPack in PackManager.AllPacks)
			{
				if (!string.IsNullOrEmpty(allPack.Path))
				{
					_livePacksByPath[allPack.Path] = allPack;
				}
			}
			for (int i = 0; i < list.Count; i++)
			{
				DrawPackRow(list, i);
			}
			GUILayout.EndScrollView();
		}

		private static void DrawPackRow(List<PackInfo> list, int i)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_064a: Unknown result type (might be due to invalid IL or missing references)
			//IL_064f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0662: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0667: Unknown result type (might be due to invalid IL or missing references)
			//IL_0669: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0671: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Unknown result type (might be due to invalid IL or missing references)
			//IL_0684: Unknown result type (might be due to invalid IL or missing references)
			PackInfo packInfo = list[i];
			_livePacksByPath.TryGetValue(packInfo.Path ?? "", out var value);
			bool flag = value?.HasConditions ?? false;
			GUILayout.BeginVertical(GUIHelper.CardStyleTransparent, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = (packInfo.IsEnabled ? GUIHelper.ColConfirm : GUIHelper.ColSurface);
			GUI.contentColor = (packInfo.IsEnabled ? Color.white : GUIHelper.ColMuted);
			bool num = GUILayout.Button(packInfo.IsEnabled ? "✓" : "", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(22f),
				GUIHelper.Height(22f)
			});
			GUI.backgroundColor = backgroundColor;
			GUI.contentColor = Color.white;
			if (num)
			{
				EnsureStaged();
				_staged[i].IsEnabled = !packInfo.IsEnabled;
			}
			GUIHelper.Space(4f);
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(packInfo.Name, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUIHelper.Space(4f);
			GUILayout.Label((packInfo.Source == PackSource.Customizer) ? Loc.T("customizer") : ((packInfo.Source == PackSource.Global) ? Loc.T("global") : Loc.T("pack@chip", "pack")), GUIHelper.ChipStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			int num2 = ConflictTracker.ShadowedCount(packInfo.Path);
			if (num2 > 0)
			{
				GUIHelper.Space(2f);
				GUI.contentColor = GUIHelper.ColWarn;
				GUILayout.Label($"⚠ {num2}", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
			GUILayout.FlexibleSpace();
			GUI.enabled = i > 0;
			if (GUILayout.Button("▲", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(26f) }))
			{
				EnsureStaged();
				List<PackInfo> staged = _staged;
				int index = i - 1;
				List<PackInfo> staged2 = _staged;
				int index2 = i;
				PackInfo value2 = _staged[i];
				PackInfo value3 = _staged[i - 1];
				staged[index] = value2;
				staged2[index2] = value3;
			}
			GUI.enabled = i < list.Count - 1;
			if (GUILayout.Button("▼", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(26f) }))
			{
				EnsureStaged();
				List<PackInfo> staged = _staged;
				int index2 = i + 1;
				List<PackInfo> staged3 = _staged;
				int index = i;
				PackInfo value3 = _staged[i];
				PackInfo value2 = _staged[i + 1];
				staged[index2] = value3;
				staged3[index] = value2;
			}
			GUI.enabled = true;
			GUIHelper.Space(2f);
			if (value != null)
			{
				bool flag2 = _conditionsOpen.Contains(packInfo.Path);
				Color backgroundColor2 = GUI.backgroundColor;
				if (flag2 || flag)
				{
					GUI.backgroundColor = new Color(GUIHelper.ColAccent.r * 0.4f, GUIHelper.ColAccent.g * 0.4f, GUIHelper.ColAccent.b * 0.4f);
					GUI.contentColor = GUIHelper.ColAccent;
				}
				if (GUILayout.Button("⚙", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(22f),
					GUIHelper.Height(22f)
				}))
				{
					if (flag2)
					{
						_conditionsOpen.Remove(packInfo.Path);
					}
					else
					{
						_conditionsOpen.Add(packInfo.Path);
					}
				}
				GUI.backgroundColor = backgroundColor2;
				GUI.contentColor = Color.white;
			}
			GUILayout.EndHorizontal();
			List<string> list2 = new List<string>();
			if (!string.IsNullOrEmpty(packInfo.Author))
			{
				list2.Add(string.Format(Loc.T("by {0}"), packInfo.Author));
			}
			if (!string.IsNullOrEmpty(packInfo.Version))
			{
				list2.Add("v" + packInfo.Version);
			}
			if (!string.IsNullOrEmpty(packInfo.Description))
			{
				string item = ((packInfo.Description.Length > 55) ? (packInfo.Description.Substring(0, 52) + "…") : packInfo.Description);
				list2.Add(item);
			}
			if (list2.Count > 0)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Space(GUIHelper.Scaled(30f));
				GUILayout.Label(string.Join("   ", list2), GUIHelper.MutedLabelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
			}
			string badge = packInfo.Stats.Badge;
			if (badge != null)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Space(GUIHelper.Scaled(30f));
				GUILayout.Label(badge, GUIHelper.MutedLabelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndHorizontal();
			}
			else
			{
				List<string> list3 = new List<string>();
				if (Directory.Exists(Path.Combine(packInfo.Path, "Sprites")))
				{
					list3.Add(Loc.T("sprites"));
				}
				if (Directory.Exists(PackLayout.SheetsRoot(packInfo.Path)))
				{
					list3.Add(Loc.T("sheets"));
				}
				if (Directory.Exists(Path.Combine(packInfo.Path, "Sounds")))
				{
					list3.Add(Loc.T("audio"));
				}
				if (Directory.Exists(Path.Combine(packInfo.Path, "Videos")))
				{
					list3.Add(Loc.T("video"));
				}
				if (Directory.Exists(Path.Combine(packInfo.Path, "Text")))
				{
					list3.Add(Loc.T("text"));
				}
				if (list3.Count > 0)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUILayout.Space(GUIHelper.Scaled(30f));
					foreach (string item2 in list3)
					{
						GUILayout.Label(item2, GUIHelper.ChipStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
					}
					GUILayout.EndHorizontal();
				}
			}
			if (value != null && _conditionsOpen.Contains(packInfo.Path))
			{
				GUIHelper.DrawSeparator();
				DrawConditionEditor(value);
			}
			GUILayout.EndVertical();
			Rect lastRect = GUILayoutUtility.GetLastRect();
			if (packInfo.IsEnabled)
			{
				Color val = (flag ? GUIHelper.ColAccent : GUIHelper.ColConfirm);
				GUIHelper.DrawBorder(lastRect, new Color(val.r, val.g, val.b, 0.7f), 2f);
			}
			else if (flag)
			{
				GUIHelper.DrawBorder(lastRect, new Color(GUIHelper.ColAccent.r, GUIHelper.ColAccent.g, GUIHelper.ColAccent.b, 0.4f), 2f);
			}
			GUIHelper.Space(4f);
		}

		private static void DrawActionBar(List<PackInfo> list)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			int num = list.Count((PackInfo p) => p.IsEnabled);
			GUIHelper.DrawSeparator();
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(string.Format(Loc.T("{0}/{1} active"), num, list.Count), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (HasChanges)
			{
				GUI.contentColor = GUIHelper.ColWarn;
				GUILayout.Label(Loc.T("unsaved changes"), GUIHelper.MutedLabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(2f);
			GUI.enabled = HasChanges;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Discard"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(26f) }))
			{
				_staged = null;
			}
			GUIHelper.Space(4f);
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = (Color)(HasChanges ? new Color(GUIHelper.ColConfirm.r * 0.5f, GUIHelper.ColConfirm.g * 0.5f, GUIHelper.ColConfirm.b * 0.5f) : GUIHelper.ColSurface1);
			if (GUILayout.Button(Loc.T("Apply"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(26f),
				GUILayout.MinWidth(GUIHelper.Scaled(100f))
			}))
			{
				PackManager.Apply(_staged);
				_staged = null;
			}
			GUI.backgroundColor = backgroundColor;
			GUILayout.EndHorizontal();
			GUI.enabled = true;
		}

		private static void DrawFooter()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			GUIHelper.DrawSeparator();
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = (Color)(Plugin.ShowStatusOverlay ? new Color(GUIHelper.ColConfirm.r * 0.35f, GUIHelper.ColConfirm.g * 0.35f, GUIHelper.ColConfirm.b * 0.35f) : GUIHelper.ColSurface1);
			if (GUILayout.Button(Plugin.ShowStatusOverlay ? Loc.T("Status Overlay: ON") : Loc.T("Status Overlay: OFF"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
			{
				Plugin.ShowStatusOverlay = !Plugin.ShowStatusOverlay;
			}
			GUI.backgroundColor = backgroundColor;
			GUIHelper.Space(4f);
			if (GUILayout.Button(Loc.T("Language") + ": " + Loc.NativeName(Plugin.Config.UILanguage.ToLowerInvariant()), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width(150f)
			}))
			{
				Loc.CycleLanguage();
			}
			GUIHelper.Space(4f);
			backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = new Color(GUIHelper.ColPop2.r * 0.4f, GUIHelper.ColPop2.g * 0.4f, GUIHelper.ColPop2.b * 0.4f);
			GUI.contentColor = GUIHelper.ColPop2;
			if (GUILayout.Button("⚒", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(28f),
				GUIHelper.Height(24f)
			}))
			{
				DevHub.OpenAt(1);
			}
			GUI.backgroundColor = backgroundColor;
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
		}

		private static void EnsureStaged()
		{
			if (_staged == null)
			{
				_staged = PackManager.AllPacks.Select((PackInfo p) => p.Clone()).ToList();
			}
		}

		private static List<List<int>> BuildClauses(List<PackCondition> conds)
		{
			List<List<int>> list = new List<List<int>>();
			if (conds.Count == 0)
			{
				return list;
			}
			List<int> list2 = new List<int> { 0 };
			for (int i = 0; i < conds.Count - 1; i++)
			{
				if (conds[i].JoinNext == LogicJoin.And)
				{
					list2.Add(i + 1);
					continue;
				}
				list.Add(list2);
				list2 = new List<int> { i + 1 };
			}
			list.Add(list2);
			return list;
		}

		private static void DrawConditionContent(PackInfo pack, int ci, ref int removeAt)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			PackCondition packCondition = pack.Conditions[ci];
			string text = $"Stitchwork.CondType.{pack.Path}.{ci}";
			bool flag = _openDropdownId == text;
			if (flag)
			{
				GUI.contentColor = kJoinHl;
			}
			if (GUILayout.Button(packCondition.TypeLabel, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(62f) }))
			{
				_openDropdownId = (flag ? null : text);
			}
			GUI.contentColor = Color.white;
			if (GUILayout.Button(packCondition.Negate ? "!=" : "==", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(30f) }))
			{
				packCondition.Negate = !packCondition.Negate;
				PackManager.SaveConditions();
			}
			if (packCondition.Type == ConditionType.CrestEquipped)
			{
				string text2 = $"Stitchwork.CrestVal.{pack.Path}.{ci}";
				bool flag2 = _openDropdownId == text2;
				string text3 = PackCondition.CrestDisplayName(packCondition.Value);
				if (flag2)
				{
					GUI.contentColor = kJoinHl;
				}
				if (GUILayout.Button(text3, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(146f) }))
				{
					_openDropdownId = (flag2 ? null : text2);
				}
				GUI.contentColor = Color.white;
			}
			else if (packCondition.Type == ConditionType.NailUpgrade)
			{
				string text4 = $"Stitchwork.NailVal.{pack.Path}.{ci}";
				bool flag3 = _openDropdownId == text4;
				string text5 = PackCondition.NailDisplayValue(packCondition.Value);
				if (flag3)
				{
					GUI.contentColor = kJoinHl;
				}
				if (GUILayout.Button(text5, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(146f) }))
				{
					_openDropdownId = (flag3 ? null : text4);
				}
				GUI.contentColor = Color.white;
			}
			else if (packCondition.Type == ConditionType.PlayerData)
			{
				string text6 = $"Stitchwork.PdVal.{pack.Path}.{ci}";
				bool flag4 = _openDropdownId == text6;
				if (!string.IsNullOrEmpty(packCondition.Value))
				{
					_ = packCondition.Value.Split(' ')[0];
				}
				if (flag4)
				{
					GUI.contentColor = kJoinHl;
				}
				if (GUILayout.Button("…", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(28f) }))
				{
					_openDropdownId = (flag4 ? null : text6);
				}
				GUI.contentColor = Color.white;
				string text7 = GUIHelper.TextField($"Stitchwork.PdExpr.{pack.Path}.{ci}", packCondition.Value, GUIHelper.Width(114f));
				if (text7 != packCondition.Value)
				{
					packCondition.Value = text7;
					PackManager.SaveConditions();
				}
			}
			else
			{
				string text8 = GUIHelper.TextField($"Stitchwork.Cond.{pack.Path}.{ci}", packCondition.Value, GUIHelper.Width(146f));
				if (text8 != packCondition.Value)
				{
					packCondition.Value = text8;
					PackManager.SaveConditions();
				}
			}
			GUI.contentColor = GUIHelper.ColDanger;
			if (GUILayout.Button("×", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(22f) }))
			{
				removeAt = ci;
			}
			GUI.contentColor = Color.white;
		}

		private static void DrawDropdownIfOpen(PackInfo pack, int ci, float indent = 0f)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			string text = $"Stitchwork.CondType.{pack.Path}.{ci}";
			if (_openDropdownId != text)
			{
				return;
			}
			PackCondition packCondition = pack.Conditions[ci];
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (indent > 0f)
			{
				GUILayout.Space(indent);
			}
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			foreach (ConditionType value in Enum.GetValues(typeof(ConditionType)))
			{
				string text2 = PackCondition.LabelFor(value);
				if (packCondition.Type == value)
				{
					GUI.contentColor = kJoinHl;
				}
				if (GUILayout.Button(text2, GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
				{
					packCondition.Type = value;
					_openDropdownId = null;
					PackManager.SaveConditions();
				}
				GUI.contentColor = Color.white;
			}
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
		}

		private static void DrawNailValueDropdownIfOpen(PackInfo pack, int ci, float indent = 0f)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			string text = $"Stitchwork.NailVal.{pack.Path}.{ci}";
			if (_openDropdownId != text)
			{
				return;
			}
			PackCondition packCondition = pack.Conditions[ci];
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (indent > 0f)
			{
				GUILayout.Space(indent);
			}
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			(string, string)[] knownNailLevels = PackCondition.KnownNailLevels;
			for (int i = 0; i < knownNailLevels.Length; i++)
			{
				var (text2, text3) = knownNailLevels[i];
				if (string.Equals(packCondition.Value, text2, StringComparison.OrdinalIgnoreCase))
				{
					GUI.contentColor = kJoinHl;
				}
				if (GUILayout.Button(text3, GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
				{
					packCondition.Value = text2;
					_openDropdownId = null;
					PackManager.SaveConditions();
				}
				GUI.contentColor = Color.white;
			}
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
		}

		private static void DrawCrestValueDropdownIfOpen(PackInfo pack, int ci, float indent = 0f)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			string text = $"Stitchwork.CrestVal.{pack.Path}.{ci}";
			if (_openDropdownId != text)
			{
				return;
			}
			PackCondition packCondition = pack.Conditions[ci];
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (indent > 0f)
			{
				GUILayout.Space(indent);
			}
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			(string, string)[] knownCrests = PackCondition.KnownCrests;
			for (int i = 0; i < knownCrests.Length; i++)
			{
				var (text2, text3) = knownCrests[i];
				if (string.Equals(packCondition.Value, text2, StringComparison.OrdinalIgnoreCase))
				{
					GUI.contentColor = kJoinHl;
				}
				if (GUILayout.Button(text3, GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
				{
					packCondition.Value = text2;
					_openDropdownId = null;
					PackManager.SaveConditions();
				}
				GUI.contentColor = Color.white;
			}
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
		}

		private static void DrawPdDropdownIfOpen(PackInfo pack, int ci, float indent = 0f)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			string text = $"Stitchwork.PdVal.{pack.Path}.{ci}";
			if (_openDropdownId != text)
			{
				return;
			}
			PackCondition packCondition = pack.Conditions[ci];
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (indent > 0f)
			{
				GUILayout.Space(indent);
			}
			GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(280f) });
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(Loc.T("Search:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(52f) });
			string text2 = GUIHelper.TextField("Stitchwork.PdSearch", _pdSearch, GUIHelper.Width(200f));
			if (text2 != _pdSearch)
			{
				_pdSearch = text2;
				_pdScrollPos = Vector2.zero;
			}
			GUILayout.EndHorizontal();
			IEnumerable<PlayerDataCatalog.Entry> enumerable = PlayerDataCatalog.Search(_pdSearch);
			int num = 0;
			_pdScrollPos = GUILayout.BeginScrollView(_pdScrollPos, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(272f),
				GUILayout.Height(200f)
			});
			foreach (PlayerDataCatalog.Entry item in enumerable)
			{
				if (num++ >= 60)
				{
					break;
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUI.contentColor = GUIHelper.ColPop2;
				GUILayout.Label("[" + item.TypeLabel + "]", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(44f) });
				GUI.contentColor = Color.white;
				if (GUILayout.Button(item.Name, GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
				{
					packCondition.Value = ((item.FieldType == typeof(bool)) ? item.Name : (item.Name + " >= "));
					_openDropdownId = null;
					PackManager.SaveConditions();
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
		}

		private static void DrawConditionEditor(PackInfo pack)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(Loc.T("Reload:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(50f) });
			if (pack.ReloadTrigger == ReloadTrigger.OnSceneTransition)
			{
				GUI.contentColor = GUIHelper.ColAccent;
			}
			if (GUILayout.Button(Loc.T("on scene"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(72f) }))
			{
				pack.ReloadTrigger = ReloadTrigger.OnSceneTransition;
				PackManager.SaveConditions();
			}
			GUI.contentColor = Color.white;
			if (pack.ReloadTrigger == ReloadTrigger.HotReload)
			{
				GUI.contentColor = GUIHelper.ColAccent;
			}
			if (GUILayout.Button(Loc.T("hot reload"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(80f) }))
			{
				pack.ReloadTrigger = ReloadTrigger.HotReload;
				PackManager.SaveConditions();
			}
			GUI.contentColor = Color.white;
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUIHelper.Space(2f);
			List<List<int>> list = BuildClauses(pack.Conditions);
			int removeAt = -1;
			for (int i = 0; i < list.Count; i++)
			{
				List<int> list2 = list[i];
				bool num = i == 0;
				int index = (num ? (-1) : (list2[0] - 1));
				bool flag = list2.Count > 1;
				if (!num)
				{
					GUIHelper.Space(3f);
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUILayout.Space(10f);
					GUI.contentColor = kJoinHl;
					if (GUILayout.Button(Loc.T("OR"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(38f) }))
					{
						pack.Conditions[index].JoinNext = LogicJoin.And;
						PackManager.SaveConditions();
					}
					GUI.contentColor = Color.white;
					GUILayout.EndHorizontal();
					GUIHelper.Space(3f);
				}
				if (flag)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					Color backgroundColor = GUI.backgroundColor;
					GUI.backgroundColor = new Color(GUIHelper.ColPop2.r, GUIHelper.ColPop2.g, GUIHelper.ColPop2.b, 0.85f);
					GUILayout.Box("", BracketStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(4f),
						GUILayout.ExpandHeight(true)
					});
					GUI.backgroundColor = backgroundColor;
					GUILayout.Space(6f);
					GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
					for (int j = 0; j < list2.Count; j++)
					{
						int num2 = list2[j];
						int index2 = num2 - 1;
						if (j > 0)
						{
							GUIHelper.Space(2f);
							GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
							GUI.contentColor = kJoinHl;
							if (GUILayout.Button(Loc.T("AND"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(38f) }))
							{
								pack.Conditions[index2].JoinNext = LogicJoin.Or;
								PackManager.SaveConditions();
							}
							GUI.contentColor = Color.white;
							GUILayout.EndHorizontal();
							GUIHelper.Space(2f);
						}
						GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
						DrawConditionContent(pack, num2, ref removeAt);
						GUILayout.EndHorizontal();
						DrawDropdownIfOpen(pack, num2);
						DrawCrestValueDropdownIfOpen(pack, num2);
						DrawNailValueDropdownIfOpen(pack, num2);
						DrawPdDropdownIfOpen(pack, num2);
					}
					GUILayout.EndVertical();
					GUILayout.EndHorizontal();
				}
				else
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUILayout.Space(10f);
					DrawConditionContent(pack, list2[0], ref removeAt);
					GUILayout.EndHorizontal();
					DrawDropdownIfOpen(pack, list2[0], 10f);
					DrawCrestValueDropdownIfOpen(pack, list2[0], 10f);
					DrawNailValueDropdownIfOpen(pack, list2[0], 10f);
					DrawPdDropdownIfOpen(pack, list2[0], 10f);
				}
			}
			if (removeAt >= 0)
			{
				pack.Conditions.RemoveAt(removeAt);
				PackManager.SaveConditions();
			}
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Space(10f);
			GUI.contentColor = new Color(GUIHelper.ColPop1.r, GUIHelper.ColPop1.g, GUIHelper.ColPop1.b, 0.85f);
			if (GUILayout.Button("+ Add A New Condition", GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				pack.Conditions.Add(new PackCondition());
				PackManager.SaveConditions();
			}
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			GUIHelper.Space(2f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button(Loc.T("Done"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(50f) }))
			{
				_conditionsOpen.Remove(pack.Path);
				_openDropdownId = null;
			}
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		private static void DrawProfilesSection()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			GUIHelper.DrawSeparator();
			GUIHelper.Space(4f);
			GUILayout.Label(Loc.T("Profiles"), GUIHelper.SectionHeaderStyle, Array.Empty<GUILayoutOption>());
			string[] profileNames = PackManager.GetProfileNames();
			if (profileNames.Length != 0)
			{
				_profilesScroll = GUILayout.BeginScrollView(_profilesScroll, false, false, GUI.skin.horizontalScrollbar, GUIStyle.none, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(28f) });
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string[] array = profileNames;
				foreach (string text in array)
				{
					if (GUILayout.Button(text, GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
					{
						List<PackInfo> list = PackManager.StageProfile(text);
						if (list != null)
						{
							_staged = list;
						}
					}
					if (GUILayout.Button("✕", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(24f) }))
					{
						PackManager.DeleteProfile(text);
					}
				}
				GUILayout.EndHorizontal();
				GUILayout.EndScrollView();
			}
			else
			{
				GUILayout.Label("  " + Loc.T("No saved profiles."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(Loc.T("Save as:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(58f) });
			_profileNameInput = GUIHelper.TextField("PackManagerProfileName", _profileNameInput, GUIHelper.Width(140f));
			GUI.enabled = !string.IsNullOrWhiteSpace(_profileNameInput);
			if (GUILayout.Button(Loc.T("Save"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(50f) }))
			{
				PackManager.SaveProfile(_profileNameInput.Trim());
				_profileNameInput = "";
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
		}

		private static void DrawConflictsSection()
		{
			int total = ConflictTracker.Total;
			GUIHelper.DrawSeparator();
			GUIHelper.Space(4f);
			if (GUILayout.Button((total == 0) ? Loc.T("Conflicts: none") : string.Format(Loc.T("Conflicts: {0}"), total), GUIHelper.SectionHeaderStyle, Array.Empty<GUILayoutOption>()))
			{
				_conflictsFoldout = !_conflictsFoldout;
			}
			if (!_conflictsFoldout || total == 0)
			{
				return;
			}
			foreach (ConflictTracker.Entry item in ConflictTracker.All)
			{
				string packName = PackManager.GetPackName(item.WinnerPack);
				string packName2 = PackManager.GetPackName(item.LoserPack);
				GUILayout.Label("  [" + item.Type + "] " + item.Key + "\n    " + packName + "  >  " + packName2, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			}
		}
	}
	internal static class ReloadToast
	{
		public enum Kind
		{
			Sprite,
			Atlas,
			T2D,
			Audio,
			Text,
			Font
		}

		private const int NameCap = 3;

		private const float ShowSeconds = 4f;

		private static readonly object _lock = new object();

		private static readonly Dictionary<Kind, List<string>> _changed = new Dictionary<Kind, List<string>>();

		private static readonly List<string> _spriteNames = new List<string>();

		private static bool _spriteFlushPending;

		private static string _title;

		private static string _body;

		private static Color _titleColor;

		private static float _until;

		public static void Record(Kind kind, string fullPath, string spriteName = null)
		{
			lock (_lock)
			{
				if (!_changed.TryGetValue(kind, out var value))
				{
					value = (_changed[kind] = new List<string>());
				}
				string fileName = Path.GetFileName(fullPath);
				if (!value.Contains(fileName))
				{
					value.Add(fileName);
				}
				if (spriteName != null && !_spriteNames.Contains(spriteName))
				{
					_spriteNames.Add(spriteName);
				}
			}
		}

		public static void ArmSpriteFlush()
		{
			_spriteFlushPending = true;
		}

		public static void TickSpriteFlush()
		{
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if (!_spriteFlushPending || SpriteLoader.IsReloadingSliced)
			{
				return;
			}
			_spriteFlushPending = false;
			List<string> list = new List<string>();
			List<string> list2;
			lock (_lock)
			{
				if (_changed.TryGetValue(Kind.Sprite, out var value))
				{
					list.AddRange(value);
					_changed.Remove(Kind.Sprite);
				}
				if (_changed.TryGetValue(Kind.Atlas, out var value2))
				{
					list.AddRange(value2);
					_changed.Remove(Kind.Atlas);
				}
				list2 = new List<string>(_spriteNames);
				_spriteNames.Clear();
			}
			if (list.Count == 0)
			{
				return;
			}
			int num = 0;
			List<string> list3 = new List<string>();
			foreach (string item in list2)
			{
				if (!SpriteLoader.WasSpriteDrawnThisCycle(item))
				{
					num++;
					if (list3.Count < 3)
					{
						list3.Add(item);
					}
				}
			}
			if (list2.Count > 0 && num == list2.Count)
			{
				Show(Loc.T("Not applied"), GUIHelper.ColWarn, string.Join(", ", list3) + ((num > 3) ? ", …" : "") + "\n" + Loc.T("not drawn — wrong name/folder, or that collection is not loaded in this scene"));
				return;
			}
			string text = Summarize(list);
			if (num > 0)
			{
				text = text + "\n" + string.Format(Loc.T("{0} not drawn"), num) + ": " + string.Join(", ", list3);
			}
			Show(Loc.T("Applied"), GUIHelper.ColConfirm, text);
		}

		public static void Flush(Kind kind, string kindLabel)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			List<string> value;
			lock (_lock)
			{
				if (!_changed.TryGetValue(kind, out value))
				{
					return;
				}
				_changed.Remove(kind);
			}
			if (value.Count != 0)
			{
				Show(string.Format(Loc.T("Reloaded ({0})"), kindLabel), GUIHelper.ColConfirm, Summarize(value));
			}
		}

		private static string Summarize(List<string> files)
		{
			if (files.Count > 3)
			{
				return string.Format(Loc.T("{0} file(s)"), files.Count) + " — " + string.Join(", ", files.GetRange(0, 3)) + ", …";
			}
			return string.Join(", ", files);
		}

		private static void Show(string title, Color color, string body)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_title = title;
			_titleColor = color;
			_body = body;
			_until = Time.realtimeSinceStartup + 4f;
		}

		public static void Draw()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			if (_title != null)
			{
				if (Time.realtimeSinceStartup > _until)
				{
					_title = null;
					return;
				}
				float num = GUIHelper.Scaled(440f);
				float num2 = GUIHelper.Scaled(74f);
				float num3 = GUIHelper.Scaled(16f);
				Rect val = default(Rect);
				((Rect)(ref val))..ctor((float)Screen.width - num - num3, (float)Screen.height - num2 - num3, num, num2);
				Color backgroundColor = GUI.backgroundColor;
				GUI.backgroundColor = new Color(0.08f, 0.08f, 0.1f, 0.92f);
				GUI.Box(val, "", GUI.skin.box);
				GUI.backgroundColor = backgroundColor;
				GUILayout.BeginArea(new Rect(((Rect)(ref val)).x + num3 * 0.75f, ((Rect)(ref val)).y + num3 * 0.4f, ((Rect)(ref val)).width - num3 * 1.5f, ((Rect)(ref val)).height - num3 * 0.8f));
				GUI.contentColor = _titleColor;
				GUILayout.Label(_title, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				GUILayout.Label(_body, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.EndArea();
			}
		}
	}
	public static class StatusOverlay
	{
		private const float PaddingH = 10f;

		private const float PaddingV = 6f;

		private const float BadgeH = 44f;

		private const float BottomMargin = 10f;

		private const float LeftMargin = 10f;

		private const float StripH = 2f;

		private static GUIStyle _labelStyle;

		private static GUIStyle _subtitleStyle;

		private static int _lastFontSize;

		private static int _lastSubtitleFontSize;

		private static int _cachedActivePacks = -1;

		private static int _cachedConflicts = -1;

		private static int _cachedSprites = -1;

		private static int _cachedClips = -1;

		private static int _cachedFontSize = -1;

		private static int _cachedLocGen = -1;

		private static string _cachedText = string.Empty;

		private static Vector2 _cachedTextSize;

		private static string _cachedSubtitleText = string.Empty;

		private static Vector2 _cachedSubtitleSize;

		private static int _cachedSubLocGen = -1;

		private static string _cachedSceneName = null;

		private static double _subtitleNextRefreshAt = -1.0;

		private const double SubtitleRefreshSeconds = 5.0;

		private const float DominantPackMinShare = 0.4f;

		public static void Draw()
		{
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			EnsureStyles();
			int num = 0;
			IReadOnlyList<PackInfo> allPacks = PackManager.AllPacks;
			for (int i = 0; i < allPacks.Count; i++)
			{
				if (allPacks[i].IsEnabled)
				{
					num++;
				}
			}
			int total = ConflictTracker.Total;
			int loadedSpriteCount = SpriteLoader.LoadedSpriteCount;
			int cachedClipCount = AudioHandler.CachedClipCount;
			if (num != _cachedActivePacks || total != _cachedConflicts || loadedSpriteCount != _cachedSprites || cachedClipCount != _cachedClips || _lastFontSize != _cachedFontSize || Loc.Generation != _cachedLocGen)
			{
				string text = "<color=#33AA88>■ " + string.Format(Loc.T((num != 1) ? "{0} packs" : "{0} pack"), num) + "</color>";
				string text2 = "<color=#8C8CA6>" + string.Format(Loc.T("{0} sprites"), loadedSpriteCount) + "  |  " + string.Format(Loc.T("{0} clips"), cachedClipCount) + "</color>";
				_cachedText = ((total > 0) ? (text + "  <color=#FFBF33>⚠ " + string.Format(Loc.T((total != 1) ? "{0} conflicts" : "{0} conflict"), total) + "</color>  " + text2) : (text + "  " + text2));
				_cachedTextSize = _labelStyle.CalcSize(new GUIContent(_cachedText));
				_cachedActivePacks = num;
				_cachedConflicts = total;
				_cachedSprites = loadedSpriteCount;
				_cachedClips = cachedClipCount;
				_cachedFontSize = _lastFontSize;
				_cachedLocGen = Loc.Generation;
			}
			UpdateSubtitleIfDue(allPacks);
			float x = _cachedTextSize.x;
			float x2 = _cachedSubtitleSize.x;
			float num2 = Mathf.Max(x, x2);
			float num3 = num2 + GUIHelper.Scaled(20f);
			float num4 = GUIHelper.Scaled(44f);
			float num5 = GUIHelper.Scaled(10f);
			float num6 = (float)Screen.height - num4 - GUIHelper.Scaled(10f);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(num5, num6, num3, num4);
			GUI.color = new Color(GUIHelper.ColSurface.r, GUIHelper.ColSurface.g, GUIHelper.ColSurface.b, 0.88f);
			GUI.DrawTexture(val, (Texture)(object)Texture2D.whiteTexture);
			GUIHelper.DrawCassetteStripHorizontal(val, 2f);
			GUI.color = Color.white;
			float num7 = num5 + GUIHelper.Scaled(10f);
			float num8 = num2;
			float num9 = GUIHelper.Scaled(20f);
			float num10 = GUIHelper.Scaled(15f);
			GUI.Label(new Rect(num7, num6 + GUIHelper.Scaled(4f), num8, num9), _cachedText, _labelStyle);
			if (!string.IsNullOrEmpty(_cachedSubtitleText))
			{
				GUI.Label(new Rect(num7, num6 + GUIHelper.Scaled(4f) + num9, num8, num10), _cachedSubtitleText, _subtitleStyle);
			}
			if (GUI.Button(val, GUIContent.none, GUIStyle.none))
			{
				if (Plugin.Config.UseCanvasPackManager)
				{
					CanvasPackManager.Show();
				}
				else
				{
					Plugin.ShowPackManager = true;
				}
			}
		}

		private static void UpdateSubtitleIfDue(IReadOnlyList<PackInfo> allPacks)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name ?? "";
			bool num = text != _cachedSceneName;
			bool flag = (double)Time.realtimeSinceStartup >= _subtitleNextRefreshAt;
			bool flag2 = _subtitleStyle != null && _lastSubtitleFontSize != _subtitleStyle.fontSize;
			bool flag3 = Loc.Generation != _cachedSubLocGen;
			if (!num && !flag && !flag2 && !flag3)
			{
				return;
			}
			_cachedSceneName = text;
			_cachedSubLocGen = Loc.Generation;
			_subtitleNextRefreshAt = (double)Time.realtimeSinceStartup + 5.0;
			string text2 = null;
			if (T2DLoader.ReplacedRendererCount > 0 && allPacks != null)
			{
				Dictionary<string, int> dictionary = T2DLoader.CountActiveRenderersByPack();
				if (dictionary.Count > 0)
				{
					int num2 = 0;
					string text3 = null;
					int num3 = 0;
					foreach (KeyValuePair<string, int> item in dictionary)
					{
						num2 += item.Value;
						if (item.Value > num3)
						{
							num3 = item.Value;
							text3 = item.Key;
						}
					}
					if (text3 != null && num2 > 0)
					{
						float num4 = (float)num3 / (float)num2;
						if (num4 >= 0.4f)
						{
							string arg = text3;
							for (int i = 0; i < allPacks.Count; i++)
							{
								if (string.Equals(allPacks[i].Path, text3, StringComparison.OrdinalIgnoreCase))
								{
									arg = allPacks[i].Name;
									break;
								}
							}
							int num5 = Mathf.RoundToInt(num4 * 100f);
							text2 = $"{arg} ({num5}%)";
						}
					}
				}
			}
			string text4 = null;
			int atlasRTCount = SpriteLoader.AtlasRTCount;
			if (atlasRTCount > 0)
			{
				int num6 = (int)(SpriteLoader.AtlasVramBytes / 1048576);
				text4 = string.Format(Loc.T((atlasRTCount == 1) ? "{0} atlas RT ~{1} MB" : "{0} atlas RTs ~{1} MB"), atlasRTCount, num6);
			}
			string value = (string.IsNullOrEmpty(text) ? Loc.T("(no scene)") : text);
			StringBuilder stringBuilder = new StringBuilder("<color=#8C8CA6>");
			stringBuilder.Append(value);
			if (text2 != null)
			{
				stringBuilder.Append("  ·  ").Append(string.Format(Loc.T("mostly {0}"), text2));
			}
			if (text4 != null)
			{
				stringBuilder.Append("  ·  ").Append(text4);
			}
			stringBuilder.Append("</color>");
			_cachedSubtitleText = stringBuilder.ToString();
			_cachedSubtitleSize = _subtitleStyle.CalcSize(new GUIContent(_cachedSubtitleText));
			_lastSubtitleFontSize = _subtitleStyle.fontSize;
		}

		private static void EnsureStyles()
		{
			//IL_0021: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			int num = GUIHelper.FontSize(13);
			if (_labelStyle == null || _lastFontSize != num)
			{
				_labelStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = num,
					alignment = (TextAnchor)0,
					richText = true
				};
				_lastFontSize = num;
			}
			int num2 = GUIHelper.FontSize(11);
			if (_subtitleStyle == null || _subtitleStyle.fontSize != num2)
			{
				_subtitleStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = num2,
					alignment = (TextAnchor)0,
					richText = true
				};
			}
		}
	}
	public static class T2DLog
	{
		internal class T2DLogEntry
		{
			public string RawTexName;

			public string CleanTexName;

			public int AtlasIndex;

			public string LastSpriteName;

			public DateTime LogTime;

			public DateTime? BumpedTime;

			public float GetFadeOpacity(double fadeDuration)
			{
				if (!BumpedTime.HasValue)
				{
					return 1f;
				}
				double totalSeconds = (DateTime.Now - BumpedTime.Value).TotalSeconds;
				if (!(totalSeconds >= fadeDuration))
				{
					return 1f - (float)(totalSeconds / fadeDuration);
				}
				return 0f;
			}

			public bool IsFadedOut(double fadeDuration)
			{
				if (!BumpedTime.HasValue)
				{
					return false;
				}
				return (DateTime.Now - BumpedTime.Value).TotalSeconds >= fadeDuration;
			}
		}

		private static readonly List<T2DLogEntry> _entries = new List<T2DLogEntry>();

		private static readonly Dictionary<string, T2DLogEntry> _lookup = new Dictionary<string, T2DLogEntry>(StringComparer.Ordinal);

		private const double ReBumpCooldownSeconds = 2.0;

		public static int EntryCount => _entries.Count;

		public static void DrawEntries(int maxVisible, double fadeDuration, Action<string, string> onEntryClick)
		{
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			UpdateLifecycle(maxVisible, fadeDuration);
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			foreach (T2DLogEntry entry in _entries)
			{
				dictionary.TryGetValue(entry.CleanTexName, out var value);
				dictionary[entry.CleanTexName] = value + 1;
			}
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			for (int i = 0; i < _entries.Count; i++)
			{
				T2DLogEntry t2DLogEntry = _entries[i];
				float num = ((i < maxVisible) ? 1f : t2DLogEntry.GetFadeOpacity(fadeDuration));
				GUI.contentColor = new Color(1f, 1f, 1f, num);
				string text = ((dictionary[t2DLogEntry.CleanTexName] > 1 && t2DLogEntry.AtlasIndex >= 0) ? $"{t2DLogEntry.CleanTexName}-{t2DLogEntry.AtlasIndex}" : t2DLogEntry.CleanTexName);
				if (GUILayout.Button(string.IsNullOrEmpty(t2DLogEntry.LastSpriteName) ? text : (text + " / " + t2DLogEntry.LastSpriteName), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>()))
				{
					onEntryClick?.Invoke(t2DLogEntry.RawTexName, t2DLogEntry.LastSpriteName);
				}
			}
			if (_entries.Count == 0)
			{
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label("No T2D textures triggered yet.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			}
			GUI.contentColor = Color.white;
			GUILayout.EndVertical();
		}

		public static void LogTrigger(string rawTexName, string cleanTexName, string spriteName)
		{
			if (string.IsNullOrEmpty(rawTexName))
			{
				return;
			}
			if (_lookup.TryGetValue(rawTexName, out var value))
			{
				if (!string.IsNullOrEmpty(spriteName))
				{
					value.LastSpriteName = spriteName;
				}
				if (!((DateTime.Now - value.LogTime).TotalSeconds < 2.0))
				{
					_entries.Remove(value);
					value.LogTime = DateTime.Now;
					value.BumpedTime = null;
					_entries.Insert(0, value);
				}
			}
			else
			{
				T2DLogEntry t2DLogEntry = new T2DLogEntry
				{
					RawTexName = rawTexName,
					CleanTexName = (cleanTexName ?? rawTexName),
					AtlasIndex = T2DUtil.AtlasIndexFromRaw(rawTexName),
					LastSpriteName = (spriteName ?? ""),
					LogTime = DateTime.Now,
					BumpedTime = null
				};
				_entries.Insert(0, t2DLogEntry);
				_lookup[rawTexName] = t2DLogEntry;
			}
		}

		public static void ClearLog()
		{
			_entries.Clear();
			_lookup.Clear();
			T2DLoader.ResetLogScanState();
		}

		private static void UpdateLifecycle(int maxVisible, double fadeDuration)
		{
			for (int num = _entries.Count - 1; num >= maxVisible; num--)
			{
				if (_entries[num].IsFadedOut(fadeDuration))
				{
					_entries.RemoveAt(num);
				}
			}
			for (int i = maxVisible; i < _entries.Count; i++)
			{
				if (!_entries[i].BumpedTime.HasValue)
				{
					_entries[i].BumpedTime = DateTime.Now;
				}
			}
			for (int j = 0; j < Math.Min(maxVisible, _entries.Count); j++)
			{
				_entries[j].BumpedTime = null;
			}
		}
	}
	public static class T2DTextureController
	{
		private static List<T2DSceneEntry> _entries = new List<T2DSceneEntry>();

		private static bool _needsRefresh = true;

		private static T2DSceneEntry _selected;

		private static bool _hasSelection;

		private static string _selectedSprite = "";

		private static string _searchFilter = "";

		private static string _spriteFilter = "";

		private static Vector2 _listScroll;

		private static Vector2 _spriteScroll;

		private static string _pendingSelectTex = null;

		private static string _pendingSelectSprite = null;

		private static Texture2D _white;

		public static void SelectEntry(string rawTexName, string spriteName)
		{
			_pendingSelectTex = rawTexName;
			_pendingSelectSprite = spriteName ?? "";
			_needsRefresh = true;
		}

		public static void DrawPillarContent()
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if (_needsRefresh)
			{
				Refresh();
			}
			if (_pendingSelectTex != null)
			{
				T2DSceneEntry t2DSceneEntry = _entries.Find((T2DSceneEntry e) => string.Equals(e.RawName, _pendingSelectTex, StringComparison.Ordinal));
				if (t2DSceneEntry != null)
				{
					_selected = t2DSceneEntry;
					_hasSelection = true;
					_selectedSprite = _pendingSelectSprite;
					_spriteFilter = "";
					_searchFilter = "";
					int num = _entries.IndexOf(t2DSceneEntry);
					if (num > 0)
					{
						_listScroll = new Vector2(0f, Mathf.Max(0f, (float)num * GUIHelper.Scaled(22f) - GUIHelper.Scaled(44f)));
					}
					if (!string.IsNullOrEmpty(_selectedSprite))
					{
						int num2 = t2DSceneEntry.SpriteNames.OrderBy((string s) => s).ToList().FindIndex((string s) => string.Equals(s, _selectedSprite, StringComparison.Ordinal));
						if (num2 > 0)
						{
							_spriteScroll = new Vector2(0f, Mathf.Max(0f, (float)num2 * GUIHelper.Scaled(22f) - GUIHelper.Scaled(44f)));
						}
					}
				}
				else
				{
					Plugin.Logger.LogWarning((object)("[T2DView] Pick target '" + _pendingSelectTex + "' is not in the current entry list — the renderer likely despawned before the browser refreshed (transient particle). Selection dropped. Tip: pause with DebugMod while the effect is alive, then pick."));
				}
				_pendingSelectTex = null;
				_pendingSelectSprite = null;
			}
			if (GUILayout.Button(Loc.T("Pick texture in world"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				WorldPickMode.Enter(WorldPickMode.Preset.T2D);
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawListPane();
			DrawDetailPane();
			GUILayout.EndHorizontal();
		}

		private static void DrawListPane()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(GUIHelper.Scaled(220f)) });
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			_searchFilter = GUIHelper.TextField("T2DTex.Search", _searchFilter, GUILayout.ExpandWidth(true), GUIHelper.Height(22f));
			if (GUILayout.Button("↺", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(26f),
				GUIHelper.Height(22f)
			}))
			{
				_needsRefresh = true;
			}
			GUILayout.EndHorizontal();
			_listScroll = GUILayout.BeginScrollView(_listScroll, Array.Empty<GUILayoutOption>());
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			foreach (T2DSceneEntry entry in _entries)
			{
				if (string.IsNullOrEmpty(_searchFilter) || entry.DisplayName.IndexOf(_searchFilter, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					if (!entry.IsT2D && !flag3)
					{
						flag3 = true;
						GUIHelper.Space(6f);
						GUI.contentColor = new Color(0.55f, 0.55f, 0.55f);
						GUILayout.Label("── Standalone ──", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
						GUI.contentColor = Color.white;
					}
					if (entry.IsT2D)
					{
						flag = true;
					}
					else
					{
						flag2 = true;
					}
					DrawListRow(entry);
				}
			}
			if (!flag && !flag2)
			{
				GUI.contentColor = new Color(0.55f, 0.55f, 0.55f);
				GUILayout.Label(string.IsNullOrEmpty(_searchFilter) ? "No T2D textures tracked yet.\nLoad a save to populate." : "No matches.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
		}

		private static void DrawListRow(T2DSceneEntry entry)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			bool num = _hasSelection && _selected.RawName == entry.RawName;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (num)
			{
				GUI.contentColor = new Color(0.6f, 0.9f, 1f);
			}
			if (GUILayout.Button(entry.DisplayName, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
			{
				_selected = entry;
				_hasSelection = true;
				_selectedSprite = "";
				_spriteFilter = "";
			}
			GUI.contentColor = Color.white;
			GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
			GUILayout.Label($"{entry.Width}×{entry.Height}", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(70f) });
			GUI.contentColor = Color.white;
			if (entry.HasSpritesheetOverride)
			{
				GUI.contentColor = new Color(0.4f, 1f, 0.4f);
				GUILayout.Label("[S]", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(22f) });
				GUI.contentColor = Color.white;
			}
			else if (entry.LoadedIndividualCount > 0)
			{
				GUI.contentColor = new Color(0.4f, 0.85f, 1f);
				GUILayout.Label($"[{entry.LoadedIndividualCount}]", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(28f) });
				GUI.contentColor = Color.white;
			}
			else
			{
				GUILayout.Space(GUIHelper.Scaled(28f));
			}
			GUILayout.EndHorizontal();
		}

		private static void DrawDetailPane()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_046f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			if (!_hasSelection || (Object)(object)_selected.NativeTexture == (Object)null)
			{
				GUI.contentColor = new Color(0.55f, 0.55f, 0.55f);
				GUILayout.Label("Select a texture on the left.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				GUILayout.EndVertical();
				return;
			}
			T2DSceneEntry selected = _selected;
			float num = GUIHelper.Scaled(185f);
			bool flag = !string.IsNullOrEmpty(_selectedSprite);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num) });
			Rect rect = GUILayoutUtility.GetRect(num, num, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.Height(num)
			});
			GUIHelper.DrawPreviewBackdrop(rect);
			if ((Object)(object)selected.NativeTexture != (Object)null)
			{
				GUI.DrawTexture(rect, selected.NativeTexture, (ScaleMode)2, true);
				if (flag)
				{
					DrawSpriteHighlight(rect, selected, _selectedSprite);
				}
			}
			GUI.contentColor = new Color(0.5f, 0.5f, 0.5f);
			GUILayout.Label("Atlas", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUILayout.EndVertical();
			GUILayout.FlexibleSpace();
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(num) });
			Rect rect2 = GUILayoutUtility.GetRect(num, num, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(num),
				GUILayout.Height(num)
			});
			if (flag)
			{
				GUIHelper.DrawPreviewBackdrop(rect2);
				DrawSpritePreview(rect2, selected, _selectedSprite);
			}
			else
			{
				GUI.color = new Color(1f, 1f, 1f, 0.06f);
				GUI.DrawTexture(rect2, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = Color.white;
			}
			GUI.contentColor = new Color(0.5f, 0.5f, 0.5f);
			GUILayout.Label(flag ? "Sprite" : "Sprite — select below", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
			GUIHelper.DrawBackdropSliderRow();
			GUIHelper.Space(4f);
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label($"{selected.DisplayName}  {selected.Width}×{selected.Height}  " + $"{selected.SpriteNames.Count} sprite(s)", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Dump Atlas"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				DumpAtlasOnly(selected);
			}
			if (GUILayout.Button(Loc.T("Dump All Sprites"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				DumpAllSprites(selected);
			}
			GUI.enabled = flag;
			if (GUILayout.Button(Loc.T("Dump Sprite"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				DumpSingleSprite(selected, _selectedSprite);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			bool flag2 = selected.SpriteNames.Count == 0;
			GUI.enabled = flag || flag2;
			bool flag3 = false;
			string loadDir;
			string dumpPath;
			string loadDir2;
			if (flag)
			{
				ResolveSpritePaths(selected, _selectedSprite, out loadDir, out var loadPath, out dumpPath, out loadDir2);
				flag3 = File.Exists(loadPath);
			}
			else if (flag2)
			{
				ResolveTexturePaths(selected, out loadDir2, out var loadPath2);
				flag3 = File.Exists(loadPath2);
			}
			if (GUILayout.Button(flag3 ? Loc.T("Edit (opens your file)") : Loc.T("Edit (new from vanilla)"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				if (flag)
				{
					EditSprite(selected, _selectedSprite);
				}
				else
				{
					EditTexture(selected);
				}
			}
			if (GUILayout.Button(Loc.T("Folder"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(70f),
				GUIHelper.Height(22f)
			}))
			{
				string loadDir3;
				if (flag)
				{
					ResolveSpritePaths(selected, _selectedSprite, out loadDir3, out loadDir2, out dumpPath, out loadDir);
				}
				else
				{
					ResolveTexturePaths(selected, out loadDir3, out loadDir);
				}
				IOUtil.OpenDeepestExisting(loadDir3);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.55f, 0.55f, 0.55f);
			GUILayout.Label($"Sprites ({selected.SpriteNames.Count})", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUI.contentColor = Color.white;
			_spriteFilter = GUIHelper.TextField("T2DTex.SpriteFilter", _spriteFilter, GUILayout.ExpandWidth(true), GUIHelper.Height(20f));
			GUI.enabled = !string.IsNullOrEmpty(_spriteFilter);
			if (GUILayout.Button("x", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(22f),
				GUIHelper.Height(20f)
			}))
			{
				_spriteFilter = "";
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			IOrderedEnumerable<string> orderedEnumerable = (string.IsNullOrEmpty(_spriteFilter) ? selected.SpriteNames.OrderBy((string s) => s) : (from s in selected.SpriteNames
				where s.IndexOf(_spriteFilter, StringComparison.OrdinalIgnoreCase) >= 0
				orderby s
				select s));
			_spriteScroll = GUILayout.BeginScrollView(_spriteScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			foreach (string item in orderedEnumerable)
			{
				bool flag4 = item == _selectedSprite;
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (flag4)
				{
					GUI.contentColor = new Color(1f, 1f, 0.5f);
				}
				if (GUILayout.Button(item, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
				{
					_selectedSprite = (flag4 ? "" : item);
				}
				if (flag4)
				{
					GUI.contentColor = Color.white;
				}
				GUI.enabled = !string.IsNullOrEmpty(item);
				if (GUILayout.Button("Edit", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(42f),
					GUIHelper.Height(20f)
				}))
				{
					EditSprite(selected, item);
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
		}

		private static void DrawSpriteHighlight(Rect previewRect, T2DSceneEntry entry, string spriteName)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			Sprite val = T2DLoader.FindSceneSprite(entry.RawName, spriteName);
			if ((Object)(object)val == (Object)null || (Object)(object)val.texture == (Object)null)
			{
				return;
			}
			float num = ((Texture)val.texture).width;
			float num2 = ((Texture)val.texture).height;
			if (!(num <= 0f) && !(num2 <= 0f))
			{
				Rect textureRect = val.textureRect;
				float num3 = ((Rect)(ref textureRect)).x / num;
				float num4 = 1f - (((Rect)(ref textureRect)).y + ((Rect)(ref textureRect)).height) / num2;
				float num5 = ((Rect)(ref textureRect)).width / num;
				float num6 = ((Rect)(ref textureRect)).height / num2;
				Rect val2 = ScaleToFitRect(previewRect, entry.Width, entry.Height);
				Rect val3 = new Rect(((Rect)(ref val2)).x + num3 * ((Rect)(ref val2)).width, ((Rect)(ref val2)).y + num4 * ((Rect)(ref val2)).height, num5 * ((Rect)(ref val2)).width, num6 * ((Rect)(ref val2)).height);
				if ((Object)(object)_white == (Object)null)
				{
					_white = new Texture2D(1, 1);
					_white.SetPixel(0, 0, Color.white);
					_white.Apply();
				}
				GUI.color = new Color(1f, 1f, 0f, 0.35f);
				GUI.DrawTexture(val3, (Texture)(object)_white);
				GUI.color = Color.white;
			}
		}

		private static void DrawSpritePreview(Rect rect, T2DSceneEntry entry, string spriteName)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			Sprite val = T2DLoader.FindSceneSprite(entry.RawName, spriteName);
			if ((Object)(object)val == (Object)null || (Object)(object)val.texture == (Object)null)
			{
				GUI.contentColor = new Color(0.45f, 0.45f, 0.45f);
				GUI.DrawTexture(rect, (Texture)(object)Texture2D.blackTexture, (ScaleMode)0);
				GUI.contentColor = Color.white;
				return;
			}
			float num = ((Texture)val.texture).width;
			float num2 = ((Texture)val.texture).height;
			if (!(num <= 0f) && !(num2 <= 0f))
			{
				Rect textureRect = val.textureRect;
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(((Rect)(ref textureRect)).x / num, ((Rect)(ref textureRect)).y / num2, ((Rect)(ref textureRect)).width / num, ((Rect)(ref textureRect)).height / num2);
				GUI.DrawTextureWithTexCoords(ScaleToFitRect(rect, (int)((Rect)(ref textureRect)).width, (int)((Rect)(ref textureRect)).height), (Texture)(object)val.texture, val2, true);
			}
		}

		private static Rect ScaleToFitRect(Rect container, int texW, int texH)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (texW <= 0 || texH <= 0)
			{
				return container;
			}
			float num = ((Rect)(ref container)).width / (float)texW;
			float num2 = ((Rect)(ref container)).height / (float)texH;
			float num3 = Mathf.Min(num, num2);
			float num4 = (float)texW * num3;
			float num5 = (float)texH * num3;
			return new Rect(((Rect)(ref container)).x + (((Rect)(ref container)).width - num4) * 0.5f, ((Rect)(ref container)).y + (((Rect)(ref container)).height - num5) * 0.5f, num4, num5);
		}

		private static void ResolveSpritePaths(T2DSceneEntry entry, string spriteName, out string loadDir, out string loadPath, out string dumpPath, out string label)
		{
			if (entry.IsT2D)
			{
				loadDir = Path.Combine(SpriteLoader.LoadPath, "T2D", entry.CleanName);
				loadPath = Path.Combine(loadDir, spriteName + ".png");
				dumpPath = Path.Combine(T2DDumper.DumpPath, entry.CleanName, spriteName + ".png");
				label = entry.CleanName + "/" + spriteName;
			}
			else
			{
				string text = T2DUtil.SanitizeForFilesystem(entry.RawName);
				loadDir = Path.Combine(SpriteLoader.LoadPath, "T2D", "_standalone");
				loadPath = Path.Combine(loadDir, text + ".png");
				dumpPath = Path.Combine(T2DDumper.DumpPath, text + ".png");
				label = "_standalone/" + text;
			}
		}

		private static void EditSprite(T2DSceneEntry entry, string spriteName)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			ResolveSpritePaths(entry, spriteName, out var loadDir, out var loadPath, out var dumpPath, out var label);
			Sprite val;
			if (!File.Exists(loadPath))
			{
				val = T2DLoader.FindSceneSprite(entry.RawName, spriteName);
				if (File.Exists(dumpPath) && (Object)(object)val != (Object)null)
				{
					(int width, int height) tuple = IOUtil.ReadPngDimensions(dumpPath);
					int item = tuple.width;
					int item2 = tuple.height;
					Rect rect = val.rect;
					if (item == (int)((Rect)(ref rect)).width)
					{
						rect = val.rect;
						if (item2 == (int)((Rect)(ref rect)).height)
						{
							goto IL_00e8;
						}
					}
					ManualLogSource logger = Plugin.Logger;
					string text = $"[T2DTex] Existing dump for '{label}' is {item}x{item2} but the live sprite rect is ";
					rect = val.rect;
					object arg = (int)((Rect)(ref rect)).width;
					rect = val.rect;
					logger.LogWarning((object)(text + $"{arg}x{(int)((Rect)(ref rect)).height} — stale (older game build?). Re-dumping."));
					File.Delete(IOUtil.LongSafe(dumpPath));
				}
				goto IL_00e8;
			}
			goto IL_014d;
			IL_00e8:
			if (!File.Exists(dumpPath))
			{
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Logger.LogError((object)("[T2DTex] Cannot find sprite '" + spriteName + "' to dump"));
					return;
				}
				T2DDumper.HandleDump(val);
			}
			if (!File.Exists(dumpPath))
			{
				Plugin.Logger.LogError((object)("[T2DTex] Dump failed for '" + label + "'"));
				return;
			}
			IOUtil.EnsureDirectoryExists(loadDir);
			File.Copy(dumpPath, loadPath, overwrite: true);
			goto IL_014d;
			IL_014d:
			IOUtil.OpenPath(loadPath);
		}

		private static void ResolveTexturePaths(T2DSceneEntry entry, out string loadDir, out string loadPath)
		{
			string text = (entry.IsT2D ? entry.CleanName : T2DUtil.SanitizeForFilesystem(entry.RawName));
			loadDir = Path.Combine(SpriteLoader.AtlasLoadPath, "T2D");
			loadPath = Path.Combine(loadDir, text + ".png");
		}

		private static void EditTexture(T2DSceneEntry entry)
		{
			ResolveTexturePaths(entry, out var loadDir, out var loadPath);
			if (!File.Exists(loadPath))
			{
				string text = Path.Combine(T2DDumper.DumpPath, entry.CleanName);
				string text2 = Path.Combine(text, $"_atlas_{entry.Width}x{entry.Height}.png");
				if (!File.Exists(text2))
				{
					Texture nativeTexture = entry.NativeTexture;
					Texture2D val = (Texture2D)(object)((nativeTexture is Texture2D) ? nativeTexture : null);
					if (val != null)
					{
						T2DDumper.DumpAtlasTexture(val);
					}
					else
					{
						BlitAndDumpAtlas(entry, text);
					}
				}
				if (!File.Exists(text2))
				{
					Plugin.Logger.LogError((object)("[T2DTex] Atlas dump failed for '" + entry.CleanName + "' — cannot create the edit file."));
					return;
				}
				IOUtil.EnsureDirectoryExists(loadDir);
				File.Copy(text2, loadPath, overwrite: true);
			}
			IOUtil.OpenPath(loadPath);
		}

		private static void DumpAtlasOnly(T2DSceneEntry entry)
		{
			Texture nativeTexture = entry.NativeTexture;
			Texture2D val = (Texture2D)(object)((nativeTexture is Texture2D) ? nativeTexture : null);
			if (val != null)
			{
				T2DDumper.DumpAtlasTexture(val);
			}
			else
			{
				BlitAndDumpAtlas(entry, Path.Combine(T2DDumper.DumpPath, entry.CleanName));
			}
			Plugin.Logger.LogInfo((object)("[T2DTex] Dumped atlas '" + entry.CleanName + "'"));
		}

		private static void DumpSingleSprite(T2DSceneEntry entry, string spriteName)
		{
			Sprite val = T2DLoader.FindSceneSprite(entry.RawName, spriteName);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogWarning((object)("[T2DTex] No live Sprite for '" + entry.CleanName + "/" + spriteName + "' — nothing to dump."));
			}
			else
			{
				T2DDumper.HandleDump(val);
				Plugin.Logger.LogInfo((object)("[T2DTex] Dumped sprite '" + entry.CleanName + "/" + spriteName + "'"));
			}
		}

		private static void DumpAllSprites(T2DSceneEntry entry)
		{
			int num = 0;
			foreach (string spriteName in entry.SpriteNames)
			{
				Sprite val = T2DLoader.FindSceneSprite(entry.RawName, spriteName);
				if (!((Object)(object)val == (Object)null))
				{
					T2DDumper.HandleDump(val);
					num++;
				}
			}
			Plugin.Logger.LogInfo((object)$"[T2DTex] Dumped {num} sprite(s) from '{entry.CleanName}'");
		}

		private static void BlitAndDumpAtlas(T2DSceneEntry entry, string dumpDir)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Texture nativeTexture = entry.NativeTexture;
			RenderTexture val = (RenderTexture)(object)((nativeTexture is RenderTexture) ? nativeTexture : null);
			if (!((Object)(object)val == (Object)null))
			{
				string path = Path.Combine(dumpDir, $"_atlas_{((Texture)val).width}x{((Texture)val).height}.png");
				if (!File.Exists(path))
				{
					RenderTexture active = RenderTexture.active;
					Texture2D val2 = new Texture2D(((Texture)val).width, ((Texture)val).height, (TextureFormat)4, false);
					RenderTexture.active = val;
					val2.ReadPixels(new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), 0, 0);
					val2.Apply();
					RenderTexture.active = active;
					IOUtil.EnsureDirectoryExists(dumpDir);
					File.WriteAllBytes(IOUtil.LongSafe(path), ImageConversion.EncodeToPNG(val2));
					Object.Destroy((Object)(object)val2);
				}
			}
		}

		private static void Refresh()
		{
			_needsRefresh = false;
			_entries = T2DLoader.GetSceneTextureEntries();
			Plugin.Logger.LogDebug((object)$"[T2DView] Refresh: {_entries.Count} entries");
			if (_hasSelection)
			{
				T2DSceneEntry t2DSceneEntry = _entries.Find((T2DSceneEntry e) => string.Equals(e.RawName, _selected.RawName, StringComparison.Ordinal));
				if (t2DSceneEntry != null)
				{
					_selected = t2DSceneEntry;
					return;
				}
				_hasSelection = false;
				_selectedSprite = "";
			}
		}

		public static void RequestRefresh()
		{
			_needsRefresh = true;
		}
	}
	public static class TextLog
	{
		internal class TextLogEntry
		{
			public string SheetName;

			public string KeyName;

			public string Text;

			public DateTime LogTime;

			public DateTime? BumpedTime;

			public float GetFadeOpacity(double fadeDuration)
			{
				if (!BumpedTime.HasValue)
				{
					return 1f;
				}
				double totalSeconds = (DateTime.Now - BumpedTime.Value).TotalSeconds;
				if (totalSeconds >= fadeDuration)
				{
					return 0f;
				}
				return 1f - (float)(totalSeconds / fadeDuration);
			}

			public bool IsFadedOut(double fadeDuration)
			{
				if (!BumpedTime.HasValue)
				{
					return false;
				}
				return (DateTime.Now - BumpedTime.Value).TotalSeconds >= fadeDuration;
			}
		}

		private static readonly List<TextLogEntry> TextLogEntries = new List<TextLogEntry>();

		private static readonly Dictionary<string, TextLogEntry> TextLogLookup = new Dictionary<string, TextLogEntry>();

		private static readonly int MaxPreviewLength = 50;

		private const int MaxEntries = 256;

		public static int EntryCount => TextLogEntries.Count;

		public static void DrawEntries(int maxVisible, double fadeDuration, Action<string, string, string> onEntryClick)
		{
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			UpdateEntryLifecycle(maxVisible, fadeDuration);
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			for (int i = 0; i < TextLogEntries.Count; i++)
			{
				TextLogEntry textLogEntry = TextLogEntries[i];
				float num = ((i < maxVisible) ? 1f : textLogEntry.GetFadeOpacity(fadeDuration));
				GUI.contentColor = new Color(1f, 1f, 1f, num);
				string text = textLogEntry.Text.Replace("\n", "\\n").Replace("\r", "\\r");
				if (text.Length > MaxPreviewLength)
				{
					text = text.Substring(0, MaxPreviewLength - 3) + "...";
				}
				if (GUILayout.Button(textLogEntry.SheetName + "." + textLogEntry.KeyName + ": " + text, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>()))
				{
					onEntryClick?.Invoke(textLogEntry.SheetName, textLogEntry.KeyName, textLogEntry.Text);
				}
			}
			if (TextLogEntries.Count == 0)
			{
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label(Loc.T("No entries yet."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			}
			GUI.contentColor = Color.white;
			GUILayout.EndVertical();
		}

		public static void DrawFilteredEntries(string filter, Action<string, string, string> onEntryClick, HashSet<string> out_seen = null, bool suppressEmpty = false)
		{
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			bool flag = !string.IsNullOrEmpty(filter);
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			bool flag2 = false;
			foreach (TextLogEntry textLogEntry in TextLogEntries)
			{
				if (!flag || textLogEntry.SheetName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0 || textLogEntry.KeyName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0 || textLogEntry.Text.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					string text = textLogEntry.Text.Replace("\n", "\\n").Replace("\r", "\\r");
					if (text.Length > MaxPreviewLength)
					{
						text = text.Substring(0, MaxPreviewLength - 3) + "...";
					}
					if (GUILayout.Button(textLogEntry.SheetName + "." + textLogEntry.KeyName + ": " + text, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>()))
					{
						onEntryClick?.Invoke(textLogEntry.SheetName, textLogEntry.KeyName, textLogEntry.Text);
					}
					out_seen?.Add(textLogEntry.SheetName + "|" + textLogEntry.KeyName);
					flag2 = true;
				}
			}
			if (!flag2 && !suppressEmpty)
			{
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label(flag ? Loc.T("No matches.") : Loc.T("No entries yet."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUILayout.EndVertical();
		}

		private static void UpdateEntryLifecycle(int maxVisible, double fadeDuration)
		{
			for (int num = TextLogEntries.Count - 1; num >= maxVisible; num--)
			{
				if (TextLogEntries[num].IsFadedOut(fadeDuration))
				{
					TextLogEntries.RemoveAt(num);
				}
			}
			for (int i = maxVisible; i < TextLogEntries.Count; i++)
			{
				if (!TextLogEntries[i].BumpedTime.HasValue)
				{
					TextLogEntries[i].BumpedTime = DateTime.Now;
				}
			}
			for (int j = 0; j < Math.Min(maxVisible, TextLogEntries.Count); j++)
			{
				TextLogEntries[j].BumpedTime = null;
			}
		}

		public static void LogText(string sheet, string key, string text)
		{
			string key2 = sheet + "|" + key;
			if (TextLogLookup.TryGetValue(key2, out var value))
			{
				TextLogEntries.Remove(value);
				value.Text = text;
				value.LogTime = DateTime.Now;
				value.BumpedTime = null;
				TextLogEntries.Insert(0, value);
				return;
			}
			TextLogEntry textLogEntry = new TextLogEntry
			{
				SheetName = sheet,
				KeyName = key,
				Text = text,
				LogTime = DateTime.Now,
				BumpedTime = null
			};
			TextLogEntries.Insert(0, textLogEntry);
			TextLogLookup[key2] = textLogEntry;
			while (TextLogEntries.Count > 256)
			{
				TextLogEntry textLogEntry2 = TextLogEntries[TextLogEntries.Count - 1];
				TextLogEntries.RemoveAt(TextLogEntries.Count - 1);
				TextLogLookup.Remove(textLogEntry2.SheetName + "|" + textLogEntry2.KeyName);
			}
		}

		public static void ClearLog()
		{
			TextLogEntries.Clear();
			TextLogLookup.Clear();
		}
	}
	internal static class TextMergePanel
	{
		private static PackInfo _selected;

		private static bool _pickerOpen;

		private static TextMerger.Plan _plan;

		private static Vector2 _scroll;

		private static string _status = "";

		private const int MaxValuePreview = 110;

		public static bool ReviewActive => _plan != null;

		public static void DrawBar()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(Loc.T("Merge pack text:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUI.contentColor = Color.white;
			string text = ((_selected != null) ? _selected.Name : Loc.T("choose a pack…")) + (_pickerOpen ? "  ▲" : "  ▼");
			GUI.enabled = _plan == null;
			if (GUILayout.Button(text, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(240f),
				GUIHelper.Height(22f)
			}))
			{
				_pickerOpen = !_pickerOpen;
			}
			GUI.enabled = _selected != null && _plan == null;
			if (GUILayout.Button(Loc.T("Merge text contents"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				_pickerOpen = false;
				StartScan(_selected);
			}
			GUI.enabled = true;
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(_status, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			if (!_pickerOpen)
			{
				return;
			}
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			bool flag = false;
			foreach (PackInfo allPack in PackManager.AllPacks)
			{
				if (Directory.Exists(Path.Combine(allPack.Path, "Text")))
				{
					flag = true;
					GUI.contentColor = ((_selected != null && allPack == _selected) ? GUIHelper.ColConfirm : Color.white);
					if (GUILayout.Button(allPack.Name + (allPack.IsEnabled ? "" : ("   (" + Loc.T("pending") + ")")), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
					{
						_selected = allPack;
						_pickerOpen = false;
						_status = "";
					}
					GUI.contentColor = Color.white;
				}
			}
			if (!flag)
			{
				GUI.contentColor = GUIHelper.ColFaint;
				GUILayout.Label(Loc.T("No packs with a Text folder found."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUILayout.EndVertical();
		}

		private static void StartScan(PackInfo pack)
		{
			_plan = TextMerger.Scan(pack);
			if (_plan == null)
			{
				_status = Loc.T("No text files in this pack.");
			}
			else if (_plan.IsEmpty)
			{
				_plan = null;
				_status = Loc.T("No text files in this pack.");
			}
			else if (_plan.AddedCount == 0 && _plan.Conflicts.Count == 0)
			{
				_plan = null;
				_status = Loc.T("Nothing to merge — pack text matches the working folder.");
			}
			else
			{
				_status = "";
			}
		}

		public static void OpenMergeFor(string packPath)
		{
			if (_plan == null)
			{
				PackInfo packInfo = PackManager.AllPacks.FirstOrDefault((PackInfo p) => string.Equals(p.Path, packPath, StringComparison.OrdinalIgnoreCase));
				if (packInfo != null)
				{
					_selected = packInfo;
					_pickerOpen = false;
					StartScan(packInfo);
				}
			}
		}

		public static void DrawReview()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Expected O, but got Unknown
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Expected O, but got Unknown
			TextMerger.Plan plan = _plan;
			if (plan == null)
			{
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(string.Format(Loc.T("Review: {0} → working folder"), plan.PackName), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(string.Format(Loc.T("{0} added · {1} identical · {2} conflicts"), plan.AddedCount, plan.IdenticalCount, plan.Conflicts.Count), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUILayout.FlexibleSpace();
			if (plan.Conflicts.Count > 0)
			{
				if (GUILayout.Button(Loc.T("take all: working folder"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					foreach (TextMerger.Conflict conflict2 in plan.Conflicts)
					{
						conflict2.Choice = 0;
					}
				}
				if (GUILayout.Button(Loc.T("take all: pack"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					foreach (TextMerger.Conflict conflict3 in plan.Conflicts)
					{
						conflict3.Choice = 1;
					}
				}
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(2f);
			_scroll = GUILayout.BeginScrollView(_scroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			string text = null;
			for (int i = 0; i < plan.Conflicts.Count; i++)
			{
				TextMerger.Conflict conflict = plan.Conflicts[i];
				string text2 = conflict.Sheet + " · " + conflict.Lang;
				if (text2 != text)
				{
					text = text2;
					GUIHelper.Space(4f);
					GUI.contentColor = GUIHelper.ColAccent;
					GUILayout.Label(text2, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
					GUI.contentColor = Color.white;
				}
				DrawConflict(conflict, i);
			}
			if (plan.Conflicts.Count == 0)
			{
				GUI.contentColor = GUIHelper.ColConfirm;
				GUILayout.Label(Loc.T("No conflicting entries — Apply adds the new keys."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUILayout.EndScrollView();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = (plan.Resolved ? GUIHelper.ColConfirm : GUIHelper.ColWarn);
			GUILayout.Label(string.Format(Loc.T("resolved {0}/{1}"), plan.ResolvedCount, plan.Conflicts.Count), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUILayout.FlexibleSpace();
			if (GUILayout.Button(Loc.T("Discard"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width(110f)
			}))
			{
				_plan = null;
				_status = Loc.T("Merge discarded.");
			}
			int num = plan.Conflicts.Count - plan.ResolvedCount;
			int num2 = plan.ResolvedCount + plan.RootOnlyCount + plan.IdenticalCount;
			bool flag = plan.PackSource == PackSource.Customizer;
			GUI.enabled = !flag && num2 > 0;
			if (GUILayout.Button(new GUIContent(string.Format(Loc.T("Push {0} → pack"), num2), flag ? Loc.T("Customizer packs are read-only.") : Loc.T("Writes resolved text into the pack, then moves those keys out of the working folder. Undecided entries stay.")), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width(170f)
			}))
			{
				(int Files, int Keys, int Removed, string Backup) tuple = TextMerger.ApplyToPack(plan);
				int item = tuple.Files;
				int item2 = tuple.Keys;
				int item3 = tuple.Removed;
				string item4 = tuple.Backup;
				_plan = null;
				_status = string.Format(Loc.T("Pushed {0} key(s) into {1} pack file(s); {2} moved out of the working folder; backup: {3}"), item2, item, item3, item4 ?? "—");
			}
			GUI.enabled = true;
			if (GUILayout.Button((num > 0) ? new GUIContent(string.Format(Loc.T("Apply · {0} unchanged"), num), Loc.T("Undecided entries keep the working folder value.")) : new GUIContent(Loc.T("Apply")), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width((num > 0) ? 190 : 110)
			}))
			{
				(int Files, int Keys, string Backup) tuple2 = TextMerger.Apply(plan);
				int item5 = tuple2.Files;
				int item6 = tuple2.Keys;
				string item7 = tuple2.Backup;
				_plan = null;
				_status = ((item5 == 0) ? Loc.T("Nothing to merge — pack text matches the working folder.") : string.Format(Loc.T("Merged {0} key(s) into {1} file(s); backup: {2}"), item6, item5, item7 ?? "—"));
			}
			GUILayout.EndHorizontal();
		}

		private static void DrawConflict(TextMerger.Conflict c, int index)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.Label(c.Key, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			ChoiceButton(c, 0, Loc.T("working folder"));
			GUI.contentColor = ((c.Choice == 0) ? Color.white : GUIHelper.ColMuted);
			GUILayout.Label(Trunc(c.RootValue), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			ChoiceButton(c, 1, Loc.T("pack@merge"));
			GUI.contentColor = ((c.Choice == 1) ? Color.white : GUIHelper.ColMuted);
			GUILayout.Label(Trunc(c.PackValue), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			ChoiceButton(c, 2, Loc.T("custom"));
			GUI.enabled = c.Choice == 2;
			c.CustomValue = GUIHelper.TextField($"TextMerge.Custom.{index}", c.CustomValue, GUILayout.ExpandWidth(true), GUIHelper.Height(22f));
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		private static void ChoiceButton(TextMerger.Conflict c, int choice, string label)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			bool num = c.Choice == choice;
			GUI.contentColor = (num ? GUIHelper.ColConfirm : GUIHelper.ColFaint);
			if (GUILayout.Button((num ? "● " : "○ ") + label, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(150f),
				GUIHelper.Height(22f)
			}))
			{
				c.Choice = choice;
				if (choice == 2 && string.IsNullOrEmpty(c.CustomValue))
				{
					c.CustomValue = c.PackValue;
				}
			}
			GUI.contentColor = Color.white;
		}

		private static string Trunc(string v)
		{
			v = v.Replace("\n", "\\n");
			if (v.Length > 110)
			{
				return v.Substring(0, 109) + "…";
			}
			return v;
		}
	}
	internal static class WorldPickMode
	{
		public enum Preset
		{
			Tk2d,
			T2D,
			SceneColour
		}

		private enum Cat
		{
			Tk2dAnim,
			T2DWorld,
			Particle
		}

		private sealed class Candidate
		{
			public Cat Category;

			public Component Target;

			public Renderer Renderer;

			public string Label;

			public string RawTex;

			public string SpriteName;

			public string SortLayer;

			public bool Furniture;

			public Texture PrevTex;

			public Rect PrevUV;

			public tk2dSpriteCollectionData Tk2dColl;

			public int Tk2dSpriteId;

			public Rect GuiRect;

			public bool OnScreen;
		}

		private static bool _colourMode;

		private const int CatCount = 3;

		private static readonly bool[] _filterOn = new bool[3] { true, false, false };

		private static readonly List<Candidate> _candidates = new List<Candidate>();

		private static readonly List<Candidate> _stack = new List<Candidate>();

		private static float _nextRescan;

		private static Candidate _hover;

		private static int _manualIndex = -1;

		private static Vector2 _manualAnchor;

		private static float _invalidClickUntil;

		private static Candidate _pendingComplete;

		private static readonly bool[] _bandOn = new bool[3] { true, true, true };

		private static readonly int[] _bandCount = new int[3];

		private static bool _showOverlays;

		private static int _furnitureCount;

		private const float FurnitureAxisFrac = 0.96f;

		private static bool _devHubWasOpen;

		private static Texture2D _white;

		private static readonly Vector3[] _corners = (Vector3[])(object)new Vector3[4];

		private static readonly Dictionary<int, Camera> _layerCam = new Dictionary<int, Camera>();

		private static Camera[] _allCams = Array.Empty<Camera>();

		private static readonly List<Rect> _chipRects = new List<Rect>();

		private static GUIStyle _noWrapLabel;

		public static bool Active { get; private set; }

		private static float PreviewBox => S(42f);

		private static GUIStyle NoWrapLabel
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				GUIStyle labelStyle = GUIHelper.LabelStyle;
				if (_noWrapLabel == null || _noWrapLabel.fontSize != labelStyle.fontSize)
				{
					_noWrapLabel = new GUIStyle(labelStyle)
					{
						wordWrap = false,
						clipping = (TextClipping)0
					};
				}
				return _noWrapLabel;
			}
		}

		private static int DepthBandOf(float z)
		{
			if (!(z <= -1f))
			{
				if (!(z < 1f))
				{
					return 2;
				}
				return 1;
			}
			return 0;
		}

		private static string BandLabel(int band)
		{
			return band switch
			{
				0 => Loc.T("Foreground@pick", "foreground"), 
				1 => Loc.T("Playfield@pick", "playfield"), 
				_ => Loc.T("Background@pick", "background"), 
			};
		}

		private static Color CatColor(Cat c)
		{
			//IL_0013: 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_0007: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(c switch
			{
				Cat.Particle => GUIHelper.ColWarn, 
				Cat.Tk2dAnim => GUIHelper.ColConfirm, 
				_ => GUIHelper.ColPop2, 
			});
		}

		private static string CatLabel(Cat c)
		{
			return c switch
			{
				Cat.Particle => Loc.T("particles@pick", "particles"), 
				Cat.Tk2dAnim => Loc.T("tk2d anim@pick", "tk2d anim"), 
				_ => Loc.T("T2D@pick", "T2D"), 
			};
		}

		public static void Enter(Preset preset)
		{
			if (!Active)
			{
				Active = true;
				_devHubWasOpen = Plugin.ShowDevHub;
				Plugin.ShowDevHub = false;
				_colourMode = preset == Preset.SceneColour;
				_filterOn[0] = preset == Preset.Tk2d;
				_filterOn[1] = preset == Preset.T2D || _colourMode;
				_filterOn[2] = false;
				_showOverlays = false;
				_hover = null;
				_manualIndex = -1;
				_pendingComplete = null;
				_candidates.Clear();
				_nextRescan = 0f;
				Plugin.Logger.LogInfo((object)"[WorldPick] Entered — click a highlighted object; chips filter categories, scroll cycles overlaps, right-click or any Stitchwork hotkey cancels.");
			}
		}

		public static void Cancel(string reason)
		{
			if (Active)
			{
				Active = false;
				Plugin.ShowDevHub = _devHubWasOpen;
				_hover = null;
				_pendingComplete = null;
				_candidates.Clear();
				Plugin.Logger.LogInfo((object)("[WorldPick] Cancelled (" + reason + ")."));
			}
		}

		private static void Complete(Candidate pick)
		{
			Active = false;
			_hover = null;
			_candidates.Clear();
			if (_colourMode)
			{
				_colourMode = false;
				Renderer renderer = pick.Renderer;
				GraphicsPillar.SelectColourFromWorldPick((SpriteRenderer)(object)((renderer is SpriteRenderer) ? renderer : null));
				DevHub.OpenAt(1);
				Plugin.Logger.LogInfo((object)("[WorldPick] Colour-picked '" + pick.Label + "'."));
				return;
			}
			LogDrawOrder(pick);
			Component target = pick.Target;
			tk2dSpriteAnimator val = (tk2dSpriteAnimator)(object)((target is tk2dSpriteAnimator) ? target : null);
			if (val != null)
			{
				AnimationController.RegisterAnimator(val);
				AnimationController.SelectFromWorldPick(((Object)((Component)val).gameObject).name);
				GraphicsPillar.SwitchToAnimation();
				DevHub.OpenAt(1);
				Plugin.Logger.LogInfo((object)("[WorldPick] Selected '" + ((Object)((Component)val).gameObject).name + "' (clip '" + val.CurrentClip?.name + "')."));
				return;
			}
			Component target2 = pick.Target;
			tk2dBaseSprite val2 = (tk2dBaseSprite)(object)((target2 is tk2dBaseSprite) ? target2 : null);
			if (val2 != null)
			{
				Plugin.ShowDevHub = _devHubWasOpen;
				AnimationController.OpenSpriteForEdit(val2.Collection, val2.CurrentSprite);
				Plugin.Logger.LogInfo((object)("[WorldPick] Selected static tk2d '" + ((Object)((Component)val2).gameObject).name + "' (" + ((Object)val2.Collection).name + "/" + val2.CurrentSprite.name + ") — opened for edit."));
			}
			else
			{
				T2DTextureController.SelectEntry(pick.RawTex, pick.SpriteName);
				GraphicsPillar.SwitchToT2DBrowser();
				DevHub.OpenAt(1);
				Plugin.Logger.LogInfo((object)((pick.Category == Cat.Particle) ? ("[WorldPick] Selected particle system '" + pick.Label + "' (tex '" + pick.RawTex + "').") : ("[WorldPick] Selected T2D '" + pick.SpriteName + "' (tex '" + pick.RawTex + "').")));
			}
		}

		public static void Update()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			if (!Active)
			{
				return;
			}
			if (_pendingComplete != null)
			{
				if (!Input.GetMouseButton(0))
				{
					Candidate pendingComplete = _pendingComplete;
					_pendingComplete = null;
					Complete(pendingComplete);
				}
				return;
			}
			if (Input.GetMouseButtonDown(1))
			{
				Cancel("right-click");
				return;
			}
			Camera val = Camera.main;
			if ((Object)(object)val == (Object)null && Camera.allCameras.Length != 0)
			{
				val = Camera.allCameras[0];
			}
			if (Time.realtimeSinceStartup >= _nextRescan)
			{
				RebuildCandidates();
				_nextRescan = Time.realtimeSinceStartup + 0.25f;
			}
			ProjectRects(val);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(Input.mousePosition.x, (float)Screen.height - Input.mousePosition.y);
			ResolveHover(val2);
			if (!Input.GetMouseButtonDown(0))
			{
				return;
			}
			foreach (Rect chipRect in _chipRects)
			{
				Rect current = chipRect;
				if (((Rect)(ref current)).Contains(val2))
				{
					return;
				}
			}
			if (_hover != null && (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305)))
			{
				CameraTracker.Track(_hover.Target, _hover.Label);
			}
			else if (_hover != null)
			{
				_pendingComplete = _hover;
			}
			else
			{
				_invalidClickUntil = Time.realtimeSinceStartup + 1.2f;
			}
		}

		private static void LogDrawOrder(Candidate pick)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			Renderer renderer = pick.Renderer;
			if (!((Object)(object)renderer == (Object)null))
			{
				Material sharedMaterial = renderer.sharedMaterial;
				Texture val = (((Object)(object)sharedMaterial != (Object)null) ? sharedMaterial.mainTexture : null);
				Plugin.Logger.LogInfo((object)($"[WorldPick/Order] '{pick.Label}' layer='{renderer.sortingLayerName}'({renderer.sortingLayerID}) " + $"order={renderer.sortingOrder} z={((Component)renderer).transform.position.z:F4} " + "mat=" + (((Object)(object)sharedMaterial != (Object)null) ? (((Object)sharedMaterial).name + "#" + ((Object)sharedMaterial).GetInstanceID()) : "(none)") + " tex=" + (((Object)(object)val != (Object)null) ? (((Object)val).name + " " + ((object)val).GetType().Name) : "(none)")));
			}
		}

		private static void RebuildCandidates()
		{
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			_candidates.Clear();
			if (_filterOn[0])
			{
				tk2dSpriteAnimator[] array = Object.FindObjectsByType<tk2dSpriteAnimator>((FindObjectsSortMode)0);
				foreach (tk2dSpriteAnimator val in array)
				{
					if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy)
					{
						continue;
					}
					tk2dBaseSprite component = ((Component)val).GetComponent<tk2dBaseSprite>();
					if (!((Object)(object)component == (Object)null) && !((Object)(object)component.Collection == (Object)null) && component.CurrentSprite != null)
					{
						Renderer component2 = ((Component)val).GetComponent<Renderer>();
						if (!((Object)(object)component2 == (Object)null) && component2.enabled)
						{
							Candidate candidate = new Candidate
							{
								Category = Cat.Tk2dAnim,
								Target = (Component)(object)val,
								Renderer = component2,
								Label = ((Object)((Component)val).gameObject).name + "  ·  " + (val.CurrentClip?.name ?? "?"),
								Tk2dColl = component.Collection,
								Tk2dSpriteId = component.spriteId
							};
							FillTk2dPreview(candidate, component.CurrentSprite);
							_candidates.Add(candidate);
						}
					}
				}
				tk2dBaseSprite[] array2 = Object.FindObjectsByType<tk2dBaseSprite>((FindObjectsSortMode)0);
				foreach (tk2dBaseSprite val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy && !((Object)(object)((Component)val2).GetComponent<tk2dSpriteAnimator>() != (Object)null) && !((Object)(object)val2.Collection == (Object)null) && val2.CurrentSprite != null && !string.IsNullOrEmpty(val2.CurrentSprite.name))
					{
						Renderer component3 = ((Component)val2).GetComponent<Renderer>();
						if (!((Object)(object)component3 == (Object)null) && component3.enabled)
						{
							Candidate candidate2 = new Candidate
							{
								Category = Cat.Tk2dAnim,
								Target = (Component)(object)val2,
								Renderer = component3,
								Label = ((Object)((Component)val2).gameObject).name + "  ·  " + val2.CurrentSprite.name,
								Tk2dColl = val2.Collection,
								Tk2dSpriteId = val2.spriteId
							};
							FillTk2dPreview(candidate2, val2.CurrentSprite);
							_candidates.Add(candidate2);
						}
					}
				}
			}
			if (_filterOn[1])
			{
				_bandCount[0] = (_bandCount[1] = (_bandCount[2] = 0));
				SpriteRenderer[] array3 = Object.FindObjectsByType<SpriteRenderer>((FindObjectsSortMode)0);
				foreach (SpriteRenderer val3 in array3)
				{
					if ((Object)(object)val3 == (Object)null || !((Renderer)val3).enabled || !((Component)val3).gameObject.activeInHierarchy)
					{
						continue;
					}
					Sprite sprite = val3.sprite;
					if (!((Object)(object)sprite == (Object)null) && !((Object)(object)sprite.texture == (Object)null))
					{
						Bounds bounds = ((Renderer)val3).bounds;
						int num = DepthBandOf(((Bounds)(ref bounds)).center.z);
						_bandCount[num]++;
						if (_bandOn[num])
						{
							Candidate candidate3 = new Candidate
							{
								Category = Cat.T2DWorld,
								Target = (Component)(object)val3,
								Renderer = (Renderer)(object)val3,
								RawTex = ((Object)sprite.texture).name,
								SpriteName = ((Object)sprite).name,
								SortLayer = ((Renderer)val3).sortingLayerName,
								Label = ((Object)sprite).name + "  ·  " + T2DUtil.CleanTextureName(((Object)sprite.texture).name)
							};
							FillSpritePreview(candidate3, sprite);
							_candidates.Add(candidate3);
						}
					}
				}
			}
			if (!_filterOn[2])
			{
				return;
			}
			ParticleSystemRenderer[] array4 = Object.FindObjectsByType<ParticleSystemRenderer>((FindObjectsSortMode)0);
			foreach (ParticleSystemRenderer val4 in array4)
			{
				if ((Object)(object)val4 == (Object)null || !((Renderer)val4).enabled || !((Component)val4).gameObject.activeInHierarchy)
				{
					continue;
				}
				Material sharedMaterial = ((Renderer)val4).sharedMaterial;
				if ((Object)(object)sharedMaterial == (Object)null)
				{
					continue;
				}
				Texture mainTexture = sharedMaterial.mainTexture;
				if (!((Object)(object)mainTexture == (Object)null) && !string.IsNullOrEmpty(((Object)mainTexture).name))
				{
					Bounds bounds2 = ((Renderer)val4).bounds;
					if (!(((Bounds)(ref bounds2)).size.x < 0.01f) && !(((Bounds)(ref bounds2)).size.y < 0.01f))
					{
						Candidate item = new Candidate
						{
							Category = Cat.Particle,
							Target = (Component)(object)val4,
							Renderer = (Renderer)(object)val4,
							RawTex = ((Object)mainTexture).name,
							SpriteName = null,
							SortLayer = ((Renderer)val4).sortingLayerName,
							Label = ((Object)((Component)val4).gameObject).name + "  ·  " + T2DUtil.CleanTextureName(((Object)mainTexture).name),
							PrevTex = mainTexture,
							PrevUV = new Rect(0f, 0f, 1f, 1f)
						};
						_candidates.Add(item);
					}
				}
			}
		}

		private static void FillSpritePreview(Candidate c, Sprite sp)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			Vector2[] uv = sp.uv;
			if (uv == null || uv.Length == 0)
			{
				c.PrevTex = (Texture)(object)sp.texture;
				c.PrevUV = new Rect(0f, 0f, 1f, 1f);
				return;
			}
			float num = uv[0].x;
			float num2 = num;
			float num3 = uv[0].y;
			float num4 = num3;
			for (int i = 1; i < uv.Length; i++)
			{
				num = Mathf.Min(num, uv[i].x);
				num2 = Mathf.Max(num2, uv[i].x);
				num3 = Mathf.Min(num3, uv[i].y);
				num4 = Mathf.Max(num4, uv[i].y);
			}
			c.PrevTex = (Texture)(object)sp.texture;
			c.PrevUV = new Rect(num, num3, Mathf.Max(1E-05f, num2 - num), Mathf.Max(1E-05f, num4 - num3));
		}

		private static void FillTk2dPreview(Candidate c, tk2dSpriteDefinition def)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			Material val = (((Object)(object)def?.materialInst != (Object)null) ? def.materialInst : def?.material);
			Texture val2 = (((Object)(object)val != (Object)null) ? val.mainTexture : null);
			Vector2[] array = def?.uvs;
			if (!((Object)(object)val2 == (Object)null) && array != null && array.Length >= 4)
			{
				float num = array[0].x;
				float num2 = num;
				float num3 = array[0].y;
				float num4 = num3;
				for (int i = 1; i < array.Length; i++)
				{
					num = Mathf.Min(num, array[i].x);
					num2 = Mathf.Max(num2, array[i].x);
					num3 = Mathf.Min(num3, array[i].y);
					num4 = Mathf.Max(num4, array[i].y);
				}
				c.PrevTex = val2;
				c.PrevUV = new Rect(num, num3, num2 - num, num4 - num3);
			}
		}

		private static Camera CameraForLayer(int layer, Camera fallback)
		{
			if (_layerCam.TryGetValue(layer, out var value))
			{
				return value;
			}
			Camera val = (((Object)(object)fallback != (Object)null && (fallback.cullingMask & (1 << layer)) != 0) ? fallback : null);
			if ((Object)(object)val == (Object)null)
			{
				Camera[] allCams = _allCams;
				foreach (Camera val2 in allCams)
				{
					if ((Object)(object)val2 != (Object)null && ((Behaviour)val2).enabled && (val2.cullingMask & (1 << layer)) != 0)
					{
						val = val2;
						break;
					}
				}
			}
			_layerCam[layer] = val ?? fallback;
			return _layerCam[layer];
		}

		private static void ProjectRects(Camera cam)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			_layerCam.Clear();
			_allCams = Camera.allCameras;
			_furnitureCount = 0;
			for (int i = 0; i < _candidates.Count; i++)
			{
				Candidate candidate = _candidates[i];
				candidate.OnScreen = false;
				if ((Object)(object)candidate.Target == (Object)null || (Object)(object)cam == (Object)null || (Object)(object)candidate.Renderer == (Object)null)
				{
					continue;
				}
				Camera val = CameraForLayer(((Component)candidate.Renderer).gameObject.layer, cam);
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Rect guiRect = WorldBoundsToGuiRect(val, candidate.Renderer.bounds);
				if (((Rect)(ref guiRect)).width < 8f || ((Rect)(ref guiRect)).height < 8f)
				{
					candidate.GuiRect = guiRect;
					continue;
				}
				if (((Rect)(ref guiRect)).xMax < 0f || ((Rect)(ref guiRect)).yMax < 0f || ((Rect)(ref guiRect)).x > (float)Screen.width || ((Rect)(ref guiRect)).y > (float)Screen.height)
				{
					candidate.GuiRect = guiRect;
					continue;
				}
				candidate.GuiRect = guiRect;
				candidate.OnScreen = true;
				candidate.Furniture = candidate.Category == Cat.T2DWorld && !string.Equals(candidate.SortLayer, "Default", StringComparison.Ordinal) && (((Rect)(ref guiRect)).width >= (float)Screen.width * 0.96f || ((Rect)(ref guiRect)).height >= (float)Screen.height * 0.96f);
				if (candidate.Furniture)
				{
					_furnitureCount++;
				}
			}
		}

		private static Rect WorldBoundsToGuiRect(Camera cam, Bounds b)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Vector2.op_Implicit(cam.WorldToScreenPoint(((Bounds)(ref b)).min));
			Vector2 val2 = Vector2.op_Implicit(cam.WorldToScreenPoint(((Bounds)(ref b)).max));
			Rect result = Rect.MinMaxRect(Mathf.Min(val.x, val2.x), Mathf.Min(val.y, val2.y), Mathf.Max(val.x, val2.x), Mathf.Max(val.y, val2.y));
			((Rect)(ref result)).y = (float)Screen.height - ((Rect)(ref result)).y - ((Rect)(ref result)).height;
			return result;
		}

		private static void ResolveHover(Vector2 mouse)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			_stack.Clear();
			foreach (Candidate candidate in _candidates)
			{
				if (candidate.OnScreen && (!candidate.Furniture || _showOverlays) && ((Rect)(ref candidate.GuiRect)).Contains(mouse))
				{
					_stack.Add(candidate);
				}
			}
			_stack.Sort((Candidate a, Candidate b) => (((Rect)(ref a.GuiRect)).width * ((Rect)(ref a.GuiRect)).height).CompareTo(((Rect)(ref b.GuiRect)).width * ((Rect)(ref b.GuiRect)).height));
			if (_stack.Count == 0)
			{
				_hover = null;
				_manualIndex = -1;
				return;
			}
			float y = Input.mouseScrollDelta.y;
			if (y != 0f && _stack.Count > 1)
			{
				if (_manualIndex < 0)
				{
					_manualIndex = AutoIndex(mouse);
					_manualAnchor = mouse;
				}
				_manualIndex = ((_manualIndex + ((y < 0f) ? 1 : (-1))) % _stack.Count + _stack.Count) % _stack.Count;
			}
			if (_manualIndex >= 0 && Vector2.Distance(mouse, _manualAnchor) > 24f)
			{
				_manualIndex = -1;
			}
			int index = ((_manualIndex >= 0) ? Mathf.Min(_manualIndex, _stack.Count - 1) : AutoIndex(mouse));
			_hover = _stack[index];
		}

		private static int AutoIndex(Vector2 mouse)
		{
			//IL_000f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _stack.Count; i++)
			{
				Rect guiRect = _stack[i].GuiRect;
				float num = Mathf.Max(8f, 0.15f * Mathf.Min(((Rect)(ref guiRect)).width, ((Rect)(ref guiRect)).height));
				if (Vector2.Distance(mouse, ((Rect)(ref guiRect)).center) <= num)
				{
					return i;
				}
			}
			return 0;
		}

		public static void OnGUI()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			if (!Active || _pendingComplete != null)
			{
				return;
			}
			EnsureWhite();
			foreach (Candidate candidate in _candidates)
			{
				if (candidate.OnScreen && candidate != _hover && (!candidate.Furniture || _showOverlays))
				{
					Color c = CatColor(candidate.Category);
					c.a = 0.5f;
					DrawBorder(candidate.GuiRect, 1f, c);
				}
			}
			if (_hover != null)
			{
				DrawBorder(_hover.GuiRect, 3f, Color.Lerp(CatColor(_hover.Category), GUIHelper.ColBone, 0.55f));
				DrawHoverChip(_hover);
			}
			if (!Cursor.visible)
			{
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(Input.mousePosition.x, (float)Screen.height - Input.mousePosition.y);
				GUI.color = GUIHelper.ColBone;
				GUI.DrawTexture(new Rect(val.x - 9f, val.y - 0.5f, 7f, 1.5f), (Texture)(object)_white);
				GUI.DrawTexture(new Rect(val.x + 3f, val.y - 0.5f, 7f, 1.5f), (Texture)(object)_white);
				GUI.DrawTexture(new Rect(val.x - 0.5f, val.y - 9f, 1.5f, 7f), (Texture)(object)_white);
				GUI.DrawTexture(new Rect(val.x - 0.5f, val.y + 3f, 1.5f, 7f), (Texture)(object)_white);
				GUI.color = Color.white;
			}
			DrawHintAndChips();
		}

		private static int AutoIndexForChip()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return AutoIndex(new Vector2(Input.mousePosition.x, (float)Screen.height - Input.mousePosition.y));
		}

		private static void DrawHoverChip(Candidate hover)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			string text = ((_stack.Count > 1) ? $"   [{((_manualIndex >= 0) ? _manualIndex : AutoIndexForChip()) + 1}/{_stack.Count}]" : "");
			GUIContent val = new GUIContent(hover.Label + "   ·   " + CatLabel(hover.Category) + text);
			Vector2 val2 = GUIHelper.LabelStyle.CalcSize(val);
			Texture val3 = hover.PrevTex;
			Rect prevUV = hover.PrevUV;
			if (hover.Category == Cat.Tk2dAnim && (Object)(object)hover.Tk2dColl != (Object)null)
			{
				Texture2D uprightSpriteTexShared = AnimationController.GetUprightSpriteTexShared(hover.Tk2dColl, hover.Tk2dSpriteId);
				if ((Object)(object)uprightSpriteTexShared != (Object)null)
				{
					val3 = (Texture)(object)uprightSpriteTexShared;
					((Rect)(ref prevUV))..ctor(0f, 0f, 1f, 1f);
				}
			}
			bool num = (Object)(object)val3 != (Object)null;
			float previewBox = PreviewBox;
			float num2 = val2.x + S(9f);
			float num3 = val2.y + S(6f);
			float num4 = (num ? S(4f) : 0f);
			float num5 = (num ? previewBox : 0f);
			float num6 = num5 + num4 + num2;
			float num7 = (num ? Mathf.Max(previewBox, num3) : num3);
			float num8 = Mathf.Clamp(((Rect)(ref hover.GuiRect)).x, 4f, (float)Screen.width - num6 - 4f);
			float num9 = ((Rect)(ref hover.GuiRect)).y - num7 - S(4f);
			if (num9 < 4f)
			{
				num9 = ((Rect)(ref hover.GuiRect)).yMax + S(4f);
			}
			if (num9 + num7 > (float)Screen.height - 4f)
			{
				num9 = Mathf.Clamp(((Rect)(ref hover.GuiRect)).y + S(4f), 4f, (float)Screen.height - num7 - 4f);
			}
			Color val4 = CatColor(hover.Category);
			if (num)
			{
				Rect r = default(Rect);
				((Rect)(ref r))..ctor(num8, num9 + (num7 - previewBox) * 0.5f, previewBox, previewBox);
				DrawPill(r, new Color(GUIHelper.ColSurface2.r, GUIHelper.ColSurface2.g, GUIHelper.ColSurface2.b, 0.95f), new Color(val4.r, val4.g, val4.b, 0.75f), S(4f));
				float num10 = Mathf.Max(1f, ((Rect)(ref prevUV)).width * (float)val3.width);
				float num11 = Mathf.Max(1f, ((Rect)(ref prevUV)).height * (float)val3.height);
				float num12 = previewBox - S(6f);
				float num13 = Mathf.Min(num12 / num10, num12 / num11);
				GUI.DrawTextureWithTexCoords(new Rect(((Rect)(ref r)).x + (previewBox - num10 * num13) * 0.5f, ((Rect)(ref r)).y + (previewBox - num11 * num13) * 0.5f, num10 * num13, num11 * num13), val3, prevUV, true);
			}
			Rect r2 = default(Rect);
			((Rect)(ref r2))..ctor(num8 + num5 + num4, num9 + (num7 - num3) * 0.5f, num2, num3);
			DrawPill(r2, new Color(GUIHelper.ColSurface.r, GUIHelper.ColSurface.g, GUIHelper.ColSurface.b, 0.95f), new Color(val4.r, val4.g, val4.b, 0.75f), S(3.5f));
			GUI.contentColor = Color.Lerp(val4, Color.white, 0.35f);
			GUI.Label(new Rect(((Rect)(ref r2)).x + S(4.5f), ((Rect)(ref r2)).y + (num3 - val2.y) * 0.5f, val2.x, val2.y), val, GUIHelper.LabelStyle);
			GUI.contentColor = Color.white;
		}

		private static void DrawPill(Rect r, Color fill, Color border, float radius, float borderW = 1f)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			GUI.DrawTexture(r, (Texture)(object)Texture2D.whiteTexture, (ScaleMode)0, true, 0f, fill, 0f, radius);
			if (border.a > 0f)
			{
				GUI.DrawTexture(r, (Texture)(object)Texture2D.whiteTexture, (ScaleMode)0, true, 0f, border, borderW, radius);
			}
		}

		private static Vector2 GuiMouse()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(Input.mousePosition.x, (float)Screen.height - Input.mousePosition.y);
		}

		private static float S(float base1080)
		{
			return GUIHelper.Scaled(base1080);
		}

		private static void DrawHintAndChips()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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)
			//IL_0034: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Expected O, but got Unknown
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = GuiMouse();
			bool flag = Time.realtimeSinceStartup < _invalidClickUntil;
			GUIContent val2 = new GUIContent(flag ? Loc.T("No pickable object there") : Loc.T("Pick: click a highlighted object — chips filter · scroll cycles overlaps · right-click cancels"));
			Vector2 val3 = GUIHelper.LabelStyle.CalcSize(val2);
			Rect r = default(Rect);
			((Rect)(ref r))..ctor(((float)Screen.width - val3.x - S(17f)) * 0.5f, S(7f), val3.x + S(17f), val3.y + S(6f));
			DrawPill(r, new Color(GUIHelper.ColSurface.r, GUIHelper.ColSurface.g, GUIHelper.ColSurface.b, 0.95f), new Color(GUIHelper.ColBorderHi.r, GUIHelper.ColBorderHi.g, GUIHelper.ColBorderHi.b, 0.9f), S(3.5f));
			DrawPill(new Rect(((Rect)(ref r)).x + S(3f), ((Rect)(ref r)).y + S(2.5f), S(1.5f), ((Rect)(ref r)).height - S(5f)), flag ? GUIHelper.ColWarn : GUIHelper.ColConfirm, Color.clear, S(0.75f));
			GUI.contentColor = (flag ? GUIHelper.ColWarn : GUIHelper.ColText);
			GUI.Label(new Rect(((Rect)(ref r)).x + S(8.5f), ((Rect)(ref r)).y + S(3f), ((Rect)(ref r)).width - S(10.5f), val3.y), val2, NoWrapLabel);
			GUI.contentColor = Color.white;
			_chipRects.Clear();
			float num = ((Rect)(ref r)).yMax + S(5f);
			float num2 = S(8.5f);
			string[] array = new string[3];
			Vector2[] array2 = (Vector2[])(object)new Vector2[3];
			float num3 = 0f;
			for (int i = 0; i < 3; i++)
			{
				array[i] = CatLabel((Cat)i);
				array2[i] = GUIHelper.LabelStyle.CalcSize(new GUIContent(array[i]));
				num3 += num2 + array2[i].x + S(10f) + S(4f);
			}
			float num4 = ((float)Screen.width - num3) * 0.5f;
			float num5 = 0f;
			Rect val4 = default(Rect);
			for (int j = 0; j < 3; j++)
			{
				int c = j;
				((Rect)(ref val4))..ctor(num4, num, num2 + array2[j].x + S(10f), array2[j].y + S(5f));
				_chipRects.Add(val4);
				num5 = ((Rect)(ref val4)).height;
				bool flag2 = _filterOn[j];
				bool flag3 = ((Rect)(ref val4)).Contains(val);
				Color val5 = CatColor((Cat)c);
				float radius = ((Rect)(ref val4)).height * 0.5f;
				Color val6 = (flag2 ? new Color(val5.r * 0.2f + GUIHelper.ColSurface.r * 0.8f, val5.g * 0.2f + GUIHelper.ColSurface.g * 0.8f, val5.b * 0.2f + GUIHelper.ColSurface.b * 0.8f, 0.96f) : new Color(GUIHelper.ColSurface2.r, GUIHelper.ColSurface2.g, GUIHelper.ColSurface2.b, 0.85f));
				if (flag3)
				{
					val6 = Color.Lerp(val6, Color.white, 0.07f);
				}
				Color border = (flag2 ? new Color(val5.r, val5.g, val5.b, flag3 ? 1f : 0.8f) : new Color(GUIHelper.ColBorderHi.r, GUIHelper.ColBorderHi.g, GUIHelper.ColBorderHi.b, flag3 ? 1f : 0.8f));
				DrawPill(val4, val6, border, radius, flag2 ? 1.5f : 1f);
				float num6 = S(3.5f);
				DrawPill(new Rect(((Rect)(ref val4)).x + S(4.5f), ((Rect)(ref val4)).y + (((Rect)(ref val4)).height - num6) * 0.5f, num6, num6), (Color)(flag2 ? val5 : new Color(val5.r, val5.g, val5.b, 0.45f)), Color.clear, num6 * 0.5f);
				GUI.contentColor = (flag2 ? Color.Lerp(val5, Color.white, 0.35f) : (flag3 ? GUIHelper.ColMuted : GUIHelper.ColFaint));
				GUI.Label(new Rect(((Rect)(ref val4)).x + num2 + S(2f), ((Rect)(ref val4)).y + S(2.5f), ((Rect)(ref val4)).width - num2 - S(2f), array2[j].y), array[j], NoWrapLabel);
				GUI.contentColor = Color.white;
				if (GUI.Button(val4, GUIContent.none, GUIStyle.none))
				{
					_filterOn[j] = !_filterOn[j];
					_nextRescan = 0f;
				}
				num4 += ((Rect)(ref val4)).width + S(4f);
			}
			if (!_filterOn[1])
			{
				return;
			}
			string[] array3 = new string[4];
			for (int k = 0; k < 3; k++)
			{
				array3[k] = $"{BandLabel(k)}  {_bandCount[k]}";
			}
			array3[3] = string.Format("{0}  {1}", Loc.T("Overlays@pick", "overlays"), _furnitureCount);
			float y = num + num5 + S(3.5f);
			DrawSubChipRow(array3, y, val, (int num7) => (num7 >= 3) ? _showOverlays : _bandOn[num7], delegate(int num7)
			{
				if (num7 < 3)
				{
					_bandOn[num7] = !_bandOn[num7];
				}
				else
				{
					_showOverlays = !_showOverlays;
				}
				_nextRescan = 0f;
			});
		}

		private static float DrawSubChipRow(string[] labels, float y, Vector2 mouse, Func<int, bool> isOn, Action<int> toggle)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0030: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			Color colPop = GUIHelper.ColPop2;
			Vector2[] array = (Vector2[])(object)new Vector2[labels.Length];
			float num = 0f;
			for (int i = 0; i < labels.Length; i++)
			{
				array[i] = GUIHelper.LabelStyle.CalcSize(new GUIContent(labels[i]));
				num += array[i].x + S(9f) + S(3f);
			}
			float num2 = ((float)Screen.width - num) * 0.5f;
			float result = 0f;
			Rect val = default(Rect);
			for (int j = 0; j < labels.Length; j++)
			{
				((Rect)(ref val))..ctor(num2, y, array[j].x + S(9f), array[j].y + S(3f));
				_chipRects.Add(val);
				result = ((Rect)(ref val)).height;
				bool num3 = isOn(j);
				bool flag = ((Rect)(ref val)).Contains(mouse);
				Color val2 = (num3 ? new Color(colPop.r * 0.16f + GUIHelper.ColSurface.r * 0.84f, colPop.g * 0.16f + GUIHelper.ColSurface.g * 0.84f, colPop.b * 0.16f + GUIHelper.ColSurface.b * 0.84f, 0.95f) : new Color(GUIHelper.ColSurface2.r, GUIHelper.ColSurface2.g, GUIHelper.ColSurface2.b, 0.75f));
				if (flag)
				{
					val2 = Color.Lerp(val2, Color.white, 0.07f);
				}
				DrawPill(border: num3 ? new Color(colPop.r, colPop.g, colPop.b, flag ? 0.95f : 0.7f) : new Color(GUIHelper.ColBorderHi.r, GUIHelper.ColBorderHi.g, GUIHelper.ColBorderHi.b, 0.7f), r: val, fill: val2, radius: ((Rect)(ref val)).height * 0.5f);
				GUI.contentColor = (num3 ? Color.Lerp(colPop, Color.white, 0.4f) : (flag ? GUIHelper.ColMuted : GUIHelper.ColFaint));
				GUI.Label(new Rect(((Rect)(ref val)).x + S(4.5f), ((Rect)(ref val)).y + S(1.5f), ((Rect)(ref val)).width - S(4.5f), array[j].y), labels[j], NoWrapLabel);
				GUI.contentColor = Color.white;
				if (GUI.Button(val, GUIContent.none, GUIStyle.none))
				{
					toggle(j);
				}
				num2 += ((Rect)(ref val)).width + S(3f);
			}
			return result;
		}

		private static void DrawBorder(Rect r, float t, Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			GUI.color = c;
			GUI.DrawTexture(new Rect(((Rect)(ref r)).x - t, ((Rect)(ref r)).y - t, ((Rect)(ref r)).width + 2f * t, t), (Texture)(object)_white);
			GUI.DrawTexture(new Rect(((Rect)(ref r)).x - t, ((Rect)(ref r)).yMax, ((Rect)(ref r)).width + 2f * t, t), (Texture)(object)_white);
			GUI.DrawTexture(new Rect(((Rect)(ref r)).x - t, ((Rect)(ref r)).y, t, ((Rect)(ref r)).height), (Texture)(object)_white);
			GUI.DrawTexture(new Rect(((Rect)(ref r)).xMax, ((Rect)(ref r)).y, t, ((Rect)(ref r)).height), (Texture)(object)_white);
			GUI.color = Color.white;
		}

		private static void EnsureWhite()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_white != (Object)null))
			{
				_white = new Texture2D(1, 1, (TextureFormat)4, false)
				{
					hideFlags = (HideFlags)32
				};
				_white.SetPixel(0, 0, Color.white);
				_white.Apply(false, false);
			}
		}
	}
}
namespace Stitchwork.GUI.Pillars
{
	public static class AudioPillar
	{
		private static Vector2 _leftScroll;

		private static Vector2 _rightScroll;

		private const float PaneSpacing = 6f;

		private const float PaneWidthBase = 360f;

		private static AudioClipEntry _selected;

		private static bool _hasSelection;

		private static string _searchFilter = "";

		private static string _dumpStatus = null;

		private static AudioClipEntry _pendingSelectEntry;

		private static readonly List<AudioClipEntry> _filteredEntries = new List<AudioClipEntry>();

		private static string _lastAppliedFilter = null;

		private static int _lastListVersion = -1;

		private static float _browserScrollViewH = 300f;

		private const float RowH = 22f;

		private static int _diskFileCount = 0;

		private static float _lastScanTime = -999f;

		private const float ScanCooldown = 3f;

		public static void Draw()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			AudioHandler.IsAudioBrowserActive = true;
			EnsureScanned();
			if (AudioList.NeedsRefresh)
			{
				AudioList.Refresh();
			}
			if ((int)Event.current.type == 8)
			{
				string text = AudioLog.ConsumePendingFocus();
				if (!string.IsNullOrEmpty(text))
				{
					FocusClipByName(text);
				}
				if (_pendingSelectEntry != null)
				{
					_selected = _pendingSelectEntry;
					_hasSelection = true;
					_pendingSelectEntry = null;
				}
			}
			int count = AudioList.Entries.Count;
			int cachedClipCount = AudioHandler.CachedClipCount;
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label($"Audio: {_diskFileCount} replacement(s) on disk  |  {count} clip(s) in memory  |  {cachedClipCount} cached", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(6f);
			float width = GUIHelper.Scaled(360f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			DrawBrowserPane(width);
			GUIHelper.Space(6f);
			DrawLogPane(width);
			GUILayout.EndHorizontal();
		}

		private static void DrawBrowserPane(float width)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Invalid comparison between Unknown and I4
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(width) });
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(Loc.T("Clip Browser"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUI.contentColor = Color.white;
			_searchFilter = GUIHelper.TextField("Audio.Search", _searchFilter, GUILayout.ExpandWidth(true), GUIHelper.Height(20f));
			GUI.enabled = !string.IsNullOrEmpty(_searchFilter);
			if (GUILayout.Button("x", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(22f),
				GUIHelper.Height(20f)
			}))
			{
				_searchFilter = "";
			}
			GUI.enabled = true;
			if (GUILayout.Button("↺", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(26f),
				GUIHelper.Height(20f)
			}))
			{
				AudioList.RequestRefresh();
			}
			GUILayout.EndHorizontal();
			if (_lastAppliedFilter != _searchFilter || _lastListVersion != AudioList.Version)
			{
				if (_lastAppliedFilter != _searchFilter)
				{
					_leftScroll.y = 0f;
				}
				_lastAppliedFilter = _searchFilter;
				_lastListVersion = AudioList.Version;
				_filteredEntries.Clear();
				foreach (AudioClipEntry entry in AudioList.Entries)
				{
					if (string.IsNullOrEmpty(_searchFilter) || entry.ClipName.IndexOf(_searchFilter, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						_filteredEntries.Add(entry);
					}
				}
			}
			float num = GUIHelper.Scaled(22f);
			int count = _filteredEntries.Count;
			_leftScroll = GUILayout.BeginScrollView(_leftScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			if (count == 0)
			{
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label(string.IsNullOrEmpty(_searchFilter) ? "No clips in memory.\nLoad a save to populate." : "No matches.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			else
			{
				int num2 = Mathf.Max(0, Mathf.FloorToInt(_leftScroll.y / num) - 1);
				int num3 = Mathf.Min(count, num2 + Mathf.CeilToInt(_browserScrollViewH / num) + 2);
				if (num2 > 0)
				{
					GUILayout.Space((float)num2 * num);
				}
				for (int i = num2; i < num3; i++)
				{
					DrawBrowserRow(_filteredEntries[i]);
				}
				if (num3 < count)
				{
					GUILayout.Space((float)(count - num3) * num);
				}
			}
			GUILayout.EndScrollView();
			if ((int)Event.current.type == 7)
			{
				Rect lastRect = GUILayoutUtility.GetLastRect();
				_browserScrollViewH = ((Rect)(ref lastRect)).height;
			}
			if (_hasSelection && _selected != null)
			{
				DrawSelectionDetail(_selected);
			}
			if (GUILayout.Button(Loc.T("Clear List"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				AudioList.ClearList();
			}
			GUILayout.EndVertical();
		}

		private static void DrawBrowserRow(AudioClipEntry entry)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _hasSelection && _selected?.ClipName == entry.ClipName;
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) });
			GUI.contentColor = (Color)(flag ? new Color(0.6f, 0.9f, 1f) : ((!entry.CurrentlyLoaded) ? new Color(0.5f, 0.5f, 0.55f) : Color.white));
			if (GUILayout.Button(entry.CurrentlyLoaded ? GUIHelper.TT(entry.ClipName, "Click to copy name") : GUIHelper.TT(entry.ClipName, "Not loaded this session — catalogued from a prior sweep. Click to copy name."), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
			{
				GUIUtility.systemCopyBuffer = entry.ClipName;
				if (_selected?.ClipName != entry.ClipName)
				{
					_dumpStatus = null;
				}
				_pendingSelectEntry = entry;
			}
			GUI.contentColor = Color.white;
			GUI.contentColor = new Color(0.55f, 0.55f, 0.55f);
			GUILayout.Label(entry.CurrentlyLoaded ? $"{entry.LengthSeconds:0.0}s" : "—", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(36f) });
			GUI.contentColor = Color.white;
			if (entry.HasReplacement)
			{
				GUI.contentColor = new Color(0.4f, 1f, 0.4f);
				GUILayout.Label("[R]", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(28f) });
				GUI.contentColor = Color.white;
			}
			else
			{
				GUILayout.Space(GUIHelper.Scaled(28f));
			}
			if (AudioHandler.IsMuted(entry.ClipName))
			{
				GUI.contentColor = GUIHelper.ColWarn;
				GUILayout.Label("[M]", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(28f) });
				GUI.contentColor = Color.white;
			}
			else
			{
				GUILayout.Space(GUIHelper.Scaled(28f));
			}
			GUILayout.EndHorizontal();
		}

		private static void DrawSelectionDetail(AudioClipEntry entry)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			GUIHelper.Space(4f);
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label($"{entry.ClipName}  {entry.LengthSeconds:0.00}s  " + $"ch:{entry.Channels}  {entry.Frequency}Hz", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			if (entry.SourcePaths.Count > 0)
			{
				GUI.contentColor = new Color(0.55f, 0.55f, 0.55f);
				foreach (string sourcePath in entry.SourcePaths)
				{
					GUILayout.Label("  ← " + sourcePath, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				}
				GUI.contentColor = Color.white;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.enabled = entry.CurrentlyLoaded;
			if (GUILayout.Button("▶ " + Loc.T("Original"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(22f),
				GUILayout.ExpandWidth(true)
			}))
			{
				PreviewVanilla(entry);
			}
			GUI.enabled = entry.CurrentlyLoaded && entry.HasReplacement;
			if (GUILayout.Button("▶ " + Loc.T("Modded"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(22f),
				GUILayout.ExpandWidth(true)
			}))
			{
				PreviewModded(entry);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Open Folder"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(22f),
				GUILayout.ExpandWidth(true)
			}))
			{
				OpenSoundFolder(entry);
			}
			GUI.enabled = entry.CurrentlyLoaded;
			if (GUILayout.Button(Loc.T("Dump WAV"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(22f),
				GUILayout.ExpandWidth(true)
			}))
			{
				DumpClip(entry);
			}
			GUI.enabled = true;
			bool flag = AudioHandler.IsMuted(entry.ClipName);
			bool num = flag && !AudioHandler.IsRootMuted(entry.ClipName);
			GUI.enabled = !num;
			if (GUILayout.Button(num ? Loc.T("Muted by pack") : (flag ? Loc.T("Unmute") : Loc.T("Mute")), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(22f),
				GUILayout.ExpandWidth(true)
			}))
			{
				AudioHandler.SetRootMute(entry.ClipName, !flag);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUI.contentColor = new Color(0.7f, 0.8f, 0.7f);
			GUILayout.Label(_dumpStatus ?? "", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(4f);
		}

		private static void DrawLogPane(float width)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(width) });
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(Loc.T("Live Log"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			int maxVisible = Mathf.Clamp(Plugin.Config.AudioLogMaxVisible, 5, 50);
			double logAudioDuration = Plugin.Config.LogAudioDuration;
			_rightScroll = GUILayout.BeginScrollView(_rightScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			AudioLog.DrawEntries(maxVisible, logAudioDuration, Plugin.Config.HideModdedAudioInLog);
			GUILayout.EndScrollView();
			if (GUILayout.Button(Loc.T("Clear Log"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				AudioLog.ClearLog();
			}
			GUILayout.EndVertical();
		}

		private static void FocusClipByName(string clipName)
		{
			if (!string.IsNullOrEmpty(_searchFilter))
			{
				_searchFilter = "";
				_lastAppliedFilter = null;
			}
			for (int i = 0; i < _filteredEntries.Count; i++)
			{
				if (string.Equals(_filteredEntries[i].ClipName, clipName, StringComparison.OrdinalIgnoreCase))
				{
					_selected = _filteredEntries[i];
					_hasSelection = true;
					float num = GUIHelper.Scaled(22f);
					_leftScroll.y = Mathf.Max(0f, (float)i * num - _browserScrollViewH * 0.5f);
					return;
				}
			}
			AudioList.RequestRefresh();
		}

		private static void OpenSoundFolder(AudioClipEntry entry)
		{
			string soundFolder = AudioHandler.SoundFolder;
			IOUtil.EnsureDirectoryExists(soundFolder);
			string text = null;
			string[] array = new string[5] { ".ogg", ".wav", ".mp3", ".aiff", ".aif" };
			foreach (string text2 in array)
			{
				string text3 = Path.Combine(soundFolder, entry.ClipName + text2);
				if (File.Exists(text3))
				{
					text = text3;
					break;
				}
			}
			if (text != null)
			{
				IOUtil.RevealPath(text);
			}
			else
			{
				IOUtil.OpenPath(soundFolder);
			}
		}

		private static void PreviewVanilla(AudioClipEntry entry)
		{
			AudioClip val = AudioHandler.FindVanillaClipForDump(entry.ClipName);
			if ((Object)(object)val == (Object)null)
			{
				_dumpStatus = "no clip in memory to preview (load the scene that uses it)";
				return;
			}
			AudioDumper.Preview(val);
			_dumpStatus = "Previewing original '" + entry.ClipName + "'…";
		}

		private static void PreviewModded(AudioClipEntry entry)
		{
			AudioClip replacementClipForPreview = AudioHandler.GetReplacementClipForPreview(entry.ClipName);
			if ((Object)(object)replacementClipForPreview == (Object)null)
			{
				_dumpStatus = "modded clip not loaded yet — press again in a moment (loading)";
				return;
			}
			AudioDumper.Preview(replacementClipForPreview);
			_dumpStatus = "Previewing modded '" + entry.ClipName + "'…";
		}

		private static void DumpClip(AudioClipEntry entry)
		{
			AudioClip val = AudioHandler.FindVanillaClipForDump(entry.ClipName);
			if ((Object)(object)val == (Object)null)
			{
				_dumpStatus = "no vanilla clip in memory for that name (load the scene that uses it)";
				return;
			}
			_dumpStatus = $"Capturing '{entry.ClipName}' (~{val.length:0.0}s, silent)…";
			string clipName = entry.ClipName;
			((MonoBehaviour)Plugin.Instance).StartCoroutine(AudioDumper.CaptureClipAsync(val, delegate(bool ok, string message)
			{
				_dumpStatus = (ok ? ("Dumped → " + message) : message);
				if (ok)
				{
					Plugin.Logger.LogInfo((object)("[AudioDumper] " + clipName + " → " + message));
				}
				else
				{
					Plugin.Logger.LogWarning((object)("[AudioDumper] " + clipName + ": " + message));
				}
			}));
		}

		private static void EnsureScanned()
		{
			if (Time.realtimeSinceStartup - _lastScanTime < 3f)
			{
				return;
			}
			_lastScanTime = Time.realtimeSinceStartup;
			int num = 0;
			if (Directory.Exists(AudioHandler.SoundFolder))
			{
				string[] array = new string[3] { ".wav", ".ogg", ".mp3" };
				string[] files = Directory.GetFiles(AudioHandler.SoundFolder, "*", SearchOption.AllDirectories);
				for (int i = 0; i < files.Length; i++)
				{
					string value = Path.GetExtension(files[i]).ToLowerInvariant();
					if (Array.IndexOf(array, value) >= 0)
					{
						num++;
					}
				}
			}
			_diskFileCount = num;
		}
	}
	public static class DashboardPillar
	{
		private enum FileStatus
		{
			OnDisk,
			Pending,
			Loaded
		}

		private class FileEntry
		{
			public string Name;

			public FileStatus Status;
		}

		private static Vector2 _scroll;

		private static Dictionary<string, List<FileEntry>> _scannedFiles;

		private static float _lastScanTime = -999f;

		private const float ScanCooldown = 2f;

		private static bool _showSprites = true;

		private static bool _showT2D = true;

		private static bool _showAudio = false;

		private static bool _showVideo = false;

		private static bool _showText = false;

		private static bool _healthFoldout;

		private static List<HealthCheck.Item> _health;

		private static float _healthTime = -999f;

		private static bool _targetListOpen;

		private static float _targetListScrollY;

		private static Rect _targetAnchorRect;

		private static Rect _targetOpenerRect;

		private const int DropdownMaxVisibleRows = 8;

		private static float _pullReplaceArmedAt = -1f;

		private const float PullReplaceArmWindowSec = 3f;

		private static bool _showGlossary = false;

		private static string _glossarySearch = "";

		private static GUIStyle _glossaryTextStyle;

		private static int _glossaryFontSize;

		private static float DropdownRowH => GUIHelper.Scaled(24f);

		private static float DropdownPad => GUIHelper.Scaled(3f);

		private static GUIStyle GlossaryTextStyle
		{
			get
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				int num = GUIHelper.FontSize(13);
				if (_glossaryTextStyle == null || _glossaryFontSize != num)
				{
					_glossaryFontSize = num;
					_glossaryTextStyle = new GUIStyle(GUIHelper.LabelStyle)
					{
						wordWrap = true
					};
				}
				return _glossaryTextStyle;
			}
		}

		private static void DrawHealthStrip()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			if (_health == null || Time.realtimeSinceStartup - _healthTime > 2f)
			{
				_health = HealthCheck.Run();
				_healthTime = Time.realtimeSinceStartup;
			}
			int num = _health.Count((HealthCheck.Item i) => i.Status == HealthCheck.Status.Warn);
			GUI.contentColor = ((num == 0) ? GUIHelper.ColConfirm : GUIHelper.ColWarn);
			if (GUILayout.Button((_healthFoldout ? "▼ " : "▶ ") + ((num == 0) ? Loc.T("Health: all checks green") : string.Format(Loc.T("Health: {0} warning(s)"), num)), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				_healthFoldout = !_healthFoldout;
			}
			GUI.contentColor = Color.white;
			if (_healthFoldout)
			{
				foreach (HealthCheck.Item item in _health)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUI.contentColor = (Color)(item.Status switch
					{
						HealthCheck.Status.Ok => GUIHelper.ColConfirm, 
						HealthCheck.Status.Warn => GUIHelper.ColWarn, 
						_ => GUIHelper.ColMuted, 
					});
					GUILayout.Label("●", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(16f) });
					GUILayout.Label(item.Name, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(190f) });
					GUILayout.Label(item.Detail, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
					GUI.contentColor = Color.white;
					GUILayout.EndHorizontal();
				}
			}
			GUIHelper.Space(4f);
		}

		private static Rect TargetDropdownRect(int rowCount)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			float num = DropdownRowH * (float)Mathf.Min(Mathf.Max(rowCount, 1), 8) + DropdownPad * 2f;
			return new Rect(((Rect)(ref _targetAnchorRect)).x, ((Rect)(ref _targetAnchorRect)).yMax + GUIHelper.Scaled(2f), ((Rect)(ref _targetAnchorRect)).width, num);
		}

		private static void HandleTargetDropdownInput()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Invalid comparison between Unknown and I4
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Invalid comparison between Unknown and I4
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if (!_targetListOpen)
			{
				return;
			}
			IReadOnlyList<PackInfo> allPacks = PackManager.AllPacks;
			Rect val = TargetDropdownRect(allPacks.Count);
			Event current = Event.current;
			if ((int)current.type == 4 && (int)current.keyCode == 27)
			{
				_targetListOpen = false;
				current.Use();
			}
			else if ((int)current.type == 6 && ((Rect)(ref val)).Contains(current.mousePosition))
			{
				float num = Mathf.Max(0f, (float)allPacks.Count * DropdownRowH - (((Rect)(ref val)).height - DropdownPad * 2f));
				_targetListScrollY = Mathf.Clamp(_targetListScrollY + current.delta.y * DropdownRowH, 0f, num);
				current.Use();
			}
			else if ((int)current.type == 0)
			{
				if (((Rect)(ref val)).Contains(current.mousePosition))
				{
					int num2 = (int)((current.mousePosition.y - ((Rect)(ref val)).y - DropdownPad + _targetListScrollY) / DropdownRowH);
					if (num2 >= 0 && num2 < allPacks.Count)
					{
						PushPull.SetTarget(allPacks[num2]);
						_targetListOpen = false;
					}
					current.Use();
				}
				else if (!((Rect)(ref _targetOpenerRect)).Contains(current.mousePosition))
				{
					_targetListOpen = false;
					current.Use();
				}
			}
			else if (((int)current.type == 1 || (int)current.type == 3) && ((Rect)(ref val)).Contains(current.mousePosition))
			{
				current.Use();
			}
		}

		private static void PaintTargetDropdown()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0021: 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)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			if (!_targetListOpen || (int)Event.current.type != 7)
			{
				return;
			}
			IReadOnlyList<PackInfo> allPacks = PackManager.AllPacks;
			Rect val = TargetDropdownRect(allPacks.Count);
			PackInfo packInfo = PushPull.ResolveTarget();
			float dropdownRowH = DropdownRowH;
			GUI.color = GUIHelper.ColSurface2;
			GUI.DrawTexture(val, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
			GUIHelper.DrawBorder(val, GUIHelper.ColBorderHi);
			if (allPacks.Count == 0)
			{
				GUI.contentColor = GUIHelper.ColFaint;
				GUI.Label(val, Loc.T("No packs found"), GUIHelper.LabelCenteredStyle);
				GUI.contentColor = Color.white;
				return;
			}
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref val)).x, ((Rect)(ref val)).y + DropdownPad, ((Rect)(ref val)).width, ((Rect)(ref val)).height - DropdownPad * 2f);
			GUI.BeginGroup(val2);
			Vector2 mousePosition = Event.current.mousePosition;
			Rect val3 = default(Rect);
			for (int i = 0; i < allPacks.Count; i++)
			{
				float num = (float)i * dropdownRowH - _targetListScrollY;
				if (num + dropdownRowH < 0f || num > ((Rect)(ref val2)).height)
				{
					continue;
				}
				((Rect)(ref val3))..ctor(0f, num, ((Rect)(ref val2)).width, dropdownRowH);
				PackInfo packInfo2 = allPacks[i];
				int num2;
				if (packInfo != null)
				{
					num2 = (string.Equals(packInfo2.Path, packInfo.Path, StringComparison.OrdinalIgnoreCase) ? 1 : 0);
					if (num2 != 0)
					{
						GUI.color = new Color(GUIHelper.ColAccentSoft.r, GUIHelper.ColAccentSoft.g, GUIHelper.ColAccentSoft.b, 0.3f);
						GUI.DrawTexture(val3, (Texture)(object)Texture2D.whiteTexture);
						GUI.color = Color.white;
						goto IL_01ba;
					}
				}
				else
				{
					num2 = 0;
				}
				if (((Rect)(ref val3)).Contains(mousePosition))
				{
					GUI.color = GUIHelper.ColBorder;
					GUI.DrawTexture(val3, (Texture)(object)Texture2D.whiteTexture);
					GUI.color = Color.white;
				}
				goto IL_01ba;
				IL_01ba:
				string text = (PackLayout.IsCustomizerPack(packInfo2.Path) ? (packInfo2.Name + "  (" + Loc.T("customizer") + ")") : packInfo2.Name);
				string effectiveAuthor = packInfo2.EffectiveAuthor;
				if (effectiveAuthor != null)
				{
					text = text + "  ·  " + string.Format(Loc.T("by {0}"), effectiveAuthor);
				}
				GUI.contentColor = ((num2 != 0) ? GUIHelper.ColAccent : GUIHelper.ColText);
				GUI.Label(new Rect(GUIHelper.Scaled(8f), num + (dropdownRowH - GUIHelper.Scaled(18f)) * 0.5f, ((Rect)(ref val2)).width - GUIHelper.Scaled(16f), GUIHelper.Scaled(18f)), text, GUIHelper.LabelStyle);
				GUI.contentColor = Color.white;
			}
			GUI.EndGroup();
			if (allPacks.Count > 8)
			{
				float num3 = (float)allPacks.Count * dropdownRowH;
				float num4 = GUIHelper.Scaled(3f);
				Rect val4 = default(Rect);
				((Rect)(ref val4))..ctor(((Rect)(ref val)).xMax - num4 - 2f, ((Rect)(ref val2)).y, num4, ((Rect)(ref val2)).height);
				float num5 = Mathf.Max(GUIHelper.Scaled(16f), ((Rect)(ref val4)).height * (((Rect)(ref val2)).height / num3));
				float num6 = _targetListScrollY / (num3 - ((Rect)(ref val2)).height);
				Rect val5 = new Rect(((Rect)(ref val4)).x, ((Rect)(ref val4)).y + num6 * (((Rect)(ref val4)).height - num5), num4, num5);
				GUI.color = GUIHelper.ColBorder;
				GUI.DrawTexture(val4, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = GUIHelper.ColFaint;
				GUI.DrawTexture(val5, (Texture)(object)Texture2D.whiteTexture);
				GUI.color = Color.white;
			}
		}

		private static void DrawTargetPackPanel()
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Invalid comparison between Unknown and I4
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			PackInfo packInfo = PushPull.ResolveTarget();
			if (packInfo == null)
			{
				Rect rect = GUILayoutUtility.GetRect(0f, GUIHelper.Scaled(52f), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
				if (GUI.Button(rect, GUIContent.none, GUIStyle.none))
				{
					_targetListOpen = !_targetListOpen;
				}
				if ((int)Event.current.type == 7)
				{
					_targetAnchorRect = rect;
					_targetOpenerRect = rect;
				}
				GUIHelper.DrawDashedRect(rect, _targetListOpen ? GUIHelper.ColText : GUIHelper.ColMuted);
				Rect val = new Rect(((Rect)(ref rect)).x + 6f, ((Rect)(ref rect)).y + 4f, ((Rect)(ref rect)).width - 12f, ((Rect)(ref rect)).height - 8f);
				GUI.contentColor = GUIHelper.ColMuted;
				GUI.Label(val, Loc.T("No target pack — pick one to enable Push/Pull"), GUIHelper.LabelCenteredStyle);
				GUI.contentColor = Color.white;
			}
			else
			{
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				GUIHelper.Space(5f);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Space(GUIHelper.Scaled(8f));
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUI.contentColor = GUIHelper.ColMuted;
				GUILayout.Label(Loc.T("Target pack:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
				GUI.contentColor = Color.white;
				string effectiveAuthor = packInfo.EffectiveAuthor;
				if (GUILayout.Button(new GUIContent((effectiveAuthor != null) ? (packInfo.Name + "  ·  " + string.Format(Loc.T("by {0}"), effectiveAuthor)) : packInfo.Name, Loc.T("click to change object")), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>()))
				{
					_targetListOpen = !_targetListOpen;
				}
				GUILayout.FlexibleSpace();
				if (GUIHelper.GhostButton("✕", GUIHelper.Width(24f), GUIHelper.Height(20f)))
				{
					PushPull.SetTarget(null);
				}
				GUILayout.EndHorizontal();
				if ((int)Event.current.type == 7)
				{
					_targetOpenerRect = GUILayoutUtility.GetLastRect();
				}
				bool targetIsReadOnly = PushPull.TargetIsReadOnly;
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUI.enabled = !targetIsReadOnly;
				if (GUILayout.Button(Loc.T("Push"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					PushPull.Push();
				}
				GUI.enabled = true;
				if (GUILayout.Button(Loc.T("Pull (merge)"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					PushPull.Pull(replace: false);
				}
				bool flag = _pullReplaceArmedAt > 0f && Time.realtimeSinceStartup - _pullReplaceArmedAt < 3f;
				Color backgroundColor = GUI.backgroundColor;
				if (flag)
				{
					GUI.backgroundColor = GUIHelper.ColDanger;
				}
				if (GUILayout.Button(flag ? Loc.T("Click again to confirm") : Loc.T("Pull (replace)"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					if (flag)
					{
						_pullReplaceArmedAt = -1f;
						PushPull.Pull(replace: true);
					}
					else
					{
						_pullReplaceArmedAt = Time.realtimeSinceStartup;
					}
				}
				GUI.backgroundColor = backgroundColor;
				GUILayout.EndHorizontal();
				if (targetIsReadOnly)
				{
					GUI.contentColor = GUIHelper.ColMuted;
					GUILayout.Label(Loc.T("Customizer pack — read-only; Pull works, Push is disabled."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
					GUI.contentColor = Color.white;
				}
				if (PushPull.LastSummary != null)
				{
					GUI.contentColor = GUIHelper.ColFaint;
					GUILayout.Label(PushPull.LastSummary, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
					GUI.contentColor = Color.white;
				}
				GUILayout.EndVertical();
				GUILayout.Space(GUIHelper.Scaled(8f));
				GUILayout.EndHorizontal();
				GUIHelper.Space(5f);
				GUILayout.EndVertical();
				if ((int)Event.current.type == 7)
				{
					_targetAnchorRect = GUILayoutUtility.GetLastRect();
					GUIHelper.DrawDashedRect(_targetAnchorRect, _targetListOpen ? GUIHelper.ColText : GUIHelper.ColAccentSoft);
				}
			}
			GUIHelper.Space(6f);
		}

		public static void Draw()
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			HandleTargetDropdownInput();
			DrawHealthStrip();
			DrawTargetPackPanel();
			if (Plugin.Config != null && Plugin.Config.DevMode)
			{
				if (GUILayout.Button(Loc.T("Run pipeline self-test"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					PipelineSelfTest.Run();
				}
				GUI.contentColor = GUIHelper.ColMuted;
				GUILayout.Label(PipelineSelfTest.LastSummary, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				GUIHelper.Space(4f);
			}
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(string.Format(Loc.T("tk2d sprites: {0} in {1} collections  T2D: {2} loaded  Sheets: {3}"), SpriteLoader.LoadedSpriteCount, SpriteLoader.LoadedCollectionCount, T2DLoader.LoadedT2DSpriteCount, T2DLoader.SpritesheetOverrideCount), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Refresh File Scan"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				_lastScanTime = -999f;
			}
			if (GUILayout.Button(Loc.T("Reload Sprites"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				FileCache.BeginCycle();
				try
				{
					SpriteLoader.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			EnsureScanned();
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			DrawFileSection(Loc.T("Sprites"), "sprites", ref _showSprites);
			DrawFileSection(Loc.T("T2D Sprites"), "t2d", ref _showT2D);
			DrawFileSection(Loc.T("Sounds"), "sounds", ref _showAudio);
			DrawFileSection(Loc.T("Videos"), "videos", ref _showVideo);
			DrawFileSection(Loc.T("Text"), "text", ref _showText);
			DrawGlossarySection();
			GUILayout.EndScrollView();
			PaintTargetDropdown();
		}

		private static void DrawGlossarySection()
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			IReadOnlyList<KeyValuePair<string, string>> glossary = Loc.Glossary;
			if (glossary.Count == 0)
			{
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			string arg = (_showGlossary ? "▼" : "►");
			if (GUILayout.Button(string.Format("{0} {1} ({2})", arg, Loc.T("Glossary"), glossary.Count), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				_showGlossary = !_showGlossary;
			}
			GUILayout.EndHorizontal();
			if (!_showGlossary)
			{
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("  " + Loc.T("Search:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(70f) });
			_glossarySearch = GUIHelper.TextField("Stitchwork.GlossarySearch", _glossarySearch, GUIHelper.Width(180f));
			GUILayout.EndHorizontal();
			foreach (KeyValuePair<string, string> item in glossary)
			{
				if (string.IsNullOrEmpty(_glossarySearch) || item.Key.IndexOf(_glossarySearch, StringComparison.OrdinalIgnoreCase) >= 0 || item.Value.IndexOf(_glossarySearch, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUI.contentColor = GUIHelper.ColAccent;
					GUILayout.Label("  " + item.Key, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(150f) });
					GUI.contentColor = Color.white;
					GUILayout.Label(item.Value, GlossaryTextStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
					GUILayout.EndHorizontal();
					GUIHelper.Space(2f);
				}
			}
		}

		private static void EnsureScanned()
		{
			if (_scannedFiles != null && Time.realtimeSinceStartup - _lastScanTime < 2f)
			{
				return;
			}
			_scannedFiles = new Dictionary<string, List<FileEntry>>();
			_lastScanTime = Time.realtimeSinceStartup;
			List<FileEntry> list = new List<FileEntry>();
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				string text = Path.Combine(pluginPackPath, "sprites");
				if (Directory.Exists(text))
				{
					ScanPng(text, list);
				}
			}
			_scannedFiles["sprites"] = list;
			List<FileEntry> list2 = new List<FileEntry>();
			ScanPng(T2DLoader.AtlasLoadPath, list2);
			HashSet<string> hashSet = new HashSet<string>(T2DLoader.LoadedT2DSpriteNames);
			HashSet<string> hashSet2 = new HashSet<string>(T2DLoader.SpritesheetOverrideNames);
			foreach (FileEntry item in list2)
			{
				if (hashSet.Contains(item.Name) || hashSet2.Contains(item.Name))
				{
					item.Status = FileStatus.Loaded;
				}
			}
			_scannedFiles["t2d"] = list2;
			List<FileEntry> list3 = new List<FileEntry>();
			if (Directory.Exists(AudioHandler.SoundFolder))
			{
				ScanExt(AudioHandler.SoundFolder, list3, new string[3] { ".wav", ".ogg", ".mp3" });
			}
			bool flag = AudioHandler.CachedClipCount > 0;
			foreach (FileEntry item2 in list3)
			{
				item2.Status = (flag ? FileStatus.Loaded : FileStatus.OnDisk);
			}
			_scannedFiles["sounds"] = list3;
			List<FileEntry> list4 = new List<FileEntry>();
			if (Directory.Exists(VideoHandler.VideoLoadPath))
			{
				ScanExt(VideoHandler.VideoLoadPath, list4, new string[3] { ".mp4", ".webm", ".ogv" });
			}
			foreach (FileEntry item3 in list4)
			{
				if (VideoHandler.VideoFileMap.TryGetValue(item3.Name, out var value) && value != null)
				{
					item3.Status = FileStatus.Loaded;
				}
			}
			_scannedFiles["videos"] = list4;
			List<FileEntry> list5 = new List<FileEntry>();
			HashSet<string> seen = new HashSet<string>();
			ScanTextDir(DialogueHandler.TextLoadPath, list5, seen);
			foreach (string pluginPackPath2 in Plugin.PluginPackPaths)
			{
				ScanTextDir(Path.Combine(pluginPackPath2, "Text"), list5, seen);
			}
			string currentLangCode = DialogueHandler.CurrentLangCode;
			if (DialogueHandler.TextCache.TryGetValue(currentLangCode, out var value2))
			{
				foreach (FileEntry item4 in list5)
				{
					int num = item4.Name.IndexOf('/');
					if (num >= 0)
					{
						string key = item4.Name.Substring(0, num);
						if (Path.GetFileNameWithoutExtension(item4.Name.Substring(num + 1)) == currentLangCode && value2.ContainsKey(key))
						{
							item4.Status = FileStatus.Loaded;
						}
					}
				}
			}
			_scannedFiles["text"] = list5;
		}

		private static void DrawFileSection(string title, string key, ref bool expanded)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			if (!_scannedFiles.TryGetValue(key, out var value))
			{
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			string arg = (expanded ? "▼" : "►");
			if (GUILayout.Button($"{arg} {title} ({value.Count})", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				expanded = !expanded;
			}
			GUILayout.EndHorizontal();
			if (!expanded)
			{
				return;
			}
			foreach (FileEntry item in value)
			{
				Color contentColor = (Color)(item.Status switch
				{
					FileStatus.Loaded => Color.green, 
					FileStatus.Pending => Color.yellow, 
					_ => new Color(0.7f, 0.7f, 0.7f), 
				});
				string text = item.Status switch
				{
					FileStatus.Loaded => "● " + Loc.T("loaded"), 
					FileStatus.Pending => "○ " + Loc.T("pending"), 
					_ => "□ " + Loc.T("on-disk"), 
				};
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("  " + item.Name, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
				GUI.contentColor = contentColor;
				GUILayout.Label(text, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(90f) });
				GUI.contentColor = Color.white;
				GUILayout.EndHorizontal();
			}
		}

		private static void ScanPng(string directory, List<FileEntry> out_)
		{
			if (Directory.Exists(directory))
			{
				string[] files = Directory.GetFiles(directory, "*.png", SearchOption.AllDirectories);
				foreach (string path in files)
				{
					out_.Add(new FileEntry
					{
						Name = Path.GetFileNameWithoutExtension(path),
						Status = FileStatus.OnDisk
					});
				}
			}
		}

		private static void ScanExt(string directory, List<FileEntry> out_, string[] extensions)
		{
			if (!Directory.Exists(directory))
			{
				return;
			}
			string[] files = Directory.GetFiles(directory, "*", SearchOption.AllDirectories);
			foreach (string path in files)
			{
				string value = Path.GetExtension(path).ToLowerInvariant();
				if (Array.IndexOf(extensions, value) >= 0)
				{
					out_.Add(new FileEntry
					{
						Name = Path.GetFileName(path),
						Status = FileStatus.OnDisk
					});
				}
			}
		}

		private static void ScanTextDir(string textRoot, List<FileEntry> out_, HashSet<string> seen)
		{
			if (!Directory.Exists(textRoot))
			{
				return;
			}
			string[] files = Directory.GetFiles(textRoot, "*.yml", SearchOption.AllDirectories);
			for (int i = 0; i < files.Length; i++)
			{
				string text = files[i].Substring(textRoot.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).Replace('\\', '/');
				if (seen.Add(text))
				{
					out_.Add(new FileEntry
					{
						Name = text,
						Status = FileStatus.OnDisk
					});
				}
			}
		}
	}
	public static class DebugPillar
	{
		private static Vector2 _scroll;

		private static float _fullDumpArmedAt = -1f;

		private const float FullDumpArmWindowSec = 4f;

		private static string _lastConvert;

		public static void Draw()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			DrawDumpSection();
			GUIHelper.Space();
			DevProfiler.DrawPillarContent();
			GUILayout.EndScrollView();
		}

		private static void DrawDumpSection()
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Label(Loc.T("Dumping"), GUIHelper.SectionHeaderStyle, Array.Empty<GUILayoutOption>());
			bool dumpSprites = Plugin.Config.DumpSprites;
			bool flag = GUIHelper.ToggleButton(dumpSprites, Loc.T("Dump sprites on scene load"), GUIHelper.Height(22f));
			if (flag != dumpSprites)
			{
				Plugin.Config.DumpSprites = flag;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Dump Text Now"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				DialogueHandler.DumpText();
			}
			bool num = Plugin.Config.DumpSprites && !SceneTraverser.IsTraversing;
			bool flag2 = _fullDumpArmedAt > 0f && Time.realtimeSinceStartup - _fullDumpArmedAt < 4f;
			if (!num)
			{
				flag2 = false;
			}
			GUI.enabled = num;
			Color backgroundColor = GUI.backgroundColor;
			if (num)
			{
				GUI.backgroundColor = (flag2 ? GUIHelper.ColDanger : GUIHelper.ColAccentSoft);
			}
			if (GUILayout.Button(flag2 ? Loc.T("Click again to confirm") : Loc.T("Full Dump"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				if (flag2)
				{
					_fullDumpArmedAt = -1f;
					SceneTraverser.TraverseAllScenes();
				}
				else
				{
					_fullDumpArmedAt = Time.realtimeSinceStartup;
				}
			}
			GUI.backgroundColor = backgroundColor;
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUI.contentColor = (flag2 ? GUIHelper.ColWarn : GUIHelper.ColFaint);
			GUILayout.Label(SceneTraverser.IsTraversing ? string.Format(Loc.T("Full dump running: scene {0}/{1}"), SceneTraverser.Processed, SceneTraverser.Total) : ((!Plugin.Config.DumpSprites) ? Loc.T("Enable sprite dumping to arm the full dump.") : Loc.T("Heavy: visits EVERY scene (~20 min). Ends at the main menu; your save file is never written.")), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(6f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Convert Sheets"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				bool convertOnlyChanged = Plugin.Config.ConvertOnlyChanged;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
				foreach (tk2dSpriteCollectionData val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						(int sheets, int written, int identical) tuple = SpriteDumper.ConvertCollectionSheets(val, convertOnlyChanged);
						int item = tuple.sheets;
						int item2 = tuple.written;
						int item3 = tuple.identical;
						num2 += item;
						num3 += item2;
						num4 += item3;
					}
				}
				(int sheets, int written, int identical) tuple2 = T2DLoader.ConvertAllActiveSheets(convertOnlyChanged);
				int item4 = tuple2.sheets;
				int item5 = tuple2.written;
				int item6 = tuple2.identical;
				num2 += item4;
				num3 += item5;
				num4 += item6;
				_lastConvert = string.Format(Loc.T("{0} sheet(s) → {1} sprite(s) written, {2} identical skipped"), num2, num3, num4);
				Plugin.Logger.LogInfo((object)($"[Convert] {num2} sheet(s) → {num3} sprite(s), " + $"{num4} identical skipped (onlyChanged={convertOnlyChanged}) → {SpriteDumper.ConvertPath}"));
				if (num3 > 0)
				{
					IOUtil.OpenPath(SpriteDumper.ConvertPath);
				}
			}
			bool convertOnlyChanged2 = Plugin.Config.ConvertOnlyChanged;
			bool flag3 = GUIHelper.ToggleButton(convertOnlyChanged2, Loc.T("only changed"), GUILayout.ExpandWidth(false), GUIHelper.Height(22f));
			if (flag3 != convertOnlyChanged2)
			{
				Plugin.Config.ConvertOnlyChanged = flag3;
			}
			GUILayout.EndHorizontal();
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(_lastConvert ?? Loc.T("Splits active whole-sheet replacements into individual sprite PNGs (Converted/). Sheets must be loaded — visit a scene that uses them."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
	}
	public static class GraphicsPillar
	{
		private static int _tab = 0;

		private static Vector2 _logScroll;

		private const int TabAnimation = 0;

		private const int TabT2D = 1;

		private const int TabT2DLog = 2;

		private const int TabMaterials = 3;

		private static readonly List<(Color c, int count, string example)> _palette = new List<(Color, int, string)>();

		private static readonly List<(Color oldC, Color newC)> _rootRules = new List<(Color, Color)>();

		private static Color? _rootAmbient;

		private static string _rootRulesScene;

		private static string _paletteScene;

		private static int _selSwatch = -1;

		private static bool _globalSel;

		private static Color _customC = Color.white;

		private static string _customHex = "";

		private static readonly string[] _chanBuf = new string[4] { "", "", "", "" };

		private static bool _previewDirty;

		private static float _lastPreviewApply;

		private static Vector2 _paletteScroll;

		private static bool _showDiagnostics;

		private static string _pickStatus = "";

		private static string _imbuementDumpStatus = "";

		private static GUIStyle _midLabel;

		private static Color? _rootSlashBase;

		private static Color? _rootSlashFire;

		private static Color? _rootSlashPoison;

		private static GUIStyle MidLabel
		{
			get
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				if (_midLabel == null || _midLabel.fontSize != GUIHelper.LabelStyle.fontSize)
				{
					_midLabel = new GUIStyle(GUIHelper.LabelStyle)
					{
						alignment = (TextAnchor)3
					};
				}
				return _midLabel;
			}
		}

		internal static void SwitchToT2DBrowser()
		{
			_tab = 1;
		}

		internal static void SwitchToAnimation()
		{
			_tab = 0;
		}

		public static void Draw()
		{
			T2DLoader.IsT2DLogActive = _tab == 1 || _tab == 2;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Toggle(_tab == 0, Loc.T("Animation"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				_tab = 0;
			}
			if (GUILayout.Toggle(_tab == 1, Loc.T("T2D Textures"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				_tab = 1;
			}
			if (GUILayout.Toggle(_tab == 2, Loc.T("T2D Log"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				_tab = 2;
			}
			if (GUILayout.Toggle(_tab == 3, Loc.T("Colors"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
			{
				_tab = 3;
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			if (_tab == 0)
			{
				AnimationController.DrawPillarContent();
			}
			else if (_tab == 1)
			{
				T2DTextureController.DrawPillarContent();
			}
			else if (_tab == 2)
			{
				DrawT2DLog();
			}
			else if (_tab == 3)
			{
				DrawSceneColour();
			}
		}

		internal static void SelectColourFromWorldPick(SpriteRenderer sr)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			_tab = 3;
			if ((Object)(object)sr == (Object)null)
			{
				_pickStatus = Loc.T("No pickable object there");
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			bool num = RecolourHandler.SceneOwned(((Component)sr).gameObject);
			int instanceID = ((Object)sr).GetInstanceID();
			Color vanilla;
			Color from;
			Color col = (RecolourHandler.TryGetVanilla(instanceID, out vanilla) ? vanilla : (RecolourHandler.TryGetGlobalFrom(instanceID, out from) ? from : sr.color));
			if (_paletteScene != name)
			{
				ScanPalette(name);
			}
			int num2 = _palette.FindIndex(((Color c, int count, string example) p) => RecolourHandler.Match(p.c, col, 0.05f));
			if (num2 < 0)
			{
				_palette.Insert(0, (col, 1, ((Object)sr).name));
				num2 = 0;
			}
			SelectSwatch(num2, name);
			_globalSel = !num;
			if (_globalSel)
			{
				if (RecolourHandler.TryGetGlobalRule(col, out var newC))
				{
					_customC = newC;
					_customHex = RecolourHandler.ToHex(newC);
					SyncChannelBufs();
				}
				_pickStatus = string.Format(Loc.T("Picked (global): {0}"), ((Object)sr).name);
			}
			else
			{
				_pickStatus = string.Format(Loc.T("Picked: {0}"), ((Object)sr).name);
			}
		}

		private static void DrawSceneColour()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_050e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0692: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_068b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0682: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_083c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bcc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bf0: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_06af: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_093f: Unknown result type (might be due to invalid IL or missing references)
			//IL_091b: Unknown result type (might be due to invalid IL or missing references)
			//IL_092e: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_095c: Unknown result type (might be due to invalid IL or missing references)
			//IL_095e: Unknown result type (might be due to invalid IL or missing references)
			//IL_079b: Unknown result type (might be due to invalid IL or missing references)
			//IL_096a: Unknown result type (might be due to invalid IL or missing references)
			//IL_096c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0975: Unknown result type (might be due to invalid IL or missing references)
			//IL_07de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2a: Unknown result type (might be due to invalid IL or missing references)
			//IL_09aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a50: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0add: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b63: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			GUILayout.Label(string.Format(Loc.T("Scene: {0}"), name), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(RecolourHandler.RootFileFor(name), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(Loc.T("Recolors scenery sprites and particles. Characters do not respond (engine shader)."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(Loc.T("Scan scene colors"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width(160f)
			}))
			{
				ScanPalette(name);
			}
			if (GUILayout.Button(Loc.T("Pick color in world"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width(160f)
			}))
			{
				WorldPickMode.Enter(WorldPickMode.Preset.SceneColour);
			}
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label((_paletteScene == name) ? string.Format(Loc.T("{0} color(s) found"), _palette.Count) : "", MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUIHelper.Height(24f)
			});
			GUILayout.Label(string.Format(Loc.T("Recolored now: {0}"), RecolourHandler.AppliedCount), MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(false),
				GUIHelper.Height(24f)
			});
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			if (!string.IsNullOrEmpty(_pickStatus))
			{
				GUI.contentColor = GUIHelper.ColFaint;
				GUILayout.Label(_pickStatus, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUIHelper.Space(4f);
			if (!string.Equals(_rootRulesScene, name, StringComparison.Ordinal))
			{
				RefreshRootRules(name);
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Color backgroundColor = GUI.backgroundColor;
			if (_selSwatch == -2)
			{
				GUI.backgroundColor = GUIHelper.ColAccentSoft;
			}
			if (GUILayout.Button(Loc.T("Scene ambient"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width(150f)
			}))
			{
				SelectAmbient();
			}
			GUI.backgroundColor = backgroundColor;
			DrawSwatch(RecolourHandler.CurrentAmbientVanilla, 30f, 16f, 24f);
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("whole scene, characters included"), MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUIHelper.Height(24f)
			});
			if (_rootAmbient.HasValue)
			{
				GUI.contentColor = GUIHelper.ColConfirm;
				GUILayout.Label("→ " + RecolourHandler.ToHex(_rootAmbient.Value), MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.ExpandWidth(false),
					GUIHelper.Height(24f)
				});
				DrawSwatch(_rootAmbient.Value, 30f, 16f, 24f);
			}
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("Slash colors"), MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(false),
				GUIHelper.Height(22f)
			});
			GUI.contentColor = Color.white;
			DrawSlashChip(-3, "base", Loc.T("Base@slash", "Base"));
			DrawSlashChip(-4, "fire", Loc.T("Fire@slash", "Fire"));
			DrawSlashChip(-5, "poison", Loc.T("Poison@slash", "Poison"));
			GUI.contentColor = GUIHelper.ColFaint;
			GUILayout.Label(Loc.T("base shows on your next swing"), MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUIHelper.Height(22f)
			});
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			if (_paletteScene == name && _palette.Count > 0)
			{
				_paletteScroll = GUILayout.BeginScrollView(_paletteScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GUIHelper.Scaled(170f)) });
				for (int i = 0; i < _palette.Count; i++)
				{
					var (val, num, text) = _palette[i];
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					DrawSwatch(val);
					bool num2 = _selSwatch == i;
					bool flag = RecolourHandler.ToHex(val) == "#FFFFFFFF";
					GUI.contentColor = (num2 ? GUIHelper.ColAccent : (flag ? GUIHelper.ColWarn : GUIHelper.ColText));
					if (GUILayout.Button($"{RecolourHandler.ToHex(val)}   ×{num}", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
					{
						SelectSwatch(i, name);
					}
					GUI.contentColor = GUIHelper.ColFaint;
					GUILayout.Label(flag ? Loc.T("untinted default — matches most of the scene") : text, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
					if (TryRootRule(val, out var newC))
					{
						GUI.contentColor = GUIHelper.ColConfirm;
						GUILayout.Label("→ " + RecolourHandler.ToHex(newC), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
						DrawSwatch(newC);
					}
					GUI.contentColor = Color.white;
					GUILayout.EndHorizontal();
				}
				GUILayout.EndScrollView();
				GUIHelper.Space(4f);
			}
			bool flag2 = _selSwatch == -2;
			bool flag3 = _selSwatch <= -3 && _selSwatch >= -5;
			string key = (flag3 ? SlashKeyFor(_selSwatch) : null);
			if (flag2 || flag3 || (_selSwatch >= 0 && _selSwatch < _palette.Count && _paletteScene == name))
			{
				Color val2 = (flag2 ? RecolourHandler.CurrentAmbientVanilla : (flag3 ? SlashColourHandler.VanillaFor(key) : _palette[_selSwatch].c));
				if (!flag2 && !flag3)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUI.contentColor = GUIHelper.ColMuted;
					GUILayout.Label(Loc.T("Scope:"), MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.ExpandWidth(false),
						GUIHelper.Height(22f)
					});
					GUI.contentColor = Color.white;
					if (GUILayout.Toggle(!_globalSel, Loc.T("Scene@scope", "Scene"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUIHelper.Width(90f),
						GUIHelper.Height(22f)
					}) && _globalSel)
					{
						_globalSel = false;
						RecolourHandler.ClearPreview();
					}
					if (GUILayout.Toggle(_globalSel, Loc.T("Global@scope", "Global"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUIHelper.Width(90f),
						GUIHelper.Height(22f)
					}) && !_globalSel)
					{
						_globalSel = true;
						RecolourHandler.ClearPreview();
					}
					GUI.contentColor = GUIHelper.ColFaint;
					GUILayout.Label(_globalSel ? RecolourHandler.GlobalFile : "", MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.ExpandWidth(true),
						GUIHelper.Height(22f)
					});
					GUI.contentColor = Color.white;
					GUILayout.EndHorizontal();
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				DrawSwatch(val2, 34f, 18f, 24f);
				GUILayout.Label("→", MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Width(20f),
					GUIHelper.Height(24f)
				});
				DrawSwatch(_customC, 34f, 18f, 24f);
				GUILayout.Space(GUIHelper.Scaled(12f));
				string text2 = GUIHelper.TextField("Stitchwork.Recolour.Hex", _customHex, GUIHelper.Width(110f), GUIHelper.Height(24f));
				if (!string.Equals(text2, _customHex, StringComparison.Ordinal))
				{
					_customHex = text2;
					if (RecolourHandler.TryParseHex(text2, out var c))
					{
						SetCustom(c, syncHex: false);
					}
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				Color customC = _customC;
				float num3 = DrawChannel(0, "R", customC.r);
				float num4 = DrawChannel(1, "G", customC.g);
				float num5 = DrawChannel(2, "B", customC.b);
				float num6;
				if (flag2)
				{
					GUI.enabled = false;
					DrawChannel(3, "A", customC.a);
					GUI.enabled = true;
					num6 = customC.a;
				}
				else
				{
					num6 = DrawChannel(3, "A", customC.a);
				}
				Color val3 = default(Color);
				((Color)(ref val3))..ctor(num3, num4, num5, num6);
				if (customC == _customC && val3 != customC)
				{
					SetCustom(val3, syncHex: true);
				}
				if (_previewDirty && Time.realtimeSinceStartup - _lastPreviewApply > 0.15f)
				{
					_previewDirty = false;
					_lastPreviewApply = Time.realtimeSinceStartup;
					if (flag2)
					{
						RecolourHandler.SetAmbientPreview(_customC);
					}
					else if (flag3)
					{
						SlashColourHandler.SetPreview(key, _customC);
					}
					else if (_globalSel)
					{
						RecolourHandler.SetGlobalPreview(val2, _customC);
					}
					else
					{
						RecolourHandler.SetPreview(val2, _customC);
					}
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (GUILayout.Button(Loc.T("Write rule"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
				{
					if (flag2)
					{
						RecolourHandler.WriteAmbientRule(name, _customC);
					}
					else if (flag3)
					{
						SlashColourHandler.WriteRule(key, _customC);
					}
					else if (_globalSel)
					{
						RecolourHandler.WriteGlobalRule(val2, _customC);
					}
					else
					{
						RecolourHandler.WriteRule(name, val2, _customC);
					}
					RefreshRootRules(name);
				}
				if (GUILayout.Button(Loc.T("Revert preview"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
				{
					bool globalSel = _globalSel;
					ClearColourPreviews();
					if (flag2)
					{
						SelectAmbient();
					}
					else if (flag3)
					{
						SelectSlash(_selSwatch);
					}
					else
					{
						SelectSwatch(_selSwatch, name);
						_globalSel = globalSel;
					}
				}
				GUI.enabled = (flag2 ? _rootAmbient.HasValue : (flag3 ? SlashRootRuleCached(key).HasValue : (_globalSel ? RecolourHandler.TryGetGlobalRule(val2, out var newC2) : TryRootRule(val2, out newC2))));
				if (GUILayout.Button(Loc.T("Remove rule"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
				{
					bool globalSel2 = _globalSel;
					if (flag2)
					{
						RecolourHandler.RemoveAmbientRule(name);
					}
					else if (flag3)
					{
						SlashColourHandler.RemoveRule(key);
					}
					else if (_globalSel)
					{
						RecolourHandler.RemoveGlobalRule(val2);
					}
					else
					{
						RecolourHandler.RemoveRule(name, val2);
					}
					RefreshRootRules(name);
					if (flag2)
					{
						SelectAmbient();
					}
					else if (flag3)
					{
						SelectSlash(_selSwatch);
					}
					else
					{
						SelectSwatch(_selSwatch, name);
						_globalSel = globalSel2;
					}
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
			}
			else if (_paletteScene == name && _palette.Count > 0)
			{
				GUI.contentColor = GUIHelper.ColFaint;
				GUILayout.Label(Loc.T("Pick a color from the scan to edit it."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			StitchworkConfig config = Plugin.Config;
			if (config != null && config.DevMode)
			{
				GUIHelper.Space(8f);
				if (GUILayout.Button((_showDiagnostics ? "▼ " : "▶ ") + "Diagnostics (DevMode)", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
				{
					_showDiagnostics = !_showDiagnostics;
				}
				if (_showDiagnostics)
				{
					DrawDiagnostics();
				}
			}
		}

		private static void SelectSwatch(int i, string scene)
		{
			//IL_002e: 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)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (i >= 0 && i < _palette.Count)
			{
				ClearColourPreviews();
				_selSwatch = i;
				_globalSel = false;
				Color item = _palette[i].c;
				_customC = (TryRootRule(item, out var newC) ? newC : item);
				_customHex = RecolourHandler.ToHex(_customC);
				SyncChannelBufs();
				_previewDirty = false;
			}
		}

		private static void SetCustom(Color c, bool syncHex, int typingChannel = -1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			_customC = c;
			if (syncHex)
			{
				_customHex = RecolourHandler.ToHex(c);
			}
			SyncChannelBufs(typingChannel);
			_previewDirty = true;
		}

		private static void SyncChannelBufs(int except = -1)
		{
			if (except != 0)
			{
				_chanBuf[0] = Mathf.RoundToInt(_customC.r * 255f).ToString();
			}
			if (except != 1)
			{
				_chanBuf[1] = Mathf.RoundToInt(_customC.g * 255f).ToString();
			}
			if (except != 2)
			{
				_chanBuf[2] = Mathf.RoundToInt(_customC.b * 255f).ToString();
			}
			if (except != 3)
			{
				_chanBuf[3] = Mathf.RoundToInt(_customC.a * 255f).ToString();
			}
		}

		private static bool TryRootRule(Color oldC, out Color newC)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			foreach (var (a, val) in _rootRules)
			{
				if (RecolourHandler.Match(a, oldC, 0.002f))
				{
					newC = val;
					return true;
				}
			}
			newC = default(Color);
			return false;
		}

		private static void ClearColourPreviews()
		{
			RecolourHandler.ClearPreview();
			SlashColourHandler.ClearPreview();
		}

		private static void SelectAmbient()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			ClearColourPreviews();
			_selSwatch = -2;
			_customC = (Color)(((??)_rootAmbient) ?? RecolourHandler.CurrentAmbientVanilla);
			_customC.a = 1f;
			_customHex = RecolourHandler.ToHex(_customC);
			SyncChannelBufs();
			_previewDirty = false;
		}

		private static string SlashKeyFor(int sel)
		{
			return sel switch
			{
				-4 => "fire", 
				-3 => "base", 
				_ => "poison", 
			};
		}

		private static Color? SlashRootRuleCached(string key)
		{
			if (!(key == "base"))
			{
				if (!(key == "fire"))
				{
					return _rootSlashPoison;
				}
				return _rootSlashFire;
			}
			return _rootSlashBase;
		}

		private static void DrawSlashChip(int sel, string key, string label)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			Color backgroundColor = GUI.backgroundColor;
			if (_selSwatch == sel)
			{
				GUI.backgroundColor = GUIHelper.ColAccentSoft;
			}
			if (GUILayout.Button(label, GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(80f),
				GUIHelper.Height(22f)
			}))
			{
				SelectSlash(sel);
			}
			GUI.backgroundColor = backgroundColor;
			Color? val = SlashRootRuleCached(key);
			if (val.HasValue)
			{
				GUI.contentColor = GUIHelper.ColConfirm;
				GUILayout.Label("→", MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.ExpandWidth(false),
					GUIHelper.Height(22f)
				});
				GUI.contentColor = Color.white;
				DrawSwatch(val.Value, 26f, 14f, 22f);
			}
		}

		private static void SelectSlash(int sel)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			ClearColourPreviews();
			_selSwatch = sel;
			string key = SlashKeyFor(sel);
			_customC = (Color)(((??)SlashRootRuleCached(key)) ?? SlashColourHandler.VanillaFor(key));
			_customHex = RecolourHandler.ToHex(_customC);
			SyncChannelBufs();
			_previewDirty = false;
		}

		private static void RefreshRootRules(string scene)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			_rootRulesScene = scene;
			_rootRules.Clear();
			_rootRules.AddRange(RecolourHandler.GetRootRules(scene));
			_rootAmbient = (RecolourHandler.TryGetRootAmbient(scene, out var c) ? new Color?(c) : ((Color?)null));
			_rootSlashBase = (SlashColourHandler.TryGetRootRule("base", out var c2) ? new Color?(c2) : ((Color?)null));
			_rootSlashFire = (SlashColourHandler.TryGetRootRule("fire", out var c3) ? new Color?(c3) : ((Color?)null));
			_rootSlashPoison = (SlashColourHandler.TryGetRootRule("poison", out var c4) ? new Color?(c4) : ((Color?)null));
		}

		private static void ScanPalette(string scene)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			ClearColourPreviews();
			_paletteScene = scene;
			_palette.Clear();
			_selSwatch = -1;
			_pickStatus = "";
			RefreshRootRules(scene);
			SpriteRenderer[] array = Object.FindObjectsByType<SpriteRenderer>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (SpriteRenderer val in array)
			{
				if ((Object)(object)val == (Object)null || !RecolourHandler.SceneOwned(((Component)val).gameObject))
				{
					continue;
				}
				Color vanilla;
				Color val2 = (RecolourHandler.TryGetVanilla(((Object)val).GetInstanceID(), out vanilla) ? vanilla : val.color);
				if (val2.a <= 0.02f)
				{
					continue;
				}
				int num = -1;
				for (int j = 0; j < _palette.Count; j++)
				{
					if (RecolourHandler.Match(val2, _palette[j].c, 0.05f))
					{
						num = j;
						break;
					}
				}
				if (num >= 0)
				{
					_palette[num] = (_palette[num].c, _palette[num].count + 1, _palette[num].example);
				}
				else
				{
					_palette.Add((val2, 1, ((Object)val).name));
				}
			}
			_palette.Sort(((Color c, int count, string example) a, (Color c, int count, string example) b) => b.count.CompareTo(a.count));
			if (_palette.Count > 64)
			{
				_palette.RemoveRange(64, _palette.Count - 64);
			}
			for (int num2 = 0; num2 < _palette.Count; num2++)
			{
				foreach (var rootRule in _rootRules)
				{
					Color item = rootRule.oldC;
					if (RecolourHandler.Match(item, _palette[num2].c, 0.05f))
					{
						_palette[num2] = (item, _palette[num2].count, _palette[num2].example);
						break;
					}
				}
			}
		}

		private static void DrawSwatch(Color c, float w = 26f, float h = 14f, float rowH = 0f)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(h, rowH);
			Rect rect = GUILayoutUtility.GetRect(GUIHelper.Scaled(w), GUIHelper.Scaled(num), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			if (num > h)
			{
				float num2 = (((Rect)(ref rect)).height - GUIHelper.Scaled(h)) * 0.5f;
				((Rect)(ref rect))..ctor(((Rect)(ref rect)).x, ((Rect)(ref rect)).y + num2, ((Rect)(ref rect)).width, GUIHelper.Scaled(h));
			}
			GUI.color = c;
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = Color.white;
			GUIHelper.DrawBorder(rect, GUIHelper.ColBorderHi);
		}

		private static float DrawChannel(int idx, string label, float v)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, MidLabel, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(16f),
				GUIHelper.Height(24f)
			});
			float result = GUILayout.HorizontalSlider(v * 255f, 0f, 255f, GUIHelper.SliderTrackStyle, GUIHelper.SliderThumbStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }) / 255f;
			string text = GUIHelper.TextField($"Stitchwork.Recolour.Ch{idx}", _chanBuf[idx], GUIHelper.Width(46f), GUIHelper.Height(22f));
			if (!string.Equals(text, _chanBuf[idx], StringComparison.Ordinal))
			{
				_chanBuf[idx] = text;
				if (int.TryParse(text, out var result2))
				{
					float num = (float)Mathf.Clamp(result2, 0, 255) / 255f;
					Color customC = _customC;
					switch (idx)
					{
					case 0:
						customC.r = num;
						break;
					case 1:
						customC.g = num;
						break;
					case 2:
						customC.b = num;
						break;
					default:
						customC.a = num;
						break;
					}
					SetCustom(customC, syncHex: true, idx);
				}
			}
			GUILayout.EndHorizontal();
			return result;
		}

		private static void DrawDiagnostics()
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			if (GUILayout.Button("Dump imbuement tint colors", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
			{
				NailImbuementConfig[] array = Resources.FindObjectsOfTypeAll<NailImbuementConfig>();
				string text = Path.Combine(Plugin.BasePath, "Recolour", "_imbuement-tints.txt");
				IOUtil.EnsureDirectoryExists(Path.GetDirectoryName(text));
				List<string> list = new List<string> { "# Imbuement tint colors (dumped from live NailImbuementConfig assets).", "# Use the NailTintColor hex as a global rule's OLD color in _global.txt." };
				NailImbuementConfig[] array2 = array;
				foreach (NailImbuementConfig val in array2)
				{
					if ((Object)(object)val != (Object)null)
					{
						list.Add(((Object)val).name + ": NailTintColor " + RecolourHandler.ToHex(val.NailTintColor) + "  ExtraHeroLightColor " + RecolourHandler.ToHex(val.ExtraHeroLightColor));
					}
				}
				if (array.Length == 0)
				{
					list.Add("# none loaded yet — use an imbuement tool (Flintslate) once, then dump again.");
				}
				File.WriteAllLines(IOUtil.LongSafe(text), list);
				_imbuementDumpStatus = $"{array.Length} config(s) → {text}";
				Plugin.Logger.LogInfo((object)("[Recolour] Imbuement tint dump: " + _imbuementDumpStatus));
			}
			if (!string.IsNullOrEmpty(_imbuementDumpStatus))
			{
				GUI.contentColor = GUIHelper.ColFaint;
				GUILayout.Label(_imbuementDumpStatus, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUIHelper.Space(8f);
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label("Material Tint Diagnostic", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(2f);
			GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
			GUILayout.Label("One-shot dump of every tk2d material's shader properties + scene-level\nlighting / RenderSettings / shader-globals state. Writes to:\n  " + MaterialDumper.DefaultOutputPath + "\nRun once per scene of interest. Cross-reference\ndocs/material-tint-investigation.md for what to look for.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(6f);
			if (GUILayout.Button("Dump materials & scene state", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(26f) }))
			{
				MaterialDumper.DumpAll();
			}
			if (!string.IsNullOrEmpty(MaterialDumper.LastStatus))
			{
				GUIHelper.Space(2f);
				GUI.contentColor = (MaterialDumper.LastStatus.StartsWith("FAILED", StringComparison.Ordinal) ? new Color(1f, 0.4f, 0.4f) : new Color(0.4f, 1f, 0.4f));
				GUILayout.Label("Dump status: " + MaterialDumper.LastStatus, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUIHelper.Space(12f);
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label("Global Ambient Probe — diagnostic", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(2f);
			GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
			GUILayout.Label("Forces RenderSettings.ambientLight + Sky/Equator/Ground colours to\nwhite AND publishes unity_AmbientSky / Equator / Ground as neutral\nshader globals. WHOLE-SCENE side effect — every sprite renders\nwithout scene-ambient influence while active. Visually jarring;\nuse only as a binary test for the ambient hypothesis.\n  • cast disappears on Hornet → ambient pipeline IS the source\n    (production: per-pack-scoped Shader.SetGlobalColor with\n    restoration on scene unload)\n  • cast persists → ambient isn't the source; investigate\n    shader keywords / post-process volume next.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(6f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (!GlobalAmbientProbe.IsOverridden)
			{
				GUI.contentColor = GUIHelper.ColWarn;
				if (GUILayout.Button("Zero global ambient", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
				{
					GlobalAmbientProbe.ZeroAll();
				}
				GUI.contentColor = Color.white;
				GUILayout.Label("(not active)", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(80f) });
			}
			else
			{
				GUI.contentColor = new Color(1f, 0.55f, 0.4f);
				GUILayout.Label("ACTIVE — scene ambient is zeroed", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
				if (GUILayout.Button("Restore", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(24f),
					GUIHelper.Width(120f)
				}))
				{
					GlobalAmbientProbe.Restore();
				}
			}
			GUILayout.EndHorizontal();
			if (!string.IsNullOrEmpty(GlobalAmbientProbe.LastStatus))
			{
				GUIHelper.Space(2f);
				GUI.contentColor = new Color(0.4f, 1f, 0.4f);
				GUILayout.Label("Probe status: " + GlobalAmbientProbe.LastStatus, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
		}

		private static void DrawT2DLog()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			int maxVisible = 20;
			double fadeDuration = 8.0;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label($"T2D Trigger Log  ({T2DLog.EntryCount} entries)", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.contentColor = Color.white;
			if (GUILayout.Button(Loc.T("Clear"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(50f),
				GUIHelper.Height(22f)
			}))
			{
				T2DLog.ClearLog();
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
			GUILayout.Label(Loc.T("Click an entry to jump to it in T2D Textures."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(4f);
			_logScroll = GUILayout.BeginScrollView(_logScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			T2DLog.DrawEntries(maxVisible, fadeDuration, delegate(string rawTex, string spriteName)
			{
				T2DTextureController.SelectEntry(rawTex, spriteName);
				SwitchToT2DBrowser();
			});
			GUILayout.EndScrollView();
		}
	}
	public static class TextPillar
	{
		private static Vector2 _recentScroll;

		private static string _searchFilter = "";

		private static string _jumpSheet = "";

		private static string _jumpKey = "";

		private const float TopRowHeight = 250f;

		public static void Draw()
		{
			//IL_0072: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			int maxVisible = Mathf.Clamp(Plugin.Config.TextLogMaxVisible, 5, 50);
			double textLogDuration = Plugin.Config.TextLogDuration;
			GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(GUIHelper.Scaled(250f)) });
			GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(string.Format(Loc.T("Recent  ({0})"), TextLog.EntryCount), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			GUI.contentColor = Color.white;
			_searchFilter = GUIHelper.TextField("TextPillar.Search", _searchFilter, GUILayout.ExpandWidth(true));
			GUILayout.EndHorizontal();
			GUIHelper.Space(2f);
			_recentScroll = GUILayout.BeginScrollView(_recentScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			if (string.IsNullOrEmpty(_searchFilter))
			{
				TextLog.DrawEntries(maxVisible, textLogDuration, delegate(string sheet, string key, string text)
				{
					DialogueEditor.SelectEntry(sheet, key, text);
				});
			}
			else
			{
				DrawSearchResults(_searchFilter);
			}
			GUILayout.EndScrollView();
			if (GUILayout.Button(Loc.T("Clear Log"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(22f) }))
			{
				TextLog.ClearLog();
			}
			GUILayout.EndVertical();
			GUIHelper.Space(6f);
			GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(Loc.T("Flags"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			FlagEditorPanel.DrawSurface();
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			TextMergePanel.DrawBar();
			GUIHelper.Space(4f);
			GUILayout.BeginVertical(GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			if (TextMergePanel.ReviewActive)
			{
				TextMergePanel.DrawReview();
				GUILayout.EndVertical();
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(Loc.T("Editor"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(54f) });
			GUI.contentColor = Color.white;
			GUILayout.Label(Loc.T("Sheet:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(42f) });
			_jumpSheet = GUIHelper.TextField("TextPillar.JumpSheet", _jumpSheet, GUIHelper.Width(110f));
			GUILayout.Label(Loc.T("Key:"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(32f) });
			_jumpKey = GUIHelper.TextField("TextPillar.JumpKey", _jumpKey, GUILayout.ExpandWidth(true));
			GUI.enabled = !string.IsNullOrWhiteSpace(_jumpSheet) && !string.IsNullOrWhiteSpace(_jumpKey);
			if (GUILayout.Button(Loc.T("Open"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(50f),
				GUIHelper.Height(22f)
			}))
			{
				DialogueEditor.SelectEntry(_jumpSheet.Trim(), _jumpKey.Trim());
				_jumpSheet = "";
				_jumpKey = "";
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUIHelper.Space(2f);
			DialogueEditor.DrawEditorSurface();
			GUILayout.EndVertical();
		}

		private static void DrawSearchResults(string filter)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> hashSet = new HashSet<string>();
			bool flag = false;
			TextLog.DrawFilteredEntries(filter, delegate(string sheet, string key, string currentText)
			{
				DialogueEditor.SelectEntry(sheet, key, currentText);
			}, hashSet, suppressEmpty: true);
			flag = hashSet.Count > 0;
			foreach (var item4 in DialogueHandler.SearchCache(filter, hashSet))
			{
				string item = item4.Sheet;
				string item2 = item4.Key;
				string item3 = item4.Value;
				string text = item3.Replace("\n", "\\n").Replace("\r", "\\r");
				if (text.Length > 45)
				{
					text = text.Substring(0, 42) + "...";
				}
				GUI.contentColor = new Color(0.8f, 0.9f, 1f);
				if (GUILayout.Button(item + "." + item2 + ": " + text, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>()))
				{
					DialogueEditor.SelectEntry(item, item2, item3);
				}
				GUI.contentColor = Color.white;
				flag = true;
			}
			if (!flag)
			{
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label(Loc.T("No matches in log or loaded overrides."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
		}
	}
	public static class VideoPillar
	{
		private sealed class CinematicEntry
		{
			public string Name;

			public bool Replaced;

			public DateTime Time;
		}

		private static Vector2 _catalogScroll;

		private static Vector2 _logScroll;

		private static float _lastScanTime = -999f;

		private const float ScanCooldown = 2f;

		private static readonly List<CinematicEntry> _log = new List<CinematicEntry>();

		public static void LogCinematic(string name, bool replaced)
		{
			CinematicEntry cinematicEntry = _log.Find((CinematicEntry e) => string.Equals(e.Name, name, StringComparison.OrdinalIgnoreCase));
			if (cinematicEntry != null)
			{
				_log.Remove(cinematicEntry);
			}
			_log.Insert(0, new CinematicEntry
			{
				Name = name,
				Replaced = replaced,
				Time = DateTime.Now
			});
		}

		public static void Draw()
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			if (Time.realtimeSinceStartup - _lastScanTime >= 2f)
			{
				_lastScanTime = Time.realtimeSinceStartup;
				VideoHandler.Reload();
			}
			SortedSet<string> sortedSet = (GameBridge.IsHK1 ? new SortedSet<string>(StringComparer.OrdinalIgnoreCase) : new SortedSet<string>(VideoHandler.KnownCinematics, StringComparer.OrdinalIgnoreCase));
			foreach (CinematicEntry item in _log)
			{
				sortedSet.Add(item.Name);
			}
			foreach (KeyValuePair<string, string> item2 in VideoHandler.VideoFileMap)
			{
				if (item2.Value != null)
				{
					sortedSet.Add(item2.Key);
				}
			}
			int num = 0;
			foreach (string item3 in sortedSet)
			{
				if (HasReplacement(item3))
				{
					num++;
				}
			}
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(string.Format(Loc.T("{0} cinematics  ·  {1} replaceable on disk"), sortedSet.Count, num), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			if (GameBridge.IsHK1)
			{
				GUI.contentColor = GUIHelper.ColMuted;
				GUILayout.Label(Loc.T("No baked catalog for this game — cinematics appear here as they play."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			GUIHelper.Space(6f);
			_catalogScroll = GUILayout.BeginScrollView(_catalogScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxHeight(GUIHelper.Scaled(220f)) });
			foreach (string name in sortedSet)
			{
				bool flag = HasReplacement(name);
				bool flag2 = _log.Exists((CinematicEntry e) => string.Equals(e.Name, name, StringComparison.OrdinalIgnoreCase));
				GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(20f) });
				if (GUILayout.Button(GUIHelper.TT(name, "Click to copy name"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
				{
					GUIUtility.systemCopyBuffer = name;
				}
				if (flag)
				{
					GUI.contentColor = new Color(0.4f, 1f, 0.4f);
					GUILayout.Label("● " + Loc.T("replaced"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(86f) });
				}
				else if (flag2)
				{
					GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
					GUILayout.Label(Loc.T("played"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(86f) });
				}
				else
				{
					GUI.contentColor = new Color(0.45f, 0.45f, 0.45f);
					GUILayout.Label(Loc.T("available"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(86f) });
				}
				GUI.contentColor = Color.white;
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
			GUIHelper.Space(8f);
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.contentColor = new Color(0.6f, 0.85f, 1f);
			GUILayout.Label(Loc.T("Live Cinematic Log"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUI.contentColor = Color.white;
			if (GUILayout.Button(Loc.T("Clear"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(50f),
				GUIHelper.Height(20f)
			}))
			{
				_log.Clear();
			}
			GUILayout.EndHorizontal();
			_logScroll = GUILayout.BeginScrollView(_logScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(true) });
			if (_log.Count == 0)
			{
				GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
				GUILayout.Label(Loc.T("No cinematics triggered this session."), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
				GUI.contentColor = Color.white;
			}
			else
			{
				foreach (CinematicEntry item4 in _log)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					if (GUILayout.Button(GUIHelper.TT(item4.Name, "Click to copy name"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
					{
						GUIUtility.systemCopyBuffer = item4.Name;
					}
					if (item4.Replaced)
					{
						GUI.contentColor = new Color(0.4f, 1f, 0.4f);
						GUILayout.Label("[R]", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(28f) });
					}
					else
					{
						GUILayout.Space(GUIHelper.Scaled(28f));
					}
					GUI.contentColor = new Color(0.45f, 0.45f, 0.45f);
					GUILayout.Label(item4.Time.ToString("HH:mm:ss"), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(56f) });
					GUI.contentColor = Color.white;
					GUILayout.EndHorizontal();
				}
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
			static bool HasReplacement(string key)
			{
				if (VideoHandler.VideoFileMap.TryGetValue(key, out var value))
				{
					return value != null;
				}
				return false;
			}
		}
	}
}