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 TeamCherry.Cinematics;
using TeamCherry.Localization;
using Unity.Mathematics;
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.UI;
using UnityEngine.Video;

[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.0.0")]
[assembly: AssemblyInformationalVersion("0.8.0+0475ee1ae4a7529149d6d3ad4b00f66006b5e890")]
[assembly: AssemblyProduct("Stitchwork")]
[assembly: AssemblyTitle("Stitchwork")]
[assembly: AssemblyMetadata("GameLibsPin", "1.2.0-silksong1.0.30000")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.8.0.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 PerClip;
	}

	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 readonly Dictionary<(int libId, string clip), ClipCoverage> _coverage = new Dictionary<(int, string), ClipCoverage>();

	private static int _coverageIndexVersion = -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 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)
	{
		tk2dSpriteAnimator val = e?.Live;
		if ((Object)(object)val != (Object)null && val.CurrentClip == clip && val.ClipFps > 0f)
		{
			return val.ClipFps;
		}
		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;
	}

	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_00e5: 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_0104: 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_021a: 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_01fb: 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)
		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 = 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_0096: 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_00e5: 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)
		//IL_017d: 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_029d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_030b: Unknown result type (might be due to invalid IL or missing references)
		//IL_031f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0324: 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_0378: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f1: 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;
		}
		IEnumerable<tk2dSpriteAnimationClip> source = library.clips.Where((tk2dSpriteAnimationClip c) => c != null && !string.IsNullOrEmpty(c.name));
		if (!string.IsNullOrEmpty(_clipSearch))
		{
			source = source.Where((tk2dSpriteAnimationClip c) => c.name.ToLower().Contains(_clipSearch.ToLower()));
		}
		if (_lensSpriteId >= 0)
		{
			source = source.Where((tk2dSpriteAnimationClip c) => ClipUsesSprite(c, _lensColl, _lensSpriteId));
		}
		List<tk2dSpriteAnimationClip> list = source.OrderBy<tk2dSpriteAnimationClip, string>((tk2dSpriteAnimationClip c) => c.name, StringComparer.OrdinalIgnoreCase).ToList();
		GUI.contentColor = GUIHelper.ColFaint;
		GUILayout.Label($"{list.Count} / {library.clips.Length}", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
		GUI.contentColor = Color.white;
		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 val = FindClip(library, recentClip);
				if (val != null)
				{
					DrawClipRow(e, library, val, currentClip, live);
				}
			}
			GUI.contentColor = GUIHelper.ColMuted;
			GUILayout.Label(Loc.T("All clips"), GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
		}
		foreach (tk2dSpriteAnimationClip item in list)
		{
			DrawClipRow(e, library, item, currentClip, live);
		}
		GUILayout.EndScrollView();
	}

	private static void DrawClipRow(AnimEntry e, tk2dSpriteAnimation lib, tk2dSpriteAnimationClip clip, string currentClip, bool live)
	{
		//IL_0022: 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_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Expected O, but got Unknown
		//IL_009a: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Expected O, but got Unknown
		//IL_0102: 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_011a: 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_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		ClipCoverage coverage = GetCoverage(lib, clip);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUI.contentColor = ((coverage.Shared > 0) ? GUIHelper.ColConfirm : GUIHelper.ColBorderHi);
		GUILayout.Label(new GUIContent(DotFor(coverage.Shared, coverage.Frames), string.Format("{0}: {1}/{2}", Loc.T("shared replacements"), coverage.Shared, coverage.Frames)), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(16f) });
		GUI.contentColor = ((coverage.PerClip > 0) ? GUIHelper.ColAccent : GUIHelper.ColBorderHi);
		GUILayout.Label(new GUIContent(DotFor(coverage.PerClip, coverage.Frames), string.Format("{0}: {1}/{2}", Loc.T("per-clip (Appliqué)"), coverage.PerClip, coverage.Frames)), GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(16f) });
		GUI.contentColor = Color.white;
		GUI.contentColor = ((clip.name == currentClip) ? 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;
		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 string DotFor(int n, int total)
	{
		if (n > 0)
		{
			if (n < total)
			{
				return "◐";
			}
			return "●";
		}
		return "○";
	}

	private static ClipCoverage GetCoverage(tk2dSpriteAnimation lib, tk2dSpriteAnimationClip clip)
	{
		if (_coverageIndexVersion != SpriteLoader.FileIndexVersion)
		{
			_coverage.Clear();
			_coverageIndexVersion = SpriteLoader.FileIndexVersion;
		}
		(int, string) key = (((Object)lib).GetInstanceID(), clip.name);
		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++;
					if (SpriteLoader.HasSpriteReplacement(spriteCollection, val2))
					{
						value.Shared++;
					}
					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_00ca: 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_020d: 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_0214: 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_02d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f4: 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_0321: Unknown result type (might be due to invalid IL or missing references)
		//IL_0323: Unknown result type (might be due to invalid IL or missing references)
		//IL_032f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0335: Invalid comparison between Unknown and I4
		//IL_022d: 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_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_056c: 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_05d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b4: 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_03bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0356: Unknown result type (might be due to invalid IL or missing references)
		//IL_0366: 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_036d: Unknown result type (might be due to invalid IL or missing references)
		//IL_066d: Unknown result type (might be due to invalid IL or missing references)
		//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0509: Unknown result type (might be due to invalid IL or missing references)
		//IL_052c: 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_0562: Unknown result type (might be due to invalid IL or missing references)
		//IL_0717: Unknown result type (might be due to invalid IL or missing references)
		//IL_0742: Unknown result type (might be due to invalid IL or missing references)
		//IL_0761: 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_0794: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_080b: Unknown result type (might be due to invalid IL or missing references)
		//IL_084c: 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 = 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, Array.Empty<GUILayoutOption>());
		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 = def.materialInst ?? def.material;
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		string text = ((Object)val).name.Split(' ')[0];
		string text2 = 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);
		}
		Process.Start(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_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Invalid comparison between Unknown and I4
		//IL_0236: 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_02a4: 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_02d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_032d: 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_033c: Expected O, but got Unknown
		//IL_034e: Unknown result type (might be due to invalid IL or missing references)
		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, (RenderTextureReadWrite)1);
		Texture2D val;
		try
		{
			RenderTexture.active = temporary;
			GL.Clear(true, true, Color.clear);
			GL.PushMatrix();
			GL.LoadPixelMatrix(0f, (float)num8, 0f, (float)num9);
			TexUtil.RotateMaterial.SetVector("_Basis", new Vector4(1f, 0f, 0f, 1f));
			TexUtil.RotateMaterial.SetTexture("_MainTex", atlas);
			TexUtil.RotateMaterial.SetPass(0);
			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_008c: 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_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Invalid comparison between Unknown and I4
		//IL_01f7: 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_022f: 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_0264: 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_03b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0495: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e6: 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_0541: Invalid comparison between Unknown and I4
		//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_08a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_08d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_09ae: 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_08f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0928: Unknown result type (might be due to invalid IL or missing references)
		//IL_097e: Unknown result type (might be due to invalid IL or missing references)
		//IL_09a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a19: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a3d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0de5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0dea: 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 = 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(Array.Empty<GUILayoutOption>());
		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 + 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>());
		if (GUILayout.Button(Loc.T("Edit Current Sprite"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			OpenSpriteForEdit(coll, val);
		}
		GUI.enabled = clip != null;
		if (GUILayout.Button(Loc.T("Detach for This Clip"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			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))
				{
					Process.Start(text8);
				}
			}
		}
		GUI.enabled = 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.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;
		if (GUILayout.Button(Loc.T("Ready All for Edit"), GUIHelper.ButtonStyle, Array.Empty<GUILayoutOption>()))
		{
			int num2 = 0;
			for (int num3 = 0; num3 < clip.frames.Length; num3++)
			{
				tk2dSpriteAnimationFrame val3 = clip.frames[num3];
				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)(val4.materialInst ?? val4.material)).name.Split(' ')[0];
				string text13 = Path.Combine(SpriteLoader.LoadPath, ((Object)spriteCollection).name, text12, val4.name + ".png");
				if (File.Exists(text13))
				{
					num2++;
					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);
					num2++;
				}
			}
			Plugin.Logger.LogInfo((object)$"[AnimCtrl] Copied {num2} sprites from '{clip.name}' ({clip.frames.Length} frames) to {SpriteLoader.LoadPath}");
			for (int num4 = 0; num4 < clip.frames.Length; num4++)
			{
				tk2dSpriteAnimationFrame val5 = clip.frames[num4];
				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)(val6.materialInst ?? val6.material)).name.Split(' ')[0];
					string text15 = Path.Combine(SpriteLoader.LoadPath, ((Object)spriteCollection2).name, path2, val6.name + ".png");
					if (File.Exists(text15))
					{
						Process.Start(text15);
					}
				}
			}
			_anchorCacheKey = null;
		}
		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))
			{
				Process.Start(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))
			{
				Process.Start(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 backgroundColor = 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 = backgroundColor;
		GUILayout.EndHorizontal();
		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 static string _cachedLangString;

	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;

	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_0009: 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)
		return _cachedLangString ?? (_cachedLangString = ((object)Language.CurrentLanguage()/*cast due to .constrained prefix*/).ToString());
	}

	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.ContainsKey(lang) && TextCache[lang].ContainsKey(sheet))
		{
			Plugin.Logger.LogDebug((object)("Invalidating text cache for sheet: " + sheet + ", lang: " + lang));
			TextCache[lang].Remove(sheet);
		}
	}

	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()
	{
		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()
	{
		_cachedLangString = null;
		Loc.OnGameLanguageChanged();
	}

	private static void GetTextPostfix(string key, string sheetTitle, ref string __result)
	{
		if (_dumpInProgress)
		{
			return;
		}
		long heapBefore = DevProfiler.SnapshotHeapBytes();
		try
		{
			string text = CurrentLangStringCached();
			if (!TextCache.TryGetValue(text, out var value))
			{
				value = new Dictionary<string, Dictionary<string, string>>();
				TextCache[text] = value;
			}
			if (!value.TryGetValue(sheetTitle, out var value2))
			{
				value2 = (value[sheetTitle] = LoadTextSheet(sheetTitle, text));
			}
			if (value2.TryGetValue(key, out var value3))
			{
				__result = value3;
				RequestedOverrideKeys.Add(text + "|" + sheetTitle + "|" + key);
			}
			DialogueHandler.OnTextAccessed?.Invoke(sheetTitle, key, __result);
		}
		finally
		{
			DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Language.Get", heapBefore);
		}
	}

	private static Dictionary<string, string> LoadTextSheet(string sheetTitle, string lang)
	{
		Dictionary<string, string> dictionary = 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;
				}
			}
		}
		foreach (KeyValuePair<string, string> item2 in LoadTextSheet(sheetTitle, lang, TextLoadPath))
		{
			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;
		foreach (string allOverrideKey in AllOverrideKeys)
		{
			if (!RequestedOverrideKeys.Contains(allOverrideKey))
			{
				string[] array = allOverrideKey.Split('|', 3);
				string text = array[0];
				string text2 = array[1];
				string text3 = array[2];
				string text4 = CurrentLangStringCached();
				if (!(text != text4))
				{
					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;
	}
}
namespace System.Runtime.CompilerServices
{
	internal static class IsExternalInit
	{
	}
}
namespace Stitchwork
{
	[BepInPlugin("Stitchwork", "Stitchwork", "0.8.0")]
	[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;

		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 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_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: 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.0");
			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)
				{
					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."));
				}
			}
			LogInstallRoot();
			PackManager.Initialize();
			TexUtil.Initialize();
			InitializeFolders();
			AudioFileWatcher = new AudioFileWatcher();
			SpriteFileWatcher = new SpriteFileWatcher();
			TextFileWatcher = new TextFileWatcher();
			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);
			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();
			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();
			}
			AnimationController.ClearAnimators();
			DialogueHandler.CheckForStaleKeys();
			PackManager.OnSceneLoaded(((Scene)(ref scene)).name);
			T2DLoader.OnSceneLoaded();
			T2DLoader.CheckForUninitializedSprites();
		}

		private void OnSceneUnloaded(Scene scene)
		{
			T2DLoader.PruneStaleOriginals();
			T2DLoader.PruneSceneState();
			T2DLoader.ResetSceneSeed();
		}

		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();
		}

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

		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();
				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();
			}
			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();
			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();
			T2DLoader.IsT2DLogActive = false;
			AudioHandler.IsAudioBrowserActive = false;
			try
			{
				if (ShowStatusOverlay)
				{
					StatusOverlay.Draw();
				}
				DumpProgressOverlay.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 class StitchworkConfig
	{
		private readonly ConfigEntry<bool> _DumpSprites;

		private readonly ConfigEntry<bool> _ConvertSpritesheets;

		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> _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> _AutoEnableIncrementalGC;

		private readonly ConfigEntry<int> _IncrementalGCTimeSliceMs;

		private readonly ConfigEntry<bool> _EagerFocusReload;

		private readonly ConfigEntry<bool> _DevMode;

		private readonly ConfigEntry<string> _T2DDiagWatchName;

		private readonly ConfigEntry<KeyCode> _AppliqueProbeKey;

		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> _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 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 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 ?? 1024;

		public bool AutoEnableIncrementalGC => _AutoEnableIncrementalGC?.Value ?? true;

		public int IncrementalGCTimeSliceMs => _IncrementalGCTimeSliceMs?.Value ?? 0;

		public bool EagerFocusReload => _EagerFocusReload?.Value ?? false;

		public bool DevMode => _DevMode?.Value ?? false;

		public KeyCode AppliqueProbeKey => (KeyCode)(((??)_AppliqueProbeKey?.Value) ?? 0);

		public bool EnableApplique => _EnableApplique?.Value ?? true;

		public string T2DDiagWatchName => _T2DDiagWatchName?.Value ?? "";

		public bool LogT2DLookupMisses => _LogT2DLookupMisses.Value;

		public bool VerboseLogging => _VerboseLogging?.Value ?? false;

		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 ?? "auto";
			}
			set
			{
				if (_UILanguage != null)
				{
					_UILanguage.Value = value;
				}
			}
		}

		internal ConfigEntry<string> UILanguageEntry => _UILanguage;

		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_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0525: Expected O, but got Unknown
			_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");
			_DumpText = config.Bind<bool>("Dumping", "DumpText", false, "Enable dumping of text when the game starts.");
			_ConvertSpritesheets = config.Bind<bool>("Dumping", "ConvertSpritesheets", false, "Automatically convert modded spritesheets to individual Stitchwork-compatible PNGs.");
			_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.");
			_AppliqueProbeKey = config.Bind<KeyCode>("Experimental", "AppliqueProbeKey", (KeyCode)288, "EXPERIMENTAL, DevMode only. Appliqué Phase-0 probe (docs/frame-decoupling-design.md): press once in-game to divert a reused animation frame to marker art via both candidate mechanisms and log the gate results ([Applique-P0] lines); press again to revert. Inert unless DevMode is enabled.");
			_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).");
			_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.0";
	}
}
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}");
			ReloadAudio = 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);
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				string path = Path.Combine(pluginPackPath, "Text");
				if (Directory.Exists(path))
				{
					PackWatchers.Add(CreateWatcher(path));
				}
			}
		}

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

		public static bool BridgeAvailable
		{
			get
			{
				if (_fiHasPreloaded != null)
				{
					return _fiIsLoading != null;
				}
				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;
		}
	}
	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";

		public static Result LastResult { get; private set; }

		private static string BootConfigPath => Path.Combine(Application.dataPath, "boot.config");

		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 at '" + bootConfigPath + "' — cannot auto-enable incremental GC. 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 Entry(string type, string key, string winnerPack, string loserPack)
			{
				Type = type;
				Key = key;
				WinnerPack = winnerPack;
				LoserPack = loserPack;
			}
		}

		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 Record(string type, string key, string winnerPack, string loserPack)
		{
			_entries.Add(new Entry(type, key, winnerPack, loserPack));
		}

		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(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
	{
		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 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 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)
			{
				_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);
				}
				_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);
				}
				_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;
			}
			Plugin.Logger.LogWarning((object)"[GameBridge] No main-menu return handle resolved.");
			return false;
		}

		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.Message + ". 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.Message));
				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.Message));
				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.Message + ". 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.Message + ". 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.Message));
				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);
			}
		}
	}
	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()
		{
			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 (!File.Exists(Path.Combine(Plugin.BasePath, "stitchwork.assetbundle")))
			{
				list.Add(new Item("Asset bundle", Status.Warn, "stitchwork.assetbundle missing next to the DLL — canvas extract + sprite preview broken; reinstall"));
			}
			else if ((Object)(object)TexUtil.RotateMaterial == (Object)null)
			{
				list.Add(new Item("Asset bundle", Status.Warn, "file present but Rotate.shader failed to load — canvas extract + sprite preview degraded"));
			}
			else
			{
				list.Add(new Item("Asset bundle", Status.Ok, "Rotate.shader loaded"));
			}
			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[] array3 = new string[5] { "Sprites", "Spritesheets", "Sounds", "Videos", "Text" };
					foreach (string path2 in array3)
					{
						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
			{
			}
			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
	{
		public static void EnsureDirectoryExists(string path)
		{
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
			}
		}

		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 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 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();
				};
			}
		}

		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) ? (DialogueHandler.CurrentLangCode ?? "EN").ToLowerInvariant() : 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 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");
			}
			LastSummary = stringBuilder.ToString();
			logger.LogInfo((object)"[SelfTest] done.");
		}

		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_010a: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.FloorToInt(uvs.Min((Vector2 uv) => uv.x) * (float)tex.width + 0.25f);
			int num2 = Mathf.CeilToInt(uvs.Max((Vector2 uv) => uv.x) * (float)tex.width - 0.25f);
			int num3 = Mathf.FloorToInt(uvs.Min((Vector2 uv) => uv.y) * (float)tex.height + 0.25f);
			int num4 = Mathf.CeilToInt(uvs.Max((Vector2 uv) => uv.y) * (float)tex.height - 0.25f);
			int num5 = math.min(num2 - num, tex.width);
			int num6 = math.min(num4 - num3, tex.height);
			return new Rect((float)num, (float)num3, (float)num5, (float)num6);
		}
	}
	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;

		public static void Initialize()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			RotateMaterial = new Material(AssetBundle.LoadFromFile(Path.Combine(Plugin.BasePath, "stitchwork.assetbundle")).LoadAsset<Shader>("Assets/Patchwork/Rotate.shader"));
		}

		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)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			byte[] array = FileCache.ReadBytes(path);
			if (array == null)
			{
				return null;
			}
			Texture2D val = new Texture2D(2, 2);
			if (!ImageConversion.LoadImage(val, array))
			{
				Plugin.Logger.LogWarning((object)("LoadFromPNG: Failed to decode image data from '" + path + "'"));
				return null;
			}
			((Texture)val).wrapMode = (TextureWrapMode)1;
			val.Apply(false, true);
			((Object)val).hideFlags = (HideFlags)32;
			return val;
		}

		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");
				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)
		{
			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(HeroController.instance?.playerData?.CurrentCrestID, Value), 
				ConditionType.NailUpgrade => NailUpgradeMatches((HeroController.instance?.playerData?.nailUpgrades).GetValueOrDefault(), Value), 
				ConditionType.PlayerData => EvaluatePlayerData(HeroController.instance?.playerData, 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 static readonly string[] ContentRoots = new string[5] { "Sprites", "Spritesheets", "Sounds", "Videos", "Text" };

		private const int MaxPerRule = 12;

		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);
			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);
			}
			return list;
		}

		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.0"));
			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 class PackInfo
	{
		private string _stableId;

		public string Path { get; }

		public string Name { get; }

		public string Author { get; }

		public string Version { get; }

		public string Description { get; }

		public bool IsEnabled { get; set; }

		public bool IsLocal { 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 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, bool isLocal, string author = null, string version = null, string description = null)
		{
			Path = path;
			Name = name;
			IsLocal = isLocal;
			Author = author;
			Version = version;
			Description = description;
		}

		public PackInfo Clone()
		{
			return new PackInfo(Path, Name, IsLocal, Author, Version, Description)
			{
				IsEnabled = IsEnabled,
				Stats = Stats,
				Conditions = Conditions.Select((PackCondition c) => c.Clone()).ToList(),
				ReloadTrigger = ReloadTrigger
			};
		}
	}
	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 LocalPacksPath => Path.Combine(Plugin.BasePath, "Packs");

		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()
		{
			IOUtil.EnsureDirectoryExists(LocalPacksPath);
			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, isLocal: false));
					}
				}
			}
			if (Directory.Exists(LocalPacksPath))
			{
				packSubfolderNames = Directory.GetDirectories(LocalPacksPath);
				foreach (string path in packSubfolderNames)
				{
					list.Add(ReadManifest(path, isLocal: true));
				}
			}
			return list;
		}

		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, bool isLocal)
		{
			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, isLocal);
			}
			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), isLocal, 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), isLocal);
			}
		}

		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)
			{
				if (GameBridge.TriggerSceneReloadCurrent())
				{
					Plugin.Logger.LogInfo((object)"[PackManager] Apply: watcher flags raised + scene reload dispatched via GameBridge.");
				}
				else
				{
					Plugin.Logger.LogInfo((object)"[PackManager] Apply: watcher flags raised (GameBridge scene reload unavailable — in-place only).");
				}
			}
			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.SpriteFileWatcher?.RebuildPackPngWatchers();
			Plugin.AudioFileWatcher?.RebuildPackWatchers();
			FileCache.Clear();
			SpriteFileWatcher.ReloadSprites = true;
			SpriteFileWatcher.ReloadT2DSprites = true;
			AudioFileWatcher.ReloadAudio = true;
			TextFileWatcher.ReloadText = 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(packPath, "Spritesheets", "*.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;
		}
	}
}
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;
		}

		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_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			//IL_0768: Expected O, but got Unknown
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0815: Unknown result type (might be due to invalid IL or missing references)
			//IL_0847: Unknown result type (might be due to invalid IL or missing references)
			//IL_084c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2f: 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_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: 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)
			if (clip?.frames == null || clip.frames.Length == 0)
			{
				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)
				{
					continue;
				}
				tk2dSpriteDefinition val2 = spriteCollection.spriteDefinitions[val.spriteId];
				if (string.IsNullOrEmpty(val2.name) || val2.positions == null || val2.positions.Length < 4 || val2.uvs == null || val2.uvs.Length < 4 || val2.texelSize.x <= 0f || val2.texelSize.y <= 0f || !hashSet.Add(val2.name))
				{
					continue;
				}
				Texture atlas = null;
				Vector2[] uvs = null;
				Vector3[] positions = null;
				if (fromCurrentRender || !SpriteLoader.TryGetVanilla(spriteCollection, val2, out atlas, out uvs, out positions))
				{
					Material obj = val2.materialInst ?? val2.material;
					atlas = ((obj != null) ? obj.mainTexture : null);
					uvs = val2.uvs;
					positions = val2.positions;
				}
				if (!((Object)(object)atlas == (Object)null) && uvs != null && uvs.Length >= 4 && positions != null && positions.Length >= 4)
				{
					string materialName = ((val2.materialId >= 0 && spriteCollection.materials != null && val2.materialId < spriteCollection.materials.Length) ? ((Object)spriteCollection.materials[val2.materialId]).name.Split(' ')[0] : "");
					frames.Add(new FrameGeom
					{
						SpriteName = val2.name,
						CollectionName = ((Object)spriteCollection).name,
						MaterialName = materialName,
						Atlas = atlas,
						Uvs = uvs,
						Positions = positions,
						TexelSize = val2.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 = val2.flipped
					});
				}
			}
			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).");
			}
			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 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."));
			}
			int num5 = (int)((num2 - num) / texel.x) + 1;
			int num6 = (int)((num4 - num3) / texel.y) + 1;
			int num7 = Mathf.Max(Mathf.CeilToInt(marginFraction * (float)num5), marginFloorPx);
			int num8 = Mathf.Max(Mathf.CeilToInt(marginFraction * (float)num6), marginFloorPx);
			int num9 = num5 + 2 * num7;
			int num10 = num6 + 2 * num8;
			int num11 = (int)((0f - num) / texel.x) + num7;
			int num12 = (int)((0f - num3) / texel.y) + num8;
			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: 5");
			stringBuilder.AppendLine($"issuedCanvas: {{ w: {num9}, h: {num10} }}");
			stringBuilder.AppendLine($"pivotInCanvas: {{ x: {num9 - 1 - num11}, y: {num12} }}");
			stringBuilder.AppendLine("pixelsPerUnit: " + (1f / texel.x).ToString("0.####", invariantCulture));
			stringBuilder.AppendLine("marginFraction: " + marginFraction.ToString(invariantCulture));
			stringBuilder.AppendLine("frames:");
			float num13 = 1f / texel.x;
			float num14 = 1f / texel.y;
			RenderTexture active = RenderTexture.active;
			RenderTexture temporary = RenderTexture.GetTemporary(num9, num10, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			Texture2D val3 = new Texture2D(num9, num10, (TextureFormat)4, false);
			Dictionary<int, RenderTexture> dictionary = new Dictionary<int, RenderTexture>();
			TexUtil.RotateMaterial.SetVector("_Basis", new Vector4(1f, 0f, 0f, 1f));
			try
			{
				int num15 = 0;
				foreach (FrameGeom item in frames)
				{
					RenderTexture pointAtlasRT = GetPointAtlasRT(item.Atlas, dictionary);
					RenderTexture.active = temporary;
					GL.Clear(true, true, Color.clear);
					GL.PushMatrix();
					GL.LoadPixelMatrix(0f, (float)num9, 0f, (float)num10);
					TexUtil.RotateMaterial.SetTexture("_MainTex", (Texture)(object)pointAtlasRT);
					TexUtil.RotateMaterial.SetPass(0);
					GL.Begin(7);
					GL.Color(Color.white);
					int[] array = new int[4] { 0, 1, 3, 2 };
					foreach (int num16 in array)
					{
						GL.TexCoord(Vector2.op_Implicit(item.Uvs[num16]));
						GL.Vertex3((float)num11 + item.Positions[num16].x * num13, (float)num12 + item.Positions[num16].y * num14, 0f);
					}
					GL.End();
					GL.PopMatrix();
					val3.ReadPixels(new Rect(0f, 0f, (float)num9, (float)num10), 0, 0);
					val3.Apply();
					FlipHorizontal(val3, num9, num10);
					string text2 = $"{num15:D3}_{T2DUtil.SanitizeForFilesystem(item.SpriteName)}.png";
					File.WriteAllBytes(Path.Combine(text, text2), ImageConversion.EncodeToPNG(val3));
					int num17 = Mathf.RoundToInt((float)num11 + item.PxMin * num13);
					int num18 = Mathf.RoundToInt((float)num11 + item.PxMax * num13) - num17;
					int num19 = num9 - num17 - num18;
					int num20 = Mathf.RoundToInt((float)num12 + item.PyMin * num14);
					int num21 = Mathf.RoundToInt((float)num12 + item.PyMax * num14) - num20;
					stringBuilder.AppendLine("  - spriteName: \"" + item.SpriteName + "\"");
					stringBuilder.AppendLine("    collection: \"" + item.CollectionName + "\"");
					stringBuilder.AppendLine("    material: \"" + item.MaterialName + "\"");
					stringBuilder.AppendLine("    dumpedFile: \"" + text2 + "\"");
					stringBuilder.AppendLine($"    canvasRect: {{ x: {num19}, y: {num20}, w: {num18}, h: {num21} }}");
					stringBuilder.AppendLine($"    flipped: {item.Flipped}");
					num15++;
				}
			}
			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(Path.Combine(text, path), stringBuilder.ToString());
			Plugin.Logger.LogInfo((object)($"[AnimWIP] '{clip.name}': {frames.Count} frame(s) → {num9}×{num10}, pivot ({num11},{num12}) " + "[source: " + (fromCurrentRender ? "current render" : "vanilla") + "] → " + text));
			return text;
		}

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

		private const byte AlphaThreshold = 16;

		private const int StrayTolerance = 2;

		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))
			{
				Plugin.Logger.LogWarning((object)("[AnimCompile] '" + clip?.name + "': no WIP folder — extract first."));
				return list;
			}
			string text2 = 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;
				}
				text2 = clip.name;
			}
			string path = Path.Combine(text, T2DUtil.SanitizeForFilesystem(clip.name) + "_sidecar.yml");
			if (!File.Exists(path))
			{
				Plugin.Logger.LogWarning((object)("[AnimCompile] '" + clip.name + "': sidecar missing — re-extract."));
				return list;
			}
			Sidecar sidecar = ParseSidecar(File.ReadAllLines(path));
			if (sidecar == null || sidecar.CanvasW <= 0 || sidecar.CanvasH <= 0)
			{
				Plugin.Logger.LogWarning((object)("[AnimCompile] '" + clip.name + "': sidecar unparseable or missing canvas dims."));
				return list;
			}
			Plugin.Logger.LogInfo((object)($"[AnimCompile] '{clip.name}': compiling {sidecar.Frames.Count} frame(s) from {text}" + ((text2 != null) ? (" → per-clip (Clips/" + text2 + "/)") : "")));
			foreach (FrameEntry frame in sidecar.Frames)
			{
				FrameOutcome item = CompileFrame(text, sidecar, frame, text2);
				list.Add(item);
				Plugin.Logger.LogInfo((object)("[AnimCompile]   " + item.Sprite + ": " + item.Kind + " — " + item.Detail));
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (FrameOutcome item2 in list)
			{
				if (item2.Kind == "inbounds")
				{
					num++;
				}
				else if (item2.Kind == "spill")
				{
					num2++;
				}
				else
				{
					num3++;
				}
			}
			Plugin.Logger.LogInfo((object)$"[AnimCompile] '{clip.name}': done — {num} in-bounds, {num2} spill, {num3} skipped.");
			return list;
		}

		private static FrameOutcome CompileFrame(string dir, Sidecar sc, FrameEntry fe, string clipDest = null)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			string path = Path.Combine(dir, fe.DumpedFile);
			if (!File.Exists(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(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();
				int num3 = 0;
				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++)
					{
						if (pixels[i * width + j].a >= 16)
						{
							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);
					File.WriteAllBytes(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";
				File.WriteAllBytes(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
			};
		}

		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_0018: Expected O, but got Unknown
			//IL_008b: 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_0097: 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_00a3: Expected O, but got Unknown
			//IL_00a9: Expected O, but got Unknown
			//IL_0066: 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)
			if (w <= 0 || h <= 0)
			{
				return ImageConversion.EncodeToPNG(new Texture2D(1, 1, (TextureFormat)4, false));
			}
			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 val = new Texture2D(w, h, (TextureFormat)4, false);
			val.SetPixels32(array);
			val.Apply();
			byte[] result = ImageConversion.EncodeToPNG(val);
			Object.Destroy((Object)val);
			return result;
		}

		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();
					}
				}
			}
			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]";

		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 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 void IndexFile(string rel, string fullPath, string sourcePack)
		{
			string[] array = rel.Split('/');
			if (array.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))
			{
				ConflictTracker.Record("clip", key, value.SourcePack, sourcePack);
				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)
			{
				string arg = ((list2.Count > 0) ? string.Format("; {0} clip name(s) not loaded yet ({1}…)", list2.Distinct<string>(StringComparer.OrdinalIgnoreCase).Count(), string.Join(", ", list2.Distinct<string>(StringComparer.OrdinalIgnoreCase).Take(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_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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_016d: 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_017f: Expected O, but got Unknown
			//IL_01c1: 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_01c8: 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_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: 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_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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_028a: Invalid comparison between Unknown and I4
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: 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_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: 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_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0631: 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_06c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d0: Expected O, but got Unknown
			//IL_0669: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_078a: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a3: 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_07b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07df: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e1: Unknown result type (might be due to invalid IL or missing references)
			byte[] array;
			try
			{
				array = File.ReadAllBytes(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;
		}
	}
	internal static class AppliquePhase0
	{
		internal const string ShadowNamePrefix = "Stitchwork_Shadow";

		private static bool _applied;

		private static tk2dSpriteAnimator _animator;

		private static tk2dSpriteAnimationClip _clipB;

		private static tk2dSpriteCollectionData _shadow;

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

		private static tk2dSpriteCollectionData _apColl;

		private static tk2dSpriteDefinition[] _apOrigDefs;

		private static tk2dSpriteAnimationClip _clipA2;

		private static bool _gate2BSeen;

		private static bool _gate2ASeen;

		public static void Toggle()
		{
			if (_applied)
			{
				Revert();
			}
			else
			{
				Apply();
			}
		}

		private static void Apply()
		{
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			_rewritten.Clear();
			_gate2BSeen = (_gate2ASeen = false);
			tk2dSpriteAnimator[] source = Object.FindObjectsByType<tk2dSpriteAnimator>((FindObjectsSortMode)0);
			_animator = ((IEnumerable<tk2dSpriteAnimator>)source).FirstOrDefault((Func<tk2dSpriteAnimator, bool>)((tk2dSpriteAnimator a) => (Object)(object)a != (Object)null && ((Object)a).name == "Hero_Hornet(Clone)" && (Object)(object)a.Library != (Object)null)) ?? ((IEnumerable<tk2dSpriteAnimator>)source).FirstOrDefault((Func<tk2dSpriteAnimator, bool>)((tk2dSpriteAnimator a) => (Object)(object)a != (Object)null && (Object)(object)a.Library != (Object)null));
			if ((Object)(object)_animator == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"[Applique-P0] No tk2dSpriteAnimator with a Library in scene — stand in-game and retry.");
				return;
			}
			tk2dSpriteAnimation library = _animator.Library;
			Plugin.Logger.LogInfo((object)$"[Applique-P0] Target animator '{((Object)_animator).name}', library '{((Object)library).name}', {library.clips.Length} clips.");
			int num = 0;
			for (int num2 = 0; num2 < library.clips.Length; num2++)
			{
				for (int num3 = num2 + 1; num3 < library.clips.Length; num3++)
				{
					if (library.clips[num2]?.frames != null && library.clips[num2].frames == library.clips[num3]?.frames)
					{
						num++;
					}
				}
			}
			Plugin.Logger.LogInfo((object)((num == 0) ? "[Applique-P0] GATE 5 PASS: no clip shares a frames[] array with another — per-clip rewrite is isolated by construction." : $"[Applique-P0] GATE 5 FAIL-ISH: {num} clip pair(s) share a frames[] array reference — rewrite needs deep-clone mitigation."));
			Dictionary<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>> dictionary = new Dictionary<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>>();
			tk2dSpriteAnimationClip[] clips = library.clips;
			foreach (tk2dSpriteAnimationClip val in clips)
			{
				if (val?.frames == null)
				{
					continue;
				}
				for (int num5 = 0; num5 < val.frames.Length; num5++)
				{
					tk2dSpriteAnimationFrame val2 = val.frames[num5];
					if (!((Object)(object)val2.spriteCollection == (Object)null))
					{
						(tk2dSpriteCollectionData, int) key = (val2.spriteCollection, val2.spriteId);
						if (!dictionary.TryGetValue(key, out var value))
						{
							value = (dictionary[key] = new List<(tk2dSpriteAnimationClip, int)>());
						}
						value.Add((val, num5));
					}
				}
			}
			List<KeyValuePair<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>>> list2 = (from kv in dictionary.Where<KeyValuePair<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>>>((KeyValuePair<(tk2dSpriteCollectionData coll, int id), List<(tk2dSpriteAnimationClip clip, int idx)>> kv) => kv.Value.Select(((tk2dSpriteAnimationClip clip, int idx) u) => u.clip).Distinct().Count() >= 2).Where<KeyValuePair<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>>>(delegate(KeyValuePair<(tk2dSpriteCollectionData coll, int id), List<(tk2dSpriteAnimationClip clip, int idx)>> kv)
				{
					tk2dSpriteDefinition[] spriteDefinitions = kv.Key.coll.spriteDefinitions;
					if (kv.Key.id < 0 || kv.Key.id >= spriteDefinitions.Length)
					{
						return false;
					}
					tk2dSpriteDefinition val7 = spriteDefinitions[kv.Key.id];
					if (val7 != null && !val7.complexGeometry)
					{
						Vector3[] positions = val7.positions;
						if (positions != null && positions.Length == 4)
						{
							Vector2[] uvs = val7.uvs;
							if (uvs != null && uvs.Length == 4 && val7.texelSize.x > 0f)
							{
								return val7.texelSize.y > 0f;
							}
						}
					}
					return false;
				})
				orderby (int)kv.Key.coll.spriteDefinitions[kv.Key.id].flipped == 0 descending
				select kv).ToList();
			if (list2.Count == 0)
			{
				Plugin.Logger.LogWarning((object)"[Applique-P0] No reused simple-geometry frame found in this library — try another scene/character.");
				return;
			}
			KeyValuePair<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>> keyValuePair = list2[0];
			tk2dSpriteCollectionData item = keyValuePair.Key.Item1;
			tk2dSpriteDefinition val3 = item.spriteDefinitions[keyValuePair.Key.Item2];
			List<IGrouping<tk2dSpriteAnimationClip, (tk2dSpriteAnimationClip, int)>> list3 = (from u in keyValuePair.Value
				group u by u.clip).ToList();
			_clipB = (list3.FirstOrDefault((IGrouping<tk2dSpriteAnimationClip, (tk2dSpriteAnimationClip clip, int idx)> g) => g.Key != _animator.CurrentClip) ?? list3[0]).Key;
			string text = string.Join(", ", from g in list3
				where g.Key != _clipB
				select "'" + g.Key.name + "'");
			_shadow = BuildShadowCollection(item, val3);
			if ((Object)(object)_shadow == (Object)null)
			{
				return;
			}
			foreach (var (val4, num6) in keyValuePair.Value.Where<(tk2dSpriteAnimationClip, int)>(((tk2dSpriteAnimationClip clip, int idx) u) => u.clip == _clipB))
			{
				_rewritten.Add((val4, num6, val4.frames[num6].spriteCollection, val4.frames[num6].spriteId));
				val4.frames[num6].spriteCollection = _shadow;
				val4.frames[num6].spriteId = 0;
			}
			Plugin.Logger.LogInfo((object)("[Applique-P0] GATE 1 PASS (B): shadow collection built; sprite '" + val3.name + "' " + $"(flip {val3.flipped}) diverted in clip '{_clipB.name}' ({keyValuePair.Value.Count<(tk2dSpriteAnimationClip, int)>(((tk2dSpriteAnimationClip clip, int idx) u) => u.clip == _clipB)} frame(s)). " + "LOOK FOR: magenta X marker while '" + _clipB.name + "' plays; UNCHANGED art in " + text + " (gate 3)."));
			KeyValuePair<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>> keyValuePair2 = list2.Skip(1).FirstOrDefault<KeyValuePair<(tk2dSpriteCollectionData, int), List<(tk2dSpriteAnimationClip, int)>>>((KeyValuePair<(tk2dSpriteCollectionData coll, int id), List<(tk2dSpriteAnimationClip clip, int idx)>> kv) => kv.Value.All(((tk2dSpriteAnimationClip clip, int idx) u) => u.clip != _clipB));
			if ((Object)(object)keyValuePair2.Key.Item1 != (Object)null)
			{
				_apColl = keyValuePair2.Key.Item1;
				tk2dSpriteDefinition srcDef2 = _apColl.spriteDefinitions[keyValuePair2.Key.Item2];
				tk2dSpriteDefinition val5 = ((IEnumerable<tk2dSpriteDefinition>)_apColl.spriteDefinitions).FirstOrDefault((Func<tk2dSpriteDefinition, bool>)delegate(tk2dSpriteDefinition d)
				{
					if (d != null && d != srcDef2 && !d.complexGeometry)
					{
						Vector3[] positions = d.positions;
						if (positions != null && positions.Length == 4)
						{
							Vector2[] uvs = d.uvs;
							if (uvs != null)
							{
								return uvs.Length == 4;
							}
							return false;
						}
					}
					return false;
				});
				if (val5 != null)
				{
					_apOrigDefs = _apColl.spriteDefinitions;
					tk2dSpriteDefinition[] array = (tk2dSpriteDefinition[])(object)new tk2dSpriteDefinition[_apOrigDefs.Length + 1];
					_apOrigDefs.CopyTo(array, 0);
					array[_apOrigDefs.Length] = val5;
					_apColl.spriteDefinitions = array;
					int num7 = _apOrigDefs.Length;
					List<IGrouping<tk2dSpriteAnimationClip, (tk2dSpriteAnimationClip, int)>> list4 = (from u in keyValuePair2.Value
						group u by u.clip).ToList();
					_clipA2 = (list4.FirstOrDefault((IGrouping<tk2dSpriteAnimationClip, (tk2dSpriteAnimationClip clip, int idx)> g) => g.Key != _animator.CurrentClip) ?? list4[0]).Key;
					foreach (var (val6, num8) in keyValuePair2.Value.Where<(tk2dSpriteAnimationClip, int)>(((tk2dSpriteAnimationClip clip, int idx) u) => u.clip == _clipA2))
					{
						_rewritten.Add((val6, num8, val6.frames[num8].spriteCollection, val6.frames[num8].spriteId));
						val6.frames[num8].spriteId = num7;
					}
					Plugin.Logger.LogInfo((object)($"[Applique-P0] GATE 1 PASS-SO-FAR (A): spriteDefinitions {_apOrigDefs.Length} → {array.Length} on " + $"'{((Object)_apColl).name}'; clip '{_clipA2.name}' frame(s) → appended id {num7} (donor art '{val5.name}'). " + "LOOK FOR: '" + val5.name + "''s art inside '" + _clipA2.name + "' where '" + srcDef2.name + "' used to show. If tk2d rejects the longer array, errors will follow this line."));
				}
				else
				{
					Plugin.Logger.LogInfo((object)"[Applique-P0] Variant A skipped: no donor def found.");
				}
			}
			else
			{
				Plugin.Logger.LogInfo((object)"[Applique-P0] Variant A skipped: no second reused candidate outside clip B.");
			}
			_applied = true;
			Plugin.Logger.LogInfo((object)"[Applique-P0] APPLIED. Trigger the named clips; watch for GATE 2 lines. Press the key again to revert (gate 4).");
		}

		private static tk2dSpriteCollectionData BuildShadowCollection(tk2dSpriteCollectionData srcColl, tk2dSpriteDefinition srcDef)
		{
			//IL_0141: 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_0150: Expected O, but got Unknown
			//IL_0153: 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_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: 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_02c5: 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)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: 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_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: 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_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: 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_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: 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_03b8: Expected O, but got Unknown
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Expected O, but got Unknown
			float num = srcDef.positions.Min((Vector3 p) => p.x);
			float num2 = srcDef.positions.Max((Vector3 p) => p.x);
			float num3 = srcDef.positions.Min((Vector3 p) => p.y);
			float num4 = srcDef.positions.Max((Vector3 p) => p.y);
			int num5 = Mathf.Max(2, Mathf.RoundToInt((num2 - num) / srcDef.texelSize.x));
			int num6 = Mathf.Max(2, Mathf.RoundToInt((num4 - num3) / srcDef.texelSize.y));
			if (num5 > 2048 || num6 > 2048)
			{
				Plugin.Logger.LogWarning((object)$"[Applique-P0] Marker {num5}x{num6} implausible — aborting B.");
				return null;
			}
			Texture2D mainTexture = BuildMarkerTexture(num5, num6);
			Material val = new Material(((Object)(object)srcDef.materialInst != (Object)null) ? srcDef.materialInst : srcDef.material)
			{
				mainTexture = (Texture)(object)mainTexture
			};
			((Object)val).hideFlags = (HideFlags)(((Object)val).hideFlags | 0x20);
			float num7 = (srcDef.uvs.Min((Vector2 u) => u.x) + srcDef.uvs.Max((Vector2 u) => u.x)) * 0.5f;
			float num8 = (srcDef.uvs.Min((Vector2 u) => u.y) + srcDef.uvs.Max((Vector2 u) => u.y)) * 0.5f;
			float num9 = 0.5f / (float)num5;
			float num10 = 0.5f / (float)num6;
			Vector2[] array = (Vector2[])(object)new Vector2[4];
			for (int num11 = 0; num11 < 4; num11++)
			{
				array[num11] = new Vector2((srcDef.uvs[num11].x > num7) ? (1f - num9) : num9, (srcDef.uvs[num11].y > num8) ? (1f - num10) : num10);
			}
			tk2dSpriteDefinition val2 = new tk2dSpriteDefinition
			{
				name = srcDef.name + "#applique",
				material = val,
				materialInst = val,
				materialId = 0,
				positions = (Vector3[])srcDef.positions.Clone(),
				uvs = array,
				normals = ((srcDef.normals != null) ? ((Vector3[])srcDef.normals.Clone()) : null),
				tangents = ((srcDef.tangents != null) ? ((Vector4[])srcDef.tangents.Clone()) : null),
				indices = ((srcDef.indices != null) ? ((int[])srcDef.indices.Clone()) : null),
				complexGeometry = false,
				flipped = (FlipMode)0,
				texelSize = new Vector2((num2 - num) / (float)num5, (num4 - num3) / (float)num6),
				boundsData = ((srcDef.boundsData != null) ? ((Vector3[])srcDef.boundsData.Clone()) : null),
				untrimmedBoundsData = ((srcDef.untrimmedBoundsData != null) ? ((Vector3[])srcDef.untrimmedBoundsData.Clone()) : null)
			};
			GameObject val3 = new GameObject("Stitchwork_Shadow_" + ((Object)srcColl).name);
			Object.DontDestroyOnLoad((Object)val3);
			tk2dSpriteCollectionData val4 = val3.AddComponent<tk2dSpriteCollectionData>();
			val4.spriteDefinitions = (tk2dSpriteDefinition[])(object)new tk2dSpriteDefinition[1] { val2 };
			val4.materials = (Material[])(object)new Material[1] { val };
			val4.premultipliedAlpha = srcColl.premultipliedAlpha;
			return val4;
		}

		private static Texture2D BuildMarkerTexture(int w, int h)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_0094: 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_0095: 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)0;
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor(byte.MaxValue, (byte)0, (byte)200, byte.MaxValue);
			Color32 val3 = default(Color32);
			((Color32)(ref val3))..ctor((byte)20, (byte)20, (byte)20, byte.MaxValue);
			Color32[] array = (Color32[])(object)new Color32[w * h];
			for (int i = 0; i < h; i++)
			{
				for (int j = 0; j < w; j++)
				{
					bool flag = j < 2 || i < 2 || j >= w - 2 || i >= h - 2;
					bool flag2 = ((j + i) & 0xF) < 3;
					array[i * w + j] = ((flag || flag2) ? val3 : val2);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			return val;
		}

		public static void Tick()
		{
			if (!_applied || (Object)(object)_animator == (Object)null)
			{
				return;
			}
			tk2dBaseSprite component = ((Component)_animator).GetComponent<tk2dBaseSprite>();
			if (!((Object)(object)component == (Object)null))
			{
				if (!_gate2BSeen && (Object)(object)_shadow != (Object)null && (Object)(object)component.Collection == (Object)(object)_shadow)
				{
					_gate2BSeen = true;
					Plugin.Logger.LogInfo((object)("[Applique-P0] GATE 2 PASS (B): live sprite is bound to the shadow collection during '" + _animator.CurrentClip?.name + "'. If the magenta marker is visible and correctly placed, gates 2+3 hold for the shadow variant."));
				}
				if (!_gate2ASeen && (Object)(object)_apColl != (Object)null && _apOrigDefs != null && (Object)(object)component.Collection == (Object)(object)_apColl && component.spriteId >= _apOrigDefs.Length)
				{
					_gate2ASeen = true;
					Plugin.Logger.LogInfo((object)$"[Applique-P0] GATE 2 PASS (A): live sprite resolved an APPENDED spriteId ({component.spriteId}) during '{_animator.CurrentClip?.name}' — append+rewrite accepted.");
				}
			}
		}

		private static void Revert()
		{
			foreach (var (val, num, spriteCollection, spriteId) in _rewritten)
			{
				val.frames[num].spriteCollection = spriteCollection;
				val.frames[num].spriteId = spriteId;
			}
			int count = _rewritten.Count;
			_rewritten.Clear();
			if ((Object)(object)_apColl != (Object)null && _apOrigDefs != null)
			{
				_apColl.spriteDefinitions = _apOrigDefs;
				Plugin.Logger.LogInfo((object)$"[Applique-P0] Variant A reverted: '{((Object)_apColl).name}' spriteDefinitions restored to {_apOrigDefs.Length}.");
			}
			_apColl = null;
			_apOrigDefs = null;
			_clipA2 = null;
			_shadow = null;
			_clipB = null;
			_applied = false;
			Plugin.Logger.LogInfo((object)$"[Applique-P0] GATE 4: reverted {count} frame entr(ies). Replay the clips — vanilla art must be back everywhere.");
		}
	}
	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> _completedAwaitingApply = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static bool _applySweepScheduled;

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

		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 void PlayHelperPatch(AudioSource source, ulong delay)
		{
			if (_inAudioPlayChain || IsDiagnosticSource(source))
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				if ((Object)(object)source.clip != (Object)null)
				{
					LogAudioCall("PlayHelper", source.clip, source);
					AudioHandler.OnAudioPlayed?.Invoke(source.clip, source);
					LoadAudio(source);
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.PlayHelper", heapBefore);
			}
		}

		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 void PlayInstancePrefix(AudioSource __instance)
		{
			if (IsDiagnosticSource(__instance) || _inAudioPlayChain)
			{
				return;
			}
			_inAudioPlayChain = true;
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.clip == (Object)null)
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				LogAudioCall("Play", __instance.clip, __instance);
				AudioHandler.OnAudioPlayed?.Invoke(__instance.clip, __instance);
				LoadAudio(__instance);
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.Play", heapBefore);
			}
		}

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

		public static void PlayOneShotHelperPatch(AudioSource source, ref AudioClip clip, float volumeScale)
		{
			if (_inAudioPlayChain)
			{
				return;
			}
			long heapBefore = DevProfiler.SnapshotHeapBytes();
			try
			{
				if ((Object)(object)clip != (Object)null)
				{
					LogAudioCall("PlayOneShot", clip, source);
					AudioHandler.OnAudioPlayed?.Invoke(clip, source);
					LoadAudio(ref clip);
				}
			}
			finally
			{
				DevProfiler.AddOpPositiveNetHeapDelta("Postfix.Audio.PlayOneShot", heapBefore);
			}
		}

		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 (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))
			{
				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))
				{
					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.Message));
			}
		}

		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++;
			}
			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);
			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 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 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))
				{
					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 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
			{
				IOUtilEnsureDir(outputPath);
				File.WriteAllText(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.0");
			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_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: 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_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_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_0595: 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)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			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;
						}
						bool flag = false;
						try
						{
							PropertyInfo property = type.GetProperty("enabled", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							if (property != null)
							{
								flag = (bool)property.GetValue(val3);
							}
						}
						catch
						{
						}
						sb.AppendLine($"    '{TPath(val3.transform)}'  enabled={flag}");
					}
					num += array6.Length;
				}
				if (num == 0)
				{
					sb.AppendLine("  (no PostProcessVolume / Volume / PostProcessLayer found)");
				}
			}
			catch (Exception ex)
			{
				sb.AppendLine("  [error: " + ex.Message + "]");
			}
			sb.AppendLine();
			sb.AppendLine("[Shader Globals — speculative probe]");
			sb.AppendLine("  (probed by candidate names; non-default values are signal)");
			bool flag2 = false;
			array5 = CandidateGlobalNames;
			foreach (string text2 in array5)
			{
				try
				{
					Color globalColor = Shader.GetGlobalColor(text2);
					if (globalColor.r != 0f || globalColor.g != 0f || globalColor.b != 0f || globalColor.a != 0f)
					{
						sb.AppendLine("  GlobalColor '" + text2 + "' = " + C(globalColor));
						flag2 = true;
					}
				}
				catch
				{
				}
				try
				{
					float globalFloat = Shader.GetGlobalFloat(text2);
					if (Math.Abs(globalFloat) > 0.0001f)
					{
						sb.AppendLine($"  GlobalFloat '{text2}' = {globalFloat:0.000}");
						flag2 = true;
					}
				}
				catch
				{
				}
				try
				{
					Vector4 globalVector = Shader.GetGlobalVector(text2);
					if (((Vector4)(ref globalVector)).sqrMagnitude > 0.0001f)
					{
						sb.AppendLine("  GlobalVector '" + text2 + "' = " + ((Vector4)(ref globalVector)).ToString("F3"));
						flag2 = true;
					}
				}
				catch
				{
				}
			}
			if (!flag2)
			{
				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();
		}

		private static void IOUtilEnsureDir(string filePath)
		{
			string directoryName = Path.GetDirectoryName(filePath);
			if (!string.IsNullOrEmpty(directoryName) && !Directory.Exists(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
		}
	}
	public static class MaterialNeutralizer
	{
		private struct RendererSnapshot
		{
			public Renderer Renderer;

			public MaterialPropertyBlock Mpb;
		}

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

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

		public static string LastStatus = "";

		public static int OverriddenCount => _snapshots.Count;

		public static int ApplyToRenderersByPath(string pathSubstring)
		{
			if (string.IsNullOrWhiteSpace(pathSubstring))
			{
				LastStatus = "Empty path — nothing to do";
				return 0;
			}
			int num = 0;
			StringBuilder stringBuilder = new StringBuilder();
			Renderer[] array = Resources.FindObjectsOfTypeAll<Renderer>();
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = TransformPath(((Component)val).transform);
				if (text.IndexOf(pathSubstring, StringComparison.OrdinalIgnoreCase) < 0)
				{
					continue;
				}
				ApplyTo(val, text);
				num++;
				if (stringBuilder.Length < 256)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append("; ");
					}
					stringBuilder.Append(text);
				}
			}
			LastStatus = ((num == 0) ? ("No renderers matched '" + pathSubstring + "'") : $"Applied to {num} renderer(s). First few: {stringBuilder}");
			Plugin.Logger.LogInfo((object)("[MaterialNeutralizer] " + LastStatus));
			return num;
		}

		public static void ApplyTo(Renderer r, string pathHint = null)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_00dd: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			if (!((Object)(object)r == (Object)null))
			{
				int instanceID = ((Object)r).GetInstanceID();
				if (!_snapshots.ContainsKey(instanceID))
				{
					MaterialPropertyBlock val = new MaterialPropertyBlock();
					r.GetPropertyBlock(val);
					_snapshots[instanceID] = new RendererSnapshot
					{
						Renderer = r,
						Mpb = val
					};
					_appliedPaths[instanceID] = pathHint ?? TransformPath(((Component)r).transform);
				}
				MaterialPropertyBlock val2 = new MaterialPropertyBlock();
				r.GetPropertyBlock(val2);
				val2.SetFloat("_CanLerpAmbient", 0f);
				val2.SetFloat("_AmbientLerp", 0f);
				val2.SetFloat("_CanDesaturate", 0f);
				val2.SetFloat("_Desaturation", 0f);
				val2.SetFloat("_CanHueShift", 0f);
				val2.SetFloat("_HueShift", 0f);
				val2.SetColor("_Color", Color.white);
				val2.SetColor("_CharacterTintColor", Color.white);
				r.SetPropertyBlock(val2);
			}
		}

		public static int RevertAll()
		{
			int num = 0;
			int num2 = 0;
			foreach (KeyValuePair<int, RendererSnapshot> snapshot in _snapshots)
			{
				Renderer renderer = snapshot.Value.Renderer;
				if ((Object)(object)renderer == (Object)null)
				{
					num2++;
					continue;
				}
				renderer.SetPropertyBlock(snapshot.Value.Mpb);
				num++;
			}
			_snapshots.Clear();
			_appliedPaths.Clear();
			LastStatus = $"Reverted {num} renderer(s)" + ((num2 > 0) ? $" ({num2} were destroyed since apply)" : "");
			Plugin.Logger.LogInfo((object)("[MaterialNeutralizer] " + LastStatus));
			return num;
		}

		public static int RevertByPath(string pathSubstring)
		{
			if (string.IsNullOrWhiteSpace(pathSubstring))
			{
				LastStatus = "Empty path — nothing to revert";
				return 0;
			}
			int num = 0;
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, RendererSnapshot> snapshot in _snapshots)
			{
				if ((_appliedPaths.TryGetValue(snapshot.Key, out var value) ? value : "(unknown path)").IndexOf(pathSubstring, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					Renderer renderer = snapshot.Value.Renderer;
					if ((Object)(object)renderer != (Object)null)
					{
						renderer.SetPropertyBlock(snapshot.Value.Mpb);
					}
					list.Add(snapshot.Key);
					num++;
				}
			}
			foreach (int item in list)
			{
				_snapshots.Remove(item);
				_appliedPaths.Remove(item);
			}
			LastStatus = ((num == 0) ? ("No overrides matched '" + pathSubstring + "'") : $"Reverted {num} renderer(s) matching '{pathSubstring}'");
			Plugin.Logger.LogInfo((object)("[MaterialNeutralizer] " + LastStatus));
			return num;
		}

		private static string TransformPath(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();
		}
	}
	internal static class ReloadCoordinator
	{
		internal static void Poll()
		{
			SpriteFileWatcher.Tick();
			if (SpriteFileWatcher.ReloadSprites)
			{
				Plugin.Logger.LogDebug((object)"[Update] ReloadSprites flag set — triggering SpriteLoader.Reload()");
				SpriteFileWatcher.ReloadSprites = false;
				DevProfiler.StartOp();
				FileCache.BeginCycle();
				try
				{
					SpriteLoader.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
				float num = DevProfiler.StopOp("SpriteLoader.Reload");
				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");
				Plugin.Logger.LogDebug((object)$"[Reload] T2DLoader.ReloadSpritesInScene completed in {num2:F1}ms");
				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");
				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");
			}
			if (VideoHandler.ReloadVideos)
			{
				VideoHandler.ReloadVideos = false;
				DevProfiler.StartOp();
				FileCache.BeginCycle();
				try
				{
					VideoHandler.Reload();
				}
				finally
				{
					FileCache.EndCycle();
				}
				DevProfiler.StopOp("VideoHandler.Reload");
			}
			GCUtil.BumpThresholdForStitchwork();
		}
	}
	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 const float FrameBudgetSec = 0.04f;

		private const float SceneArriveTimeoutSec = 90f;

		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_006d: 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)
			if (_isTraversing)
			{
				return;
			}
			Plugin.Logger.LogInfo((object)"Starting scene traversal for full sprite dump...");
			_isTraversing = true;
			_scenesSinceLastGC = 0;
			sceneQueue.Clear();
			scenesProcessed = 0;
			StartedAt = Time.realtimeSinceStartup;
			Dictionary<string, SceneInfo> teleportMap = SceneTeleportMap.GetTeleportMap();
			foreach (string key in teleportMap.Keys)
			{
				if (!sceneQueue.Contains(key) && (int)teleportMap[key].MapZone != 0)
				{
					Plugin.Logger.LogDebug((object)$"Enqueued scene: {key} : {teleportMap[key].MapZone}");
					sceneQueue.Enqueue(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.realtimeSinceStartup + 90f;
					while (!_sceneArrived && Time.realtimeSinceStartup < deadline)
					{
						yield return null;
					}
					if (!_sceneArrived)
					{
						Plugin.Logger.LogWarning((object)$"[FullDump] '{next}' did not fire sceneLoaded within {90f:F0} s — skipped.");
						continue;
					}
					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();
					while (!unload.isDone)
					{
						yield return null;
					}
					_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.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 SpriteDumper
	{
		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_01a8: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			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(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(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 Texture2D RotateToScreen(Texture2D src, 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_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_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//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_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_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_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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00ac: 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_00b8: 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_00c4: 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_0100: 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)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val;
			Vector2 val2;
			if ((int)flip != 1)
			{
				if ((int)flip == 2)
				{
					val = Vector2.down;
					val2 = Vector2.right;
				}
				else
				{
					val = Vector2.right;
					val2 = Vector2.up;
				}
			}
			else
			{
				val = Vector2.up;
				val2 = Vector2.left;
			}
			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 val3 = new Texture2D(num2, num3, (TextureFormat)4, false);
			try
			{
				RenderTexture.active = temporary;
				GL.PushMatrix();
				GL.LoadPixelMatrix(0f, (float)((Texture)temporary).height, (float)((Texture)temporary).width, 0f);
				TexUtil.RotateMaterial.SetVector("_Basis", new Vector4(val.x, val.y, val2.x, val2.y));
				Graphics.DrawTextureImpl(new Rect(0f, 0f, (float)((Texture)src).width, (float)((Texture)src).height), (Texture)(object)src, new Rect(0f, 0f, 1f, 1f), 0, 0, 0, 0, Color.white, TexUtil.RotateMaterial, 0);
				val3.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
				val3.Apply();
				GL.PopMatrix();
				return val3;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		private static void DumpRotatedSprite(tk2dSpriteDefinition def, Texture2D spriteTex, Rect spriteRect, string baseDir, string collectionName, string matname)
		{
			//IL_004e: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			//IL_0061: 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_0068: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_0099: 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_00a7: 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_00d7: 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_00fa: 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_0122: Expected O, but got Unknown
			//IL_013b: 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_0076: 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_0081: 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_0088: 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)
			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);
				FlipMode flipped = def.flipped;
				Vector2 val2;
				Vector2 val3;
				if ((int)flipped != 1)
				{
					if ((int)flipped == 2)
					{
						val2 = Vector2.down;
						val3 = Vector2.right;
					}
					else
					{
						val2 = Vector2.right;
						val3 = Vector2.up;
					}
				}
				else
				{
					val2 = Vector2.up;
					val3 = Vector2.left;
				}
				TexUtil.RotateMaterial.SetVector("_Basis", new Vector4(val2.x, val2.y, val3.x, val3.y));
				Graphics.DrawTextureImpl(new Rect(0f, 0f, (float)((Texture)spriteTex).width, (float)((Texture)spriteTex).height), (Texture)(object)spriteTex, new Rect(0f, 0f, 1f, 1f), 0, 0, 0, 0, Color.white, TexUtil.RotateMaterial, 0);
				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(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_0127: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_016a: 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_01ce: Unknown result type (might be due to invalid IL or missing references)
			if (def == null || string.IsNullOrEmpty(def.name) || 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(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(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)>();
		}

		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<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 readonly HashSet<tk2dSpriteCollectionData> _collectionsRevertedThisReload = new HashSet<tk2dSpriteCollectionData>();

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

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

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

		private static bool _copyTextureToRTSupported
		{
			get
			{
				//IL_0017: 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_001f: Invalid comparison between Unknown and I4
				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; }

		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 (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_0265: 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_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Expected O, but got Unknown
			//IL_08e5: 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_0912: Unknown result type (might be due to invalid IL or missing references)
			//IL_0917: Unknown result type (might be due to invalid IL or missing references)
			//IL_0919: Unknown result type (might be due to invalid IL or missing references)
			//IL_091c: Invalid comparison between Unknown and I4
			//IL_0925: Unknown result type (might be due to invalid IL or missing references)
			//IL_092a: Unknown result type (might be due to invalid IL or missing references)
			//IL_092c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0931: Unknown result type (might be due to invalid IL or missing references)
			//IL_091e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0921: Invalid comparison between Unknown and I4
			//IL_0620: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_062a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Expected O, but got Unknown
			//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_0959: Unknown result type (might be due to invalid IL or missing references)
			//IL_0935: Unknown result type (might be due to invalid IL or missing references)
			//IL_093a: Unknown result type (might be due to invalid IL or missing references)
			//IL_093c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0941: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09dc: 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_09ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a13: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0945: Unknown result type (might be due to invalid IL or missing references)
			//IL_094a: Unknown result type (might be due to invalid IL or missing references)
			//IL_094c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0951: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_0721: 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();
				if ((!SceneTraverser.IsTraversing || _collectionsWithFiles.Contains(((Object)collection).name)) && !(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;
						int num2 = Array.IndexOf(collection.materials, val);
						if (num2 >= 0)
						{
							_originalTexturesByColIndex[(((Object)collection).name, num2)] = _originalTextures[instanceID];
							_vanillaTexNamesByColIndex[(((Object)collection).name, num2)] = name2;
						}
						if (flag)
						{
							Plugin.Logger.LogWarning((object)("[SpriteLoader]   mat '" + text + "' → vanilla texture '" + name2 + "'"));
						}
						_vanillaCaptureSourceId[instanceID] = instanceID2;
					}
				}
				int num3 = Array.IndexOf(collection.materials, val);
				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;
					}
					else
					{
						val.mainTexture = (Texture)(object)value3;
					}
					continue;
				}
				if (!LoadedAtlases.ContainsKey(key))
				{
					LoadedAtlases[key] = new HashSet<string>();
				}
				Dictionary<string, RenderTexture> value11;
				RenderTexture value12;
				if (LoadedAtlases[key].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)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 value9))
					{
						value9 = (LoadedAtlasesTextures[key] = new Dictionary<string, RenderTexture>());
					}
					if (!value9.TryGetValue(name, out var value10) || (Object)(object)value10 == (Object)null)
					{
						RenderTexture val5 = new RenderTexture(num4, num5, 0, (RenderTextureFormat)0, TexUtil.ReadWriteForSource(val4))
						{
							hideFlags = (HideFlags)32,
							name = name
						};
						value10 = (value9[name] = val5);
					}
					else if (((Texture)value10).width != num4 || ((Texture)value10).height != num5)
					{
						value10.Release();
						((Texture)value10).width = num4;
						((Texture)value10).height = num5;
						value10.Create();
					}
					if (atlasExpansionPlan != null)
					{
						RenderTexture active = RenderTexture.active;
						RenderTexture.active = value10;
						GL.Clear(false, true, Color.clear);
						RenderTexture.active = active;
						if (_copyTextureToRTSupported)
						{
							Graphics.CopyTexture(val4, 0, 0, 0, 0, val4.width, val4.height, (Texture)(object)value10, 0, 0, 0, 0);
						}
						else
						{
							RenderTexture active2 = RenderTexture.active;
							RenderTexture.active = value10;
							GL.PushMatrix();
							GL.LoadPixelMatrix(0f, (float)((Texture)value10).width, (float)((Texture)value10).height, 0f);
							Graphics.DrawTexture(new Rect(0f, (float)(((Texture)value10).height - val4.height), (float)val4.width, (float)val4.height), val4);
							GL.PopMatrix();
							RenderTexture.active = active2;
						}
					}
					else
					{
						Graphics.Blit(val4, value10);
					}
					if ((Object)(object)val3 != (Object)null)
					{
						Object.Destroy((Object)(object)val3);
					}
					if (atlasExpansionPlan != null)
					{
						ApplyExpansionPlan(collection, atlasExpansionPlan, instanceID, num3, ((Texture)value10).width, ((Texture)value10).height);
						_collectionsExpandedThisReload.Add(collection);
					}
					val.mainTexture = (Texture)(object)value10;
				}
				else if (LoadedAtlasesTextures.TryGetValue(key, out value11) && value11.TryGetValue(name, out value12))
				{
					val.mainTexture = (Texture)(object)value12;
				}
				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 value13))
						{
							value13 = (LoadedSprites[key] = new Dictionary<string, HashSet<string>>());
						}
						if (!value13.TryGetValue(name, out var value14))
						{
							value14 = (value13[name] = new HashSet<string>());
						}
						if (!value14.Add(val7.name))
						{
							continue;
						}
						_loadedSpriteCount++;
						Texture2D val8 = FindSprite(((Object)collection).name, instanceID, text, val7.name);
						if ((Object)(object)val8 == (Object)null)
						{
							continue;
						}
						_perCollectionReplacements.TryGetValue(((Object)collection).name, out var value15);
						_perCollectionReplacements[((Object)collection).name] = value15 + 1;
						Rect spriteRect = SpriteUtil.GetSpriteRect(val7, val.mainTexture);
						((Rect)(ref spriteRect)).y = (float)val.mainTexture.height - ((Rect)(ref spriteRect)).y - ((Rect)(ref spriteRect)).height;
						FlipMode flipped = val7.flipped;
						Vector2 val9;
						Vector2 val10;
						if ((int)flipped != 1)
						{
							if ((int)flipped == 2)
							{
								val9 = Vector2.up;
								val10 = Vector2.left;
							}
							else
							{
								val9 = Vector2.right;
								val10 = Vector2.up;
							}
						}
						else
						{
							val9 = Vector2.down;
							val10 = Vector2.right;
						}
						Rect val11 = 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 val11))..ctor(((Rect)(ref spriteRect)).x, ((Rect)(ref spriteRect)).y + (float)num7, (float)((Texture)val8).width, (float)((Texture)val8).height);
							}
						}
						TexUtil.RotateMaterial.SetVector("_Basis", new Vector4(val9.x, val9.y, val10.x, val10.y));
						Graphics.DrawTextureImpl(val11, (Texture)(object)val8, new Rect(0f, 0f, 1f, 1f), 0, 0, 0, 0, Color.white, TexUtil.RotateMaterial, 0);
						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;
		}

		private static void RebuildFileIndex()
		{
			_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(Path.Combine(pluginPackPath2, "Spritesheets"), 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));
				}
			}
			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 (text2.IndexOf("_WIP/", StringComparison.OrdinalIgnoreCase) < 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))
							{
								ConflictTracker.Record(conflictType, ConflictKey(conflictType, text2), value.Item2, sourcePack);
							}
							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;
		}

		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);
		}

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

		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 (string item2 in value.Keys.ToList())
					{
						if (item2.StartsWith(atlasName))
						{
							value[item2].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))
					{
						foreach (string item2 in value.Where((string a) => a.StartsWith(atlasName)).ToList())
						{
							value.Remove(item2);
						}
					}
					if (!LoadedSprites.TryGetValue(item, out var value2))
					{
						continue;
					}
					foreach (string item3 in value2.Keys.Where((string a) => a.StartsWith(atlasName)).ToList())
					{
						value2[item3].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()
		{
			RebuildFileIndex();
			LoadedAtlases.Clear();
			LoadedSprites.Clear();
			_loadedSpriteCount = 0;
			_instanceKeyToName.Clear();
			_nameInstanceCount.Clear();
			_collectionsExpandedThisReload.Clear();
			_collectionsRevertedThisReload.Clear();
			_perCollectionReplacements.Clear();
			tk2dSpriteCollectionData[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val in array)
			{
				if (!((Object)val).name.StartsWith("Stitchwork_Shadow", StringComparison.Ordinal))
				{
					LoadCollection(val);
				}
			}
			if (_collectionsWithFiles.Count == 0 && _originalTextures.Count > 0)
			{
				int num = 0;
				Material[] array2 = Resources.FindObjectsOfTypeAll<Material>();
				foreach (Material val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						int instanceID = ((Object)val2).GetInstanceID();
						if (_originalTextures.TryGetValue(instanceID, out var value) && (Object)(object)value != (Object)null && value.IsCreated() && (Object)(object)val2.mainTexture != (Object)(object)value)
						{
							val2.mainTexture = (Texture)(object)value;
							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[] array3 = Resources.FindObjectsOfTypeAll<tk2dBaseSprite>();
				foreach (tk2dBaseSprite val3 in array3)
				{
					if (!((Object)(object)val3 == (Object)null) && hashSet.Contains(val3.Collection))
					{
						val3.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} sprite(s) blitted across " + $"{LoadedAtlases.Count} atlas(es){arg}"));
			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_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_0203: 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(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(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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00c6: 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(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(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_0057: 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_0068: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Expected O, but got Unknown
			//IL_041d: 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)
			//IL_0175: 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_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: 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)
			//IL_01cf: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: 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_0257: Expected O, but got Unknown
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Expected O, but got Unknown
			//IL_0296: 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: Expected O, but got Unknown
			//IL_00f5: 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_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_0116: 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_0126: 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)
			if (T2DUtil.IsT2DTexture(((Object)sprite.texture).name))
			{
				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");
				GameObject val2 = null;
				Camera val3 = null;
				RenderTexture val4 = null;
				Texture2D val5 = null;
				Texture2D val6 = null;
				Sprite val7 = null;
				try
				{
					Sprite sprite2 = sprite;
					if (T2DLoader.TryGetOriginalPngBytes(((Object)sprite.texture).name, out var png))
					{
						val6 = new Texture2D(2, 2, (TextureFormat)4, false);
						if (ImageConversion.LoadImage(val6, png) && ((Texture)val6).width == ((Texture)sprite.texture).width && ((Texture)val6).height == ((Texture)sprite.texture).height)
						{
							Texture2D obj = val6;
							Rect rect2 = sprite.rect;
							float x = sprite.pivot.x;
							rect = sprite.rect;
							float num4 = x / ((Rect)(ref rect)).width;
							float y = sprite.pivot.y;
							rect = sprite.rect;
							val7 = Sprite.Create(obj, rect2, new Vector2(num4, y / ((Rect)(ref rect)).height), sprite.pixelsPerUnit);
							sprite2 = val7;
						}
					}
					val.AddComponent<SpriteRenderer>().sprite = sprite2;
					val.layer = num3;
					Transform transform = val.transform;
					float x2 = sprite.pivot.x;
					rect = sprite.rect;
					float num5 = (x2 - ((Rect)(ref rect)).width / 2f) / sprite.pixelsPerUnit;
					float y2 = sprite.pivot.y;
					rect = sprite.rect;
					transform.position = new Vector3(num5, (y2 - ((Rect)(ref rect)).height / 2f) / sprite.pixelsPerUnit, 0f);
					val2 = new GameObject("TempCamera");
					val3 = val2.AddComponent<Camera>();
					val3.clearFlags = (CameraClearFlags)2;
					val3.backgroundColor = new Color(0f, 0f, 0f, 0f);
					val3.orthographic = true;
					val3.cullingMask = 1 << num3;
					val3.orthographicSize = (float)num2 / sprite.pixelsPerUnit / 2f;
					((Component)val3).transform.position = new Vector3(0f, 0f, -10f);
					val4 = new RenderTexture(num, num2, 0, (RenderTextureFormat)0);
					((Texture)val4).filterMode = (FilterMode)0;
					val3.targetTexture = val4;
					val3.Render();
					RenderTexture active = RenderTexture.active;
					RenderTexture.active = val4;
					val5 = new Texture2D(num, num2, (TextureFormat)5, false);
					val5.ReadPixels(new Rect(0f, 0f, (float)num, (float)num2), 0, 0);
					val5.Apply();
					RenderTexture.active = active;
					File.WriteAllBytes(path2, ImageConversion.EncodeToPNG(val5));
					return;
				}
				finally
				{
					if ((Object)(object)val3 != (Object)null)
					{
						val3.targetTexture = null;
					}
					if ((Object)(object)val != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val);
					}
					if ((Object)(object)val2 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val2);
					}
					if ((Object)(object)val4 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val4);
					}
					if ((Object)(object)val5 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val5);
					}
					if ((Object)(object)val7 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val7);
					}
					if ((Object)(object)val6 != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)val6);
					}
				}
			}
			string text2 = T2DUtil.SanitizeForFilesystem(((Object)sprite.texture).name);
			string path3 = Path.Combine(DumpPath, text2 + ".png");
			if (File.Exists(path3))
			{
				return;
			}
			if (T2DLoader.TryGetOriginalPngBytes(((Object)sprite.texture).name, out var png2))
			{
				File.WriteAllBytes(path3, png2);
				return;
			}
			Plugin.Logger.LogDebug((object)("[T2D] Dumping non-atlas texture: '" + ((Object)sprite.texture).name + "' -> " + text2 + ".png"));
			RenderTexture val8 = null;
			Texture2D val9 = null;
			try
			{
				val8 = TexUtil.GetReadable((Texture)(object)sprite.texture);
				val9 = new Texture2D(((Texture)val8).width, ((Texture)val8).height, (TextureFormat)5, false);
				RenderTexture active2 = RenderTexture.active;
				RenderTexture.active = val8;
				val9.ReadPixels(new Rect(0f, 0f, (float)((Texture)val8).width, (float)((Texture)val8).height), 0, 0);
				val9.Apply();
				RenderTexture.active = active2;
				File.WriteAllBytes(path3, ImageConversion.EncodeToPNG(val9));
			}
			finally
			{
				if ((Object)(object)val8 != (Object)null)
				{
					RenderTexture.ReleaseTemporary(val8);
				}
				if ((Object)(object)val9 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val9);
				}
			}
		}
	}
	[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.Message));
				return;
			}
			for (int i = 0; i < num && i < array.Length; i++)
			{
				Sprite val = array[i];
				if ((Object)(object)((val != null) ? val.texture : null) != (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 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 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 bool _sceneSeedDone;

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

		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);
			}
		}

		private static void SeedFromScene()
		{
			if (_sceneSeedDone)
			{
				return;
			}
			_sceneSeedDone = true;
			SpriteRenderer[] array = Resources.FindObjectsOfTypeAll<SpriteRenderer>();
			foreach (SpriteRenderer val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					Sprite sprite = val.sprite;
					if ((Object)(object)((sprite != null) ? sprite.texture : null) != (Object)null)
					{
						_knownRenderers.Add(val);
					}
				}
			}
			Image[] array2 = Resources.FindObjectsOfTypeAll<Image>();
			foreach (Image val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					Sprite sprite2 = val2.sprite;
					if ((Object)(object)((sprite2 != null) ? sprite2.texture : null) != (Object)null)
					{
						_knownImages.Add(val2);
					}
				}
			}
			_seededSprites = Resources.FindObjectsOfTypeAll<Sprite>();
		}

		public static void ResetSceneSeed()
		{
			_sceneSeedDone = false;
			_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>();
			_sceneSeedDone = true;
			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);
					}
				}
			}
			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[] array = Resources.FindObjectsOfTypeAll<tk2dSpriteCollectionData>();
			foreach (tk2dSpriteCollectionData val in array)
			{
				if (val?.spriteDefinitions == null)
				{
					continue;
				}
				tk2dSpriteDefinition[] spriteDefinitions = val.spriteDefinitions;
				foreach (tk2dSpriteDefinition val2 in spriteDefinitions)
				{
					object obj;
					if (val2 == null)
					{
						obj = null;
					}
					else
					{
						Material material = val2.material;
						obj = ((material != null) ? material.mainTexture : null);
					}
					if (!((Object)obj == (Object)null) && !string.IsNullOrEmpty(val2.name))
					{
						string name = ((Object)val2.material.mainTexture).name;
						if (dictionary.TryGetValue(name, out var value3))
						{
							value3.Item4.Add(val2.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 val3)
			{
				if (!((Object)(object)((val3 != null) ? val3.texture : null) == (Object)null))
				{
					Texture2D texture = val3.texture;
					int instanceID = ((Object)texture).GetInstanceID();
					if (!spritesByTexId.TryGetValue(instanceID, out var value7))
					{
						value7 = new HashSet<string>(StringComparer.Ordinal);
						spritesByTexId[instanceID] = value7;
						texById[instanceID] = (Texture)(object)texture;
					}
					if (!string.IsNullOrEmpty(((Object)val3).name))
					{
						value7.Add(((Object)val3).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()
		{
			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()
		{
			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_0078: 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)
					if (_loadedSprites.ContainsKey(key))
					{
						ConflictTracker.Record("t2d-sprite", key, _t2dProviders.GetValueOrDefault(key), sourcePack);
						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;
					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)
		{
			//IL_0040: 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)
			Sprite val;
			if (Math.Abs(cached.pixelsPerUnit - targetPPU) <= 0.5f)
			{
				val = cached;
			}
			else
			{
				Sprite val2 = Sprite.Create(cached.texture, new Rect(0f, 0f, (float)((Texture)cached.texture).width, (float)((Texture)cached.texture).height), new Vector2(0.5f, 0.5f), targetPPU);
				((Object)val2).name = ((Object)cached).name;
				((Object)val2).hideFlags = (HideFlags)32;
				_ourSpriteIds.Add(((Object)val2).GetInstanceID());
				_loadedSprites[key] = val2;
				val = val2;
			}
			if (vanillaTextureName != null && (Object)(object)val.texture != (Object)null && string.IsNullOrEmpty(((Object)val.texture).name))
			{
				((Object)val.texture).name = vanillaTextureName;
			}
			return val;
		}

		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);
					}
				}
			}
		}

		internal static void HandleLoad(object spriteContainer, Sprite sprite)
		{
			//IL_01cc: 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_01ee: 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)
			if (_handling || !HasT2DReplacements || (Object)(object)((sprite != null) ? sprite.texture : null) == (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);
					}
					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 && _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);
				}
				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);
						}
					}
					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 != null) ? value.texture : null) != (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}:{(Object)(object)val4 == (Object)null}";
					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 + "' " + $"texFakeNull={(Object)(object)val4 == (Object)null} — 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 != null) ? value.texture : null) != (Object)null)
				{
					SkippedTextureIds.Add(((Object)value.texture).GetInstanceID());
				}
			}
			InitializedSpriteRenderers.Clear();
			InvalidateUninitCache();
			_replacedSrs.Clear();
			_replacedImgs.Clear();
		}

		public static void ReloadSpritesInScene()
		{
			List<Sprite> list = new List<Sprite>(_loadedSprites.Values);
			_loadedSprites.Clear();
			_spriteNameToKey.Clear();
			_t2dProviders.Clear();
			_coveredCleanNames.Clear();
			_emittedMissKeys.Clear();
			ReplacedTextureIds.Clear();
			SkippedTextureIds.Clear();
			ClearSoftSkips();
			_restoredNames.Clear();
			T2DUtil.ClearCleanNameCache();
			foreach (Sprite item in list)
			{
				if ((Object)(object)((item != null) ? item.texture : null) != (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();
			if (list.Count > 0)
			{
				HashSet<Sprite> hashSet = new HashSet<Sprite>(list);
				Dictionary<string, Sprite> dictionary = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);
				Sprite[] array6 = Resources.FindObjectsOfTypeAll<Sprite>();
				foreach (Sprite val4 in array6)
				{
					if ((Object)(object)val4 != (Object)null && !hashSet.Contains(val4) && !dictionary.ContainsKey(((Object)val4).name))
					{
						dictionary[((Object)val4).name] = val4;
					}
				}
				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 value2;
							Sprite val6 = (_loadedSprites.TryGetValue(KeyForSprite(val5.sprite), out value) ? value : (dictionary.TryGetValue(((Object)val5.sprite).name, out value2) ? value2 : null));
							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 value3;
							Sprite value4;
							Sprite val8 = (_loadedSprites.TryGetValue(KeyForSprite(val7.sprite), out value3) ? value3 : (dictionary.TryGetValue(((Object)val7.sprite).name, out value4) ? value4 : null));
							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, {dictionary.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) && list.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) && list.Contains(val10.sprite))
				{
					hashSet2.Add(((Object)val10.sprite).GetInstanceID());
				}
			}
			int num3 = 0;
			int num4 = 0;
			foreach (Sprite item2 in list)
			{
				if ((Object)(object)item2 == (Object)null)
				{
					continue;
				}
				if (hashSet2.Contains(((Object)item2).GetInstanceID()))
				{
					num4++;
					continue;
				}
				if ((Object)(object)item2.texture != (Object)null)
				{
					Object.Destroy((Object)(object)item2.texture);
				}
				Object.Destroy((Object)(object)item2);
				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."));
			}
		}

		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)
			{
				return true;
			}
			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", "m_FallbackFontAssetTable");
			if (_fontAssetFallbackTableMember == null)
			{
				Plugin.Logger.LogDebug((object)"[T2D] TMProOld.TMP_FontAsset.fallbackFontAssetTable 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 (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));
				if (T2DUtil.IsT2DTexture(((Object)tex).name))
				{
					foreach (KeyValuePair<string, (byte[], int, int)> spritesheetOverride in SpritesheetOverrides)
					{
						if (string.Equals(T2DUtil.CleanTextureName(spritesheetOverride.Key), text, StringComparison.OrdinalIgnoreCase) && spritesheetOverride.Value.Item2 == ((Texture)tex).width && spritesheetOverride.Value.Item3 == ((Texture)tex).height)
						{
							value = spritesheetOverride.Value;
							break;
						}
					}
				}
				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;
				}
				Plugin.Logger.LogInfo((object)("[T2D] Fuzzy match for '" + ((Object)tex).name + "' → clean name '" + text + "' " + $"({((Texture)tex).width}x{((Texture)tex).height})"));
			}
			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 text2 = "[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)text2);
				}
				else
				{
					Plugin.Logger.LogDebug((object)text2);
				}
				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(Path.Combine(pluginPackPath, "Spritesheets", "T2D"), pluginPackPath);
			}
			ScanDirectory(AtlasLoadPath, null);
			void ScanDirectory(string dir, string sourcePack)
			{
				if (Directory.Exists(dir))
				{
					string[] files = Directory.GetFiles(dir, "*.png", SearchOption.TopDirectoryOnly);
					foreach (string text in files)
					{
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
						namesAttempted.Add(fileNameWithoutExtension);
						if (SpritesheetOverrides.ContainsKey(fileNameWithoutExtension))
						{
							ConflictTracker.Record("t2d-sheet", fileNameWithoutExtension, _sheetProviders.GetValueOrDefault(fileNameWithoutExtension), sourcePack);
						}
						else
						{
							bool flag = false;
							try
							{
								byte[] array = File.ReadAllBytes(text);
								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 '" + text + "': " + 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."));
							}
						}
					}
				}
			}
		}

		internal static void RegisterStandaloneSpritesheet(string textureName, string file, string sourcePack)
		{
			if (SpritesheetOverrides.ContainsKey(textureName))
			{
				ConflictTracker.Record("t2d-sheet", textureName, _sheetProviders.GetValueOrDefault(textureName), sourcePack);
				return;
			}
			try
			{
				byte[] array = File.ReadAllBytes(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 void ConvertSpritesheet(Texture2D atlas, string cleanName)
		{
			//IL_00be: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0118: 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 active = RenderTexture.active;
			RenderTexture.active = temporary;
			try
			{
				int num = 0;
				Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
				foreach (Sprite val in array)
				{
					if ((Object)(object)val == (Object)null || (Object)(object)val.texture == (Object)null || ((Object)val.texture).GetInstanceID() != ((Object)atlas).GetInstanceID() || string.IsNullOrEmpty(((Object)val).name))
					{
						continue;
					}
					string path = Path.Combine(text, ((Object)val).name + ".png");
					if (File.Exists(path))
					{
						continue;
					}
					Rect rect = val.rect;
					if (!(((Rect)(ref rect)).width <= 0f) && !(((Rect)(ref rect)).height <= 0f))
					{
						Texture2D val2 = new Texture2D((int)((Rect)(ref rect)).width, (int)((Rect)(ref rect)).height, (TextureFormat)4, false);
						try
						{
							val2.ReadPixels(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width, ((Rect)(ref rect)).height), 0, 0);
							val2.Apply();
							IOUtil.EnsureDirectoryExists(text);
							File.WriteAllBytes(path, ImageConversion.EncodeToPNG(val2));
							num++;
						}
						finally
						{
							Object.Destroy((Object)(object)val2);
						}
					}
				}
				if (num > 0)
				{
					Plugin.Logger.LogDebug((object)$"[T2D] Converted spritesheet '{cleanName}' → {num} individual sprites in {text}");
				}
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		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 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 int AddedCount;

			public int IdenticalCount;

			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
			};
			string[] directories = Directory.GetDirectories(path);
			foreach (string path2 in directories)
			{
				string fileName = Path.GetFileName(path2);
				string[] files = Directory.GetFiles(path2, "*.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++;
						}
						else
						{
							plan.Conflicts.Add(new Conflict
							{
								Sheet = fileName,
								Lang = fileNameWithoutExtension,
								Key = item.Key,
								RootValue = value,
								PackValue = item.Value
							});
						}
					}
				}
			}
			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 != 0)
				{
					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)
				{
					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);
		}

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

		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(Path.Combine(pluginPackPath, "Videos"));
			}
			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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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.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.ContainsKey(name))
			{
				return VideoFileMap[name];
			}
			foreach (string pluginPackPath in Plugin.PluginPackPaths)
			{
				if (Directory.Exists(Path.Combine(pluginPackPath, "Videos")))
				{
					string[] files = Directory.GetFiles(Path.Combine(pluginPackPath, "Videos"), name + ".*", SearchOption.AllDirectories);
					if (files.Any())
					{
						string text = "file:///" + files[0];
						VideoFileMap[name] = text;
						return text;
					}
				}
			}
			string[] files2 = Directory.GetFiles(VideoLoadPath, name + ".*", SearchOption.AllDirectories);
			if (files2.Any())
			{
				string text2 = "file:///" + files2[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();
			}
		}

		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)
			{
				__instance.videoPlayer.url = text;
				__instance.videoPlayer.clip = null;
				__instance.videoPlayer.playbackSpeed = 1f;
				if (Object.op_Implicit((Object)(object)config.AudioSource))
				{
					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
				{
					Plugin.Logger.LogWarning((object)("Using custom video file '" + config.VideoReference.VideoFileName + "' with direct audio output. This may result in no audio being played."));
					__instance.videoPlayer.audioOutputMode = (VideoAudioOutputMode)2;
				}
				__instance.videoPlayer.Prepare();
			}
		}

		private static void PlayVideoPostfix(EmbeddedCinematicVideoPlayer __instance)
		{
			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 = Path.Combine(pluginPackPath, "Spritesheets");
				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);
			string[] array = relativePath.Split(Path.DirectorySeparatorChar);
			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"));
				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"));
				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"));
				DeferReloadT2DSprites();
				return;
			}
			string text = array[^2];
			string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(array[^1]);
			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 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);
			_closePrompt = false;
			_pendingProfileDelete = null;
			Rebuild();
		}

		public static void Hide()
		{
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
		}

		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)
			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>();
			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);
			}
		}

		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.0", 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_0592: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: 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_0624: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_066b: Unknown result type (might be due to invalid IL or missing references)
			//IL_070c: 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.IsLocal ? Loc.T("local") : Loc.T("pack") };
			string badge = packInfo.Stats.Badge;
			if (badge != null)
			{
				list2.Add(badge);
			}
			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);
			}
			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)
				{
					Process.Start(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 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_01b3: 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_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: 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)
			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", item.Key, 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));
			}
		}

		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_0041: 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_0095: Expected O, but got Unknown
			//IL_0112: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: 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_027f: 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_0293: 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_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0882: Unknown result type (might be due to invalid IL or missing references)
			//IL_0887: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c3: Expected O, but got Unknown
			//IL_093b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0942: 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_05e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Expected O, but got Unknown
			//IL_0a69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa2: Expected O, but got Unknown
			//IL_0a48: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b31: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b72: Expected O, but got Unknown
			//IL_0bdb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c17: Expected O, but got Unknown
			//IL_0c3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c45: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0702: Unknown result type (might be due to invalid IL or missing references)
			//IL_0715: Unknown result type (might be due to invalid IL or missing references)
			//IL_073f: Expected O, but got Unknown
			//IL_075a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			//IL_078e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0afc: 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;
			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, FabricUI.S(16f));
					}
					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);
						GameObject val6 = new GameObject($"OpSlot_{num3}", new Type[1] { typeof(RectTransform) });
						val6.transform.SetParent(val2.transform, false);
						FabricUI.AddLayout(val6, -1f, FabricUI.S(36f));
						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 = Vector2.zero;
						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);
					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);
			float num7 = FabricUI.S(36f);
			foreach (List<int> item2 in list)
			{
				float num8 = (float)item2.Count * num7 - FabricUI.S(4f);
				if (item2.Count > 1)
				{
					BuildNotchedBracket(val3.transform, num8, color);
				}
				else
				{
					GameObject val8 = new GameObject("BracketSpacer", new Type[1] { typeof(RectTransform) });
					val8.transform.SetParent(val3.transform, false);
					FabricUI.AddLayout(val8, -1f, num8);
				}
				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));
		}

		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);
				});
			}
			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;
				});
			}
			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;
				});
			}
		}

		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)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_004e: 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_0095: 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_00fa: 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_0105: 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)));
			((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 readonly string[] _pillarError = new string[TabNames.Length];

		private static int _pillarErrorFrame = -1;

		public static Rect WindowRect => _windowRect;

		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_01a9: 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 (GUILayout.Button("×", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Width(28f),
				GUIHelper.Height(28f)
			}))
			{
				Plugin.ShowDevHub = false;
			}
			GUILayout.EndHorizontal();
			GUIHelper.Space(6f);
			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 Texture2D reloadBarTex;

		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_0065: 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_0036: Expected O, but got Unknown
			//IL_0051: 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_0089: Expected O, but got Unknown
			//IL_0090: 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_00bd: Expected O, but got Unknown
			//IL_00c4: 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_021d: 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)
			//IL_016b: 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)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: 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_017d: 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)
			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);
				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);
				barTex.SetPixel(0, 0, Color.white);
				barTex.Apply();
			}
			if ((Object)(object)reloadBarTex == (Object)null)
			{
				reloadBarTex = new Texture2D(1, 1);
				reloadBarTex.SetPixel(0, 0, Color.white);
				reloadBarTex.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 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_02bb: 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_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_0279: 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_0297: 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>());
				if (GUILayout.Button(hasUnsavedChanges ? (Loc.T("Save") + " *") : Loc.T("Save"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(80f)
				}))
				{
					SaveEntry(selectedEntry, editText);
				}
				if (GUILayout.Button(Loc.T("Revert"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUIHelper.Height(26f),
					GUIHelper.Width(80f)
				}))
				{
					editText = SmartWrap(selectedEntry.CurrentText);
					hasUnsavedChanges = false;
				}
				if (GUILayout.Button(Loc.T("Delete Override"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(26f) }))
				{
					DeleteOverride(selectedEntry);
				}
				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()
		{
			//IL_0094: 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_00b4: 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_00ea: 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_0129: 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_0192: 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_01c0: 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_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			if (SceneTraverser.IsTraversing)
			{
				EnsureStyles();
				int total = SceneTraverser.Total;
				int processed = SceneTraverser.Processed;
				float num = ((total > 0) ? Mathf.Clamp01((float)processed / (float)total) : 0f);
				float num2 = (Time.realtimeSinceStartup - SceneTraverser.StartedAt) / 60f;
				float num3 = GUIHelper.Scaled(480f);
				float num4 = GUIHelper.Scaled(74f);
				float num5 = ((float)Screen.width - num3) * 0.5f;
				float num6 = GUIHelper.Scaled(16f);
				float num7 = GUIHelper.Scaled(10f);
				GUI.color = new Color(0.05f, 0.05f, 0.06f, 0.88f);
				GUI.DrawTexture(new Rect(num5, num6, num3, num4), (Texture)(object)Fill);
				GUI.color = GUIHelper.ColBorderHi;
				GUI.DrawTexture(new Rect(num5, num6, num3, 1f), (Texture)(object)Fill);
				GUI.DrawTexture(new Rect(num5, num6 + num4 - 1f, num3, 1f), (Texture)(object)Fill);
				GUI.color = Color.white;
				GUI.Label(new Rect(num5 + num7, num6 + GUIHelper.Scaled(6f), num3 - 2f * num7, GUIHelper.Scaled(20f)), string.Format(Loc.T("Full dump: scene {0}/{1} · {2:F1} min"), processed, total, num2), _title);
				float num8 = num6 + GUIHelper.Scaled(30f);
				float num9 = GUIHelper.Scaled(10f);
				GUI.color = GUIHelper.ColBorder;
				GUI.DrawTexture(new Rect(num5 + num7, num8, num3 - 2f * num7, num9), (Texture)(object)Fill);
				GUI.color = GUIHelper.ColConfirm;
				GUI.DrawTexture(new Rect(num5 + num7, num8, (num3 - 2f * num7) * num, num9), (Texture)(object)Fill);
				GUI.color = Color.white;
				string text = SceneTraverser.CurrentScene;
				if (!string.IsNullOrEmpty(SceneTraverser.SubProgress))
				{
					text = text + "   ·   " + string.Format(Loc.T("collections {0}"), SceneTraverser.SubProgress);
				}
				GUI.contentColor = GUIHelper.ColMuted;
				GUI.Label(new Rect(num5 + num7, num8 + num9 + GUIHelper.Scaled(4f), num3 - 2f * num7, GUIHelper.Scaled(20f)), text, _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>();

		public static Canvas RootCanvas
		{
			get
			{
				if (!((Object)(object)_rootCanvas != (Object)null))
				{
					return Init();
				}
				return _rootCanvas;
			}
		}

		public static Font GameFont => _font ?? (_font = FindGameFont());

		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()
		{
			Font result = Font.CreateDynamicFontFromOSFont("Arial", 14);
			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 result;
		}

		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)
			if (!((Object)(object)EventSystem.current != (Object)null))
			{
				GameObject val = new GameObject("StitchworkEventSystem");
				Object.DontDestroyOnLoad((Object)val);
				_eventSystem = val.AddComponent<EventSystem>();
				val.AddComponent<StandaloneInputModule>();
			}
		}

		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 SetAnchored(RectTransform rt, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 anchoredPosition, Vector2 sizeDelta)
		{
			//IL_0001: 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_000f: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = anchorMin;
			rt.anchorMax = anchorMax;
			rt.pivot = pivot;
			rt.anchoredPosition = anchoredPosition;
			rt.sizeDelta = sizeDelta;
			return rt;
		}

		public static RectTransform SetTopLeft(RectTransform rt, float x, float y, float w, float h)
		{
			//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_0051: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(0f, 1f);
			rt.pivot = new Vector2(0f, 1f);
			rt.anchoredPosition = new Vector2(x, 0f - y);
			rt.sizeDelta = new Vector2(w, h);
			return rt;
		}

		public static RectTransform SetStretchTop(RectTransform rt, float height, float left = 0f, float right = 0f, float top = 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_0046: 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)
			rt.anchorMin = new Vector2(0f, 1f);
			rt.anchorMax = new Vector2(1f, 1f);
			rt.pivot = new Vector2(0.5f, 1f);
			rt.offsetMin = new Vector2(left, 0f - top - height);
			rt.offsetMax = new Vector2(0f - right, 0f - top);
			return rt;
		}

		public static RectTransform SetStretchBottom(RectTransform rt, float height, float left = 0f, float right = 0f, float bottom = 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(1f, 0f);
			rt.pivot = new Vector2(0.5f, 0f);
			rt.offsetMin = new Vector2(left, bottom);
			rt.offsetMax = new Vector2(0f - right, bottom + height);
			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>() ?? 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_0011: 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)
			ContentSizeFitter obj = go.GetComponent<ContentSizeFitter>() ?? go.AddComponent<ContentSizeFitter>();
			obj.horizontalFit = horizontal;
			obj.verticalFit = vertical;
			return obj;
		}

		public static GameObject CreateRawImage(Transform parent, string name, Texture texture, Color? tint = 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_0048: 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_0059: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RawImage obj = val.AddComponent<RawImage>();
			obj.texture = texture;
			((Graphic)obj).color = (Color)(((??)tint) ?? Color.white);
			((Graphic)obj).raycastTarget = false;
			return val;
		}

		public static GameObject CreateToggle(Transform parent, string name, bool isOn, Action<bool> onChanged, Color? bgColor = null, Color? checkColor = 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_005f: Expected O, but got Unknown
			//IL_0076: 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)
			Color color = (Color)(((??)bgColor) ?? GUIHelper.ColSurface1);
			Color value = (Color)(((??)checkColor) ?? GUIHelper.ColConfirm);
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = color;
			((Graphic)val2).raycastTarget = true;
			GameObject checkGO = CreateText(val.transform, name + "_Check", "✓", 16, value, (TextAnchor)4);
			SetStretch(checkGO.GetComponent<RectTransform>());
			checkGO.SetActive(isOn);
			Toggle val3 = val.AddComponent<Toggle>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			val3.graphic = (Graphic)(object)checkGO.GetComponent<Text>();
			val3.isOn = isOn;
			if (onChanged != null)
			{
				((UnityEvent<bool>)(object)val3.onValueChanged).AddListener((UnityAction<bool>)delegate(bool flag)
				{
					checkGO.SetActive(flag);
					onChanged(flag);
				});
			}
			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_01a3: 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_01bc: 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_0224: 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 = GUILayout.Toggle(_storyOnly, Loc.T("Story flags"), GUIHelper.ToggleStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(100f) });
			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
	{
		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 _toggleStyle;

		private static GUIStyle _textFieldStyle;

		private static int _cachedFontSize;

		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 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 _cardStyle;

		private static int _cachedCardPad;

		private static GUIStyle _cardStyleTransparent;

		private static int _cachedCardTransPad;

		private static GUIStyle _chipStyle;

		private static int _cachedChipFontSize;

		private static GUIStyle _tagStyle;

		private static int _cachedTagFontSize;

		private static GUIStyle _mutedLabelStyle;

		private static int _cachedMutedFontSize;

		private static GUIStyle _sectionHeaderStyle;

		private static int _cachedSectionFontSize;

		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 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>();

		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 ToggleStyle
		{
			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 (_toggleStyle == null || _toggleStyle.fontSize != num)
				{
					_toggleStyle = new GUIStyle(GUI.skin.toggle)
					{
						fontSize = num
					};
				}
				return _toggleStyle;
			}
		}

		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 CardStyle
		{
			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
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				int num = ScaledInt(6);
				if (_cardStyle == null || _cachedCardPad != num)
				{
					_cachedCardPad = num;
					_cardStyle = new GUIStyle(GUIStyle.none)
					{
						padding = new RectOffset(num, num, ScaledInt(4), ScaledInt(4))
					};
					_cardStyle.normal.background = MakeTex(ColSurface1);
				}
				return _cardStyle;
			}
		}

		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 TagStyle
		{
			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_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Expected O, but got Unknown
				//IL_005b: Expected O, but got Unknown
				int num = FontSize(12);
				if (_tagStyle == null || _cachedTagFontSize != num)
				{
					_cachedTagFontSize = num;
					_tagStyle = new GUIStyle(GUI.skin.button)
					{
						fontSize = num,
						padding = new RectOffset(ScaledInt(6), ScaledInt(6), ScaledInt(2), ScaledInt(2))
					};
				}
				return _tagStyle;
			}
		}

		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 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;

		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 void DrawActiveCardFill(Rect rect, Color borderColor)
		{
			//IL_0000: 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_003a: 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_0066: 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)
			GUI.color = new Color(borderColor.r * 0.2f + ColSurface.r * 0.8f, borderColor.g * 0.2f + ColSurface.g * 0.8f, borderColor.b * 0.2f + ColSurface.b * 0.8f, 0.35f);
			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 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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, (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 ApplyScaledSkin()
		{
		}

		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 LabelWidth(float baseWidth)
		{
			return Width(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();
			}
		}

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

		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)
					{
					}
				}
			}
			_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_002a: 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_007d: 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_00ab: 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_00d9: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			if (GUIHelper.IsTextFieldFocused)
			{
				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);
			}
			if (Plugin.Config.DevMode && Input.GetKeyDown(Plugin.Config.AppliqueProbeKey))
			{
				AppliquePhase0.Toggle();
			}
			AppliquePhase0.Tick();
		}

		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)
			//IL_006f: 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) && !Input.GetKeyDown(config.FullDumpKey))
			{
				return Input.GetKeyDown(config.AppliqueProbeKey);
			}
			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 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>());
			}
			for (int i = 0; i < list.Count; i++)
			{
				DrawPackRow(list, i);
			}
			GUILayout.EndScrollView();
		}

		private static void DrawPackRow(List<PackInfo> list, int i)
		{
			//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_006b: 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_0089: 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_00d6: 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_01b1: 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_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: 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_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_070e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06df: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fa: Unknown result type (might be due to invalid IL or missing references)
			PackInfo pack = list[i];
			PackInfo packInfo = PackManager.AllPacks.FirstOrDefault((PackInfo p) => string.Equals(p.Path, pack.Path, StringComparison.OrdinalIgnoreCase));
			bool flag = packInfo?.HasConditions ?? false;
			GUILayout.BeginVertical(GUIHelper.CardStyleTransparent, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = (pack.IsEnabled ? GUIHelper.ColConfirm : GUIHelper.ColSurface);
			GUI.contentColor = (pack.IsEnabled ? Color.white : GUIHelper.ColMuted);
			bool num = GUILayout.Button(pack.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 = !pack.IsEnabled;
			}
			GUIHelper.Space(4f);
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(pack.Name, GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUIHelper.Space(4f);
			GUILayout.Label(pack.IsLocal ? Loc.T("local") : Loc.T("pack@chip", "pack"), GUIHelper.ChipStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			int num2 = ConflictTracker.ShadowedCount(pack.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 value = _staged[i];
				PackInfo value2 = _staged[i - 1];
				staged[index] = value;
				staged2[index2] = value2;
			}
			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 value2 = _staged[i];
				PackInfo value = _staged[i + 1];
				staged[index2] = value2;
				staged3[index] = value;
			}
			GUI.enabled = true;
			GUIHelper.Space(2f);
			if (packInfo != null)
			{
				bool flag2 = _conditionsOpen.Contains(pack.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(pack.Path);
					}
					else
					{
						_conditionsOpen.Add(pack.Path);
					}
				}
				GUI.backgroundColor = backgroundColor2;
				GUI.contentColor = Color.white;
			}
			GUILayout.EndHorizontal();
			List<string> list2 = new List<string>();
			if (!string.IsNullOrEmpty(pack.Author))
			{
				list2.Add(string.Format(Loc.T("by {0}"), pack.Author));
			}
			if (!string.IsNullOrEmpty(pack.Version))
			{
				list2.Add("v" + pack.Version);
			}
			if (!string.IsNullOrEmpty(pack.Description))
			{
				string item = ((pack.Description.Length > 55) ? (pack.Description.Substring(0, 52) + "…") : pack.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 = pack.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(pack.Path, "Sprites")))
				{
					list3.Add(Loc.T("sprites"));
				}
				if (Directory.Exists(Path.Combine(pack.Path, "Spritesheets")))
				{
					list3.Add(Loc.T("sheets"));
				}
				if (Directory.Exists(Path.Combine(pack.Path, "Sounds")))
				{
					list3.Add(Loc.T("audio"));
				}
				if (Directory.Exists(Path.Combine(pack.Path, "Videos")))
				{
					list3.Add(Loc.T("video"));
				}
				if (Directory.Exists(Path.Combine(pack.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 (packInfo != null && _conditionsOpen.Contains(pack.Path))
			{
				GUIHelper.DrawSeparator();
				DrawConditionEditor(packInfo);
			}
			GUILayout.EndVertical();
			Rect lastRect = GUILayoutUtility.GetLastRect();
			if (pack.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>());
			}
		}
	}
	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 string _cachedDominantPackName = null;

		private static int _cachedDominantPackPercent = 0;

		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_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Expected O, but got Unknown
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: 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 text4 = text3;
							for (int i = 0; i < allPacks.Count; i++)
							{
								if (string.Equals(allPacks[i].Path, text3, StringComparison.OrdinalIgnoreCase))
								{
									text4 = allPacks[i].Name;
									break;
								}
							}
							int num5 = Mathf.RoundToInt(num4 * 100f);
							text2 = $"{text4} ({num5}%)";
							_cachedDominantPackName = text4;
							_cachedDominantPackPercent = num5;
						}
					}
				}
			}
			string text5 = null;
			int atlasRTCount = SpriteLoader.AtlasRTCount;
			if (atlasRTCount > 0)
			{
				int num6 = (int)(SpriteLoader.AtlasVramBytes / 1048576);
				text5 = 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 (text5 != null)
			{
				stringBuilder.Append("  ·  ").Append(text5);
			}
			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()
		{
			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;
				}
				_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_0355: 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_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: 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)
			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();
			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 flag2 = item == _selectedSprite;
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				if (flag2)
				{
					GUI.contentColor = new Color(1f, 1f, 0.5f);
				}
				if (GUILayout.Button(item, GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) }))
				{
					_selectedSprite = (flag2 ? "" : item);
				}
				if (flag2)
				{
					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 EditSprite(T2DSceneEntry entry, string spriteName)
		{
			string text;
			string text2;
			string text3;
			string text4;
			if (entry.IsT2D)
			{
				text = Path.Combine(SpriteLoader.LoadPath, "T2D", entry.CleanName);
				text2 = Path.Combine(text, spriteName + ".png");
				text3 = Path.Combine(T2DDumper.DumpPath, entry.CleanName, spriteName + ".png");
				text4 = entry.CleanName + "/" + spriteName;
			}
			else
			{
				string text5 = T2DUtil.SanitizeForFilesystem(entry.RawName);
				text = Path.Combine(SpriteLoader.LoadPath, "T2D", "_standalone");
				text2 = Path.Combine(text, text5 + ".png");
				text3 = Path.Combine(T2DDumper.DumpPath, text5 + ".png");
				text4 = "_standalone/" + text5;
			}
			if (!File.Exists(text2))
			{
				if (!File.Exists(text3))
				{
					Sprite val = T2DLoader.FindSceneSprite(entry.RawName, spriteName);
					if ((Object)(object)val == (Object)null)
					{
						Plugin.Logger.LogError((object)("[T2DTex] Cannot find sprite '" + spriteName + "' to dump"));
						return;
					}
					T2DDumper.HandleDump(val);
				}
				if (!File.Exists(text3))
				{
					Plugin.Logger.LogError((object)("[T2DTex] Dump failed for '" + text4 + "'"));
					return;
				}
				IOUtil.EnsureDirectoryExists(text);
				File.Copy(text3, text2, overwrite: true);
			}
			Process.Start(text2);
		}

		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(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 && !_entries.Any((T2DSceneEntry e) => e.RawName == _selected.RawName))
			{
				_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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: 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_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: 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;
				_plan = TextMerger.Scan(_selected);
				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 = "";
				}
			}
			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();
		}

		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_0196: 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_01af: 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_0214: 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_0269: 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_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			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.");
			}
			GUI.enabled = plan.Resolved;
			if (GUILayout.Button(Loc.T("Apply"), GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUIHelper.Height(24f),
				GUIHelper.Width(110f)
			}))
			{
				(int Files, int Keys, string Backup) tuple = TextMerger.Apply(plan);
				int item = tuple.Files;
				int item2 = tuple.Keys;
				string item3 = tuple.Backup;
				_plan = null;
				_status = ((item == 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}"), item2, item, item3 ?? "—"));
			}
			GUI.enabled = true;
			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
		}

		private enum Cat
		{
			Tk2dAnim,
			T2DWorld
		}

		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 const int CatCount = 2;

		private static readonly bool[] _filterOn = new bool[2] { true, 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>();

		public static bool Active { get; private set; }

		private static float PreviewBox => S(42f);

		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_0009: 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)
			if (c != Cat.Tk2dAnim)
			{
				return GUIHelper.ColPop2;
			}
			return GUIHelper.ColConfirm;
		}

		private static string CatLabel(Cat c)
		{
			if (c != Cat.Tk2dAnim)
			{
				return Loc.T("T2D@pick", "T2D");
			}
			return Loc.T("tk2d anim@pick", "tk2d anim");
		}

		public static void Enter(Preset preset)
		{
			if (!Active)
			{
				Active = true;
				_devHubWasOpen = Plugin.ShowDevHub;
				Plugin.ShowDevHub = false;
				_filterOn[0] = preset == Preset.Tk2d;
				_filterOn[1] = preset == Preset.T2D;
				_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();
			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)("[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_00c0: 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_00c8: 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)
			{
				_pendingComplete = _hover;
			}
			else
			{
				_invalidClickUntil = Time.realtimeSinceStartup + 1.2f;
			}
		}

		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)
			_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])
			{
				return;
			}
			_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);
					}
				}
			}
		}

		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_019c: 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_01a8: 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_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_0227: 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)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: 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_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: 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_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: 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_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0619: 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_03f4: 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_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: 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_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: 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_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: 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_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: 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_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c2: 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)
			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), val3.x, val3.y), val2, GUIHelper.LabelStyle);
			GUI.contentColor = Color.white;
			_chipRects.Clear();
			float num = ((Rect)(ref r)).yMax + S(5f);
			float num2 = S(8.5f);
			string[] array = new string[2];
			Vector2[] array2 = (Vector2[])(object)new Vector2[2];
			float num3 = 0f;
			for (int i = 0; i < 2; 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 < 2; 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), array2[j].x, array2[j].y), array[j], GUIHelper.LabelStyle);
				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_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: 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), array[j].x, array[j].y), labels[j], GUIHelper.LabelStyle);
				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)
			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));
			}
			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_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			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;
			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)
			{
				Process.Start("explorer.exe", "/select,\"" + text + "\"");
			}
			else
			{
				Process.Start(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 _showGlossary = false;

		private static string _glossarySearch = "";

		private static GUIStyle _glossaryTextStyle;

		private static int _glossaryFontSize;

		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);
		}

		public static void Draw()
		{
			//IL_0088: 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_018d: 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_019c: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			DrawHealthStrip();
			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();
		}

		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>();
			ScanTextDir(DialogueHandler.TextLoadPath, list5);
			foreach (string pluginPackPath2 in Plugin.PluginPackPaths)
			{
				ScanTextDir(Path.Combine(pluginPackPath2, "Text"), list5);
			}
			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_)
		{
			if (!Directory.Exists(textRoot))
			{
				return;
			}
			string[] files = Directory.GetFiles(textRoot, "*.yml", SearchOption.AllDirectories);
			foreach (string text in files)
			{
				string rel = text.Substring(textRoot.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).Replace('\\', '/');
				if (out_.All((FileEntry e) => e.Name != rel))
				{
					out_.Add(new FileEntry
					{
						Name = rel,
						Status = FileStatus.OnDisk
					});
				}
			}
		}
	}
	public static class DebugPillar
	{
		private static Vector2 _scroll;

		private static float _fullDumpArmedAt = -1f;

		private const float FullDumpArmWindowSec = 4f;

		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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_0141: 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_0155: 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)
			GUILayout.Label(Loc.T("Dumping"), GUIHelper.SectionHeaderStyle, Array.Empty<GUILayoutOption>());
			bool dumpSprites = Plugin.Config.DumpSprites;
			bool flag = GUILayout.Toggle(dumpSprites, Loc.T("Dump sprites on scene load"), GUIHelper.ToggleStyle, Array.Empty<GUILayoutOption>());
			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 in the game, minutes of stalls, abandons this play session. Save first.")), 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 string _tintPath = "Hornet";

		internal static void SwitchToT2DBrowser()
		{
			_tab = 1;
		}

		internal static void SwitchToAnimation()
		{
			_tab = 0;
		}

		public static void Draw()
		{
			T2DLoader.IsT2DLogActive = _tab == 1 || _tab == 2;
			bool flag = Plugin.Config?.DevMode ?? false;
			if (!flag && _tab == 3)
			{
				_tab = 0;
			}
			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 (flag && GUILayout.Toggle(_tab == 3, "Materials", 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 && flag)
			{
				DrawMaterials();
			}
		}

		private static void DrawMaterials()
		{
			//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_0050: 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_0154: 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_0195: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_0131: 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_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: 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_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: 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_0348: 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_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: 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_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			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("Tint Override — Proof of Concept", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(2f);
			GUI.contentColor = new Color(0.6f, 0.6f, 0.6f);
			GUILayout.Label("Apply a per-renderer MaterialPropertyBlock that zeroes the tint surface\n(_AmbientLerp, _CanLerpAmbient, _CanDesaturate, _Desaturation,\n_CanHueShift, _HueShift, _Color=white, _CharacterTintColor=white).\nHit-flash / silk-damage feedback is preserved.\nTests, per docs/material-tint-investigation.md:\n  • mechanism + ambient layer — type 'Hornet' in a tinted scene\n    (Bone_East: warm cast, Peak: cool cast). Body should snap\n    to its raw PNG colour with no scene wash.\n  • transient effects — trigger any reproducible custom-shader\n    flicker (lightning bolts, dream-blink, charged attack glow);\n    type its path substring; if cast persists despite Apply,\n    a per-frame controller is overwriting our MPB and the\n    production design needs a LateUpdate re-apply tracker.", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			GUIHelper.Space(6f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Path contains:", GUIHelper.LabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Width(100f) });
			_tintPath = GUIHelper.TextField("Stitchwork.MaterialNeutralizer.Path", _tintPath, GUILayout.ExpandWidth(true), GUIHelper.Height(22f));
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Apply to matching", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
			{
				MaterialNeutralizer.ApplyToRenderersByPath(_tintPath);
			}
			if (GUILayout.Button("Revert matching", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
			{
				MaterialNeutralizer.RevertByPath(_tintPath);
			}
			GUI.contentColor = GUIHelper.ColWarn;
			if (GUILayout.Button("Revert ALL overrides", GUIHelper.ButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUIHelper.Height(24f) }))
			{
				MaterialNeutralizer.RevertAll();
			}
			GUI.contentColor = Color.white;
			GUILayout.EndHorizontal();
			GUIHelper.Space(4f);
			GUI.contentColor = new Color(0.55f, 0.55f, 0.65f);
			GUILayout.Label($"Currently overridden: {MaterialNeutralizer.OverriddenCount} renderer(s)", GUIHelper.LabelStyle, Array.Empty<GUILayoutOption>());
			GUI.contentColor = Color.white;
			if (!string.IsNullOrEmpty(MaterialNeutralizer.LastStatus))
			{
				GUI.contentColor = new Color(0.4f, 1f, 0.4f);
				GUILayout.Label("Override status: " + MaterialNeutralizer.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_00f9: 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_0147: 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_034a: 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_021a: 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_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: 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_026e: 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_0401: 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_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: 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 = 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;
			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;
			}
		}
	}
}