using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using I2.Loc;
using Microsoft.CodeAnalysis;
using TCGShopExpansionMod.Handlers;
using TCGShopExpansionMod0703Patch.Patches;
using TMPro;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[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("TCGShopExpansionMod0703Patch")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+89938e8139244489dbcd9d0ac79611e738764844")]
[assembly: AssemblyProduct("TCGShopExpansionMod 0.70.3 Compatibility Patch")]
[assembly: AssemblyTitle("TCGShopExpansionMod0703Patch")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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;
		}
	}
}
namespace TCGShopExpansionMod0703Patch
{
	[DefaultExecutionOrder(32760)]
	internal sealed class AlbumHoFoilRepairBehaviour : MonoBehaviour
	{
		private CardUI? _cardUi;

		private Coroutine? _endOfFrameLoop;

		public static void EnsureOn(CardUI cardUi)
		{
			if (!((Object)(object)cardUi == (Object)null))
			{
				AlbumHoFoilRepairBehaviour albumHoFoilRepairBehaviour = ((Component)cardUi).GetComponent<AlbumHoFoilRepairBehaviour>();
				if ((Object)(object)albumHoFoilRepairBehaviour == (Object)null)
				{
					albumHoFoilRepairBehaviour = ((Component)cardUi).gameObject.AddComponent<AlbumHoFoilRepairBehaviour>();
				}
				albumHoFoilRepairBehaviour._cardUi = cardUi;
				((Behaviour)albumHoFoilRepairBehaviour).enabled = true;
				if (albumHoFoilRepairBehaviour._endOfFrameLoop == null && ((Behaviour)albumHoFoilRepairBehaviour).isActiveAndEnabled)
				{
					albumHoFoilRepairBehaviour._endOfFrameLoop = ((MonoBehaviour)albumHoFoilRepairBehaviour).StartCoroutine(albumHoFoilRepairBehaviour.EndOfFrameRepairLoop());
				}
			}
		}

		public static void DisableOn(CardUI cardUi)
		{
			if (!((Object)(object)cardUi == (Object)null))
			{
				AlbumHoFoilRepairBehaviour component = ((Component)cardUi).GetComponent<AlbumHoFoilRepairBehaviour>();
				if ((Object)(object)component != (Object)null)
				{
					((Behaviour)component).enabled = false;
				}
			}
		}

		private void OnEnable()
		{
			if ((Object)(object)_cardUi != (Object)null && _endOfFrameLoop == null)
			{
				_endOfFrameLoop = ((MonoBehaviour)this).StartCoroutine(EndOfFrameRepairLoop());
			}
		}

		private void OnDisable()
		{
			if (_endOfFrameLoop != null)
			{
				((MonoBehaviour)this).StopCoroutine(_endOfFrameLoop);
				_endOfFrameLoop = null;
			}
		}

		private void LateUpdate()
		{
			if ((Object)(object)_cardUi == (Object)null)
			{
				((Behaviour)this).enabled = false;
			}
			else
			{
				TetramonOverlay0703Patches.RepairAlbumHoFoilMainTex(_cardUi);
			}
		}

		private IEnumerator EndOfFrameRepairLoop()
		{
			WaitForEndOfFrame wait = new WaitForEndOfFrame();
			while (((Behaviour)this).enabled && (Object)(object)_cardUi != (Object)null)
			{
				yield return wait;
				if ((Object)(object)_cardUi == (Object)null)
				{
					yield break;
				}
				TetramonOverlay0703Patches.RepairAlbumHoFoilMainTex(_cardUi);
			}
			_endOfFrameLoop = null;
		}
	}
	internal static class ArtExpanderBridge
	{
		private const BindingFlags StaticAny = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private const BindingFlags InstanceAny = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static bool _initialized;

		private static bool _available;

		private static readonly List<object> ArtCaches = new List<object>();

		private static MethodInfo? _resolveArtPath;

		private static MethodInfo? _loadSprite;

		private static bool _loggedAssetNameDump;

		private static readonly ECardBorderType[] BorderFallbackOrder;

		public static void TryInitialize()
		{
			EnsureInitialized();
		}

		public static void DumpBackAssetNames()
		{
			if (_loggedAssetNameDump || !EnsureInitialized())
			{
				return;
			}
			_loggedAssetNameDump = true;
			try
			{
				int num = 0;
				foreach (object artCache in ArtCaches)
				{
					string[] allAssetNames = GetAllAssetNames(artCache);
					if (allAssetNames == null)
					{
						continue;
					}
					num++;
					int num2 = 0;
					for (int i = 0; i < allAssetNames.Length; i++)
					{
						string text = allAssetNames[i].ToLowerInvariant();
						if (text.Contains("back") || text.Contains("pokemon") || text.Contains("sleeve") || text.Contains("reverse"))
						{
							Plugin.Log.LogWarning((object)$"BundleBackAsset[{num}]: {allAssetNames[i]}");
							num2++;
						}
					}
					Plugin.Log.LogWarning((object)$"ArtExpander bundle cache #{num}: {allAssetNames.Length} assets, {num2} back-like names.");
				}
				if (num == 0)
				{
					Plugin.Log.LogWarning((object)"DumpBackAssetNames: no enumerable bundle caches found.");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("DumpBackAssetNames failed: " + ex.Message));
			}
		}

		public static Sprite? LoadSpriteByBundlePath(string assetPath)
		{
			if (string.IsNullOrEmpty(assetPath) || !EnsureInitialized() || _loadSprite == null)
			{
				return null;
			}
			for (int i = 0; i < ArtCaches.Count; i++)
			{
				object? obj = _loadSprite.Invoke(ArtCaches[i], new object[1] { assetPath });
				Sprite val = (Sprite)((obj is Sprite) ? obj : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static string[]? GetAllAssetNames(object cache)
		{
			object obj = cache.GetType().GetField("_bundleLoader", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(cache);
			if (obj == null)
			{
				return null;
			}
			return obj.GetType().GetMethod("GetAllAssetNames", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(obj, Array.Empty<object>()) as string[];
		}

		public static Sprite? LoadCardArt(CardData cardData)
		{
			//IL_0056: 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_0059: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			if (cardData == null || !EnsureInitialized() || !_available)
			{
				return null;
			}
			Sprite val = TryLoadFromCaches(cardData);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (cardData.isFoil)
			{
				CardData obj = CloneCardData(cardData);
				obj.isFoil = false;
				val = TryLoadFromCaches(obj);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			for (int i = 0; i < BorderFallbackOrder.Length; i++)
			{
				ECardBorderType val2 = BorderFallbackOrder[i];
				if (val2 != cardData.borderType)
				{
					CardData obj2 = CloneCardData(cardData);
					obj2.borderType = val2;
					val = TryLoadFromCaches(obj2);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static Sprite? TryLoadFromCaches(CardData cardData)
		{
			for (int i = 0; i < ArtCaches.Count; i++)
			{
				Sprite val = LoadFromCache(ArtCaches[i], cardData);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static CardData CloneCardData(CardData source)
		{
			//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_000d: Expected O, but got Unknown
			CardData val = new CardData();
			val.CopyData(source);
			return val;
		}

		private static Sprite? LoadFromCache(object cache, CardData cardData)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			if (_resolveArtPath == null || _loadSprite == null)
			{
				return null;
			}
			object[] array = _resolveArtPath.GetParameters().Length switch
			{
				5 => new object[5] { cardData.monsterType, cardData.borderType, cardData.expansionType, cardData.isDestiny, cardData.isFoil }, 
				4 => new object[4] { cardData.monsterType, cardData.borderType, cardData.expansionType, cardData.isDestiny }, 
				_ => null, 
			};
			if (array == null)
			{
				return null;
			}
			if (!(_resolveArtPath.Invoke(cache, array) is string text) || string.IsNullOrEmpty(text))
			{
				return null;
			}
			object? obj = _loadSprite.Invoke(cache, new object[1] { text });
			return (Sprite?)((obj is Sprite) ? obj : null);
		}

		private static bool EnsureInitialized()
		{
			if (_initialized)
			{
				return _available;
			}
			_initialized = true;
			try
			{
				Type type = FindArtExpanderPluginType();
				if (type == null)
				{
					Plugin.Log.LogWarning((object)"ArtExpander bridge: Plugin type not found.");
					return false;
				}
				CollectArtCaches(type);
				if (ArtCaches.Count == 0)
				{
					Plugin.Log.LogWarning((object)"ArtExpander bridge: no ArtCache fields found.");
					return false;
				}
				Type type2 = ArtCaches[0].GetType();
				_resolveArtPath = FindResolveArtPathMethod(type2);
				_loadSprite = type2.GetMethod("LoadSprite", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
				_available = _resolveArtPath != null && _loadSprite != null;
				if (_available)
				{
					Plugin.Log.LogInfo((object)$"ArtExpander bridge ready ({ArtCaches.Count} cache(s), cardart.assets).");
				}
				else
				{
					Plugin.Log.LogWarning((object)$"ArtExpander bridge: methods missing (ResolveArtPath={_resolveArtPath != null}, LoadSprite={_loadSprite != null}).");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("ArtExpander bridge init failed: " + ex.Message));
				_available = false;
			}
			return _available;
		}

		private static MethodInfo? FindResolveArtPathMethod(Type cacheType)
		{
			MethodInfo[] methods = cacheType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (!(methodInfo.Name != "ResolveArtPath"))
				{
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (parameters.Length >= 4 && parameters[0].ParameterType == typeof(EMonsterType))
					{
						return methodInfo;
					}
				}
			}
			return null;
		}

		private static Type? FindArtExpanderPluginType()
		{
			Type type = Type.GetType("ArtExpander.Plugin, ArtExpander");
			if (type != null)
			{
				return type;
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (string.Equals(assembly.GetName().Name, "ArtExpander", StringComparison.OrdinalIgnoreCase))
				{
					Type type2 = assembly.GetType("ArtExpander.Plugin", throwOnError: false);
					if (type2 != null)
					{
						return type2;
					}
				}
			}
			return null;
		}

		private static void CollectArtCaches(Type pluginType)
		{
			string[] array = new string[3] { "art_cache", "art_cache_bundle", "art_cache_directory" };
			for (int i = 0; i < array.Length; i++)
			{
				TryAddCacheField(pluginType, array[i]);
			}
			FieldInfo[] fields = pluginType.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (IsArtCacheField(fieldInfo))
				{
					AddCacheValue(fieldInfo.GetValue(null));
				}
			}
		}

		private static void TryAddCacheField(Type pluginType, string fieldName)
		{
			FieldInfo field = pluginType.GetField(fieldName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(field == null))
			{
				AddCacheValue(field.GetValue(null));
			}
		}

		private static void AddCacheValue(object? cache)
		{
			if (cache != null && !ArtCaches.Contains(cache))
			{
				ArtCaches.Add(cache);
			}
		}

		private static bool IsArtCacheField(FieldInfo field)
		{
			if (!string.Equals(field.FieldType.Name, "ArtCache", StringComparison.Ordinal))
			{
				return string.Equals(field.FieldType.FullName, "ArtExpander.Core.ArtCache", StringComparison.Ordinal);
			}
			return true;
		}

		static ArtExpanderBridge()
		{
			ECardBorderType[] array = new ECardBorderType[7];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			BorderFallbackOrder = (ECardBorderType[])(object)array;
		}
	}
	internal static class Card3dInteractableRegistry
	{
		private static readonly Dictionary<Card3dUIGroup, InteractableCard3d> ByCard3d = new Dictionary<Card3dUIGroup, InteractableCard3d>();

		public static void Register(Card3dUIGroup? card3d, InteractableCard3d? interactable)
		{
			if (!((Object)(object)card3d == (Object)null))
			{
				if ((Object)(object)interactable == (Object)null)
				{
					ByCard3d.Remove(card3d);
				}
				else
				{
					ByCard3d[card3d] = interactable;
				}
			}
		}

		public static void UnregisterInteractable(InteractableCard3d interactable)
		{
			if (!((Object)(object)interactable?.m_Card3dUI == (Object)null))
			{
				ByCard3d.Remove(interactable.m_Card3dUI);
			}
		}

		public static InteractableCard3d? FindForCardUi(CardUI cardUi)
		{
			if ((Object)(object)cardUi == (Object)null)
			{
				return null;
			}
			InteractableCard3d componentInParent = ((Component)cardUi).GetComponentInParent<InteractableCard3d>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent;
			}
			object? value = CardUiFieldAccess.GetValue(cardUi, "m_Card3dUIGroup");
			Card3dUIGroup val = (Card3dUIGroup)((value is Card3dUIGroup) ? value : null);
			if (val != null && ByCard3d.TryGetValue(val, out var value2))
			{
				return value2;
			}
			return null;
		}
	}
	internal static class Card3dUiGroupAccess
	{
		private const BindingFlags InstanceAny = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

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

		public static object? GetValue(Card3dUIGroup group, string fieldName)
		{
			return GetField(fieldName)?.GetValue(group);
		}

		private static FieldInfo? GetField(string fieldName)
		{
			if (Fields.TryGetValue(fieldName, out var value))
			{
				return value;
			}
			FieldInfo field = typeof(Card3dUIGroup).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				Fields[fieldName] = field;
			}
			return field;
		}
	}
	internal static class CardExtrasCacheAccess
	{
		private const string PackStackBackSpriteName = "T_CardBackMesh";

		private const string UiCardBackSpriteName = "CardBack";

		private const string CardExtrasFolderName = "CardExtrasImages";

		private static readonly FieldInfo? CardExtrasImagesCacheField = typeof(NewSwappingHandler).Assembly.GetType("TCGShopExpansionMod.Handlers.CacheHandler")?.GetField("cardExtrasImagesCache", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo? OriginalCardExtrasImagesCacheField = typeof(NewSwappingHandler).Assembly.GetType("TCGShopExpansionMod.Handlers.CacheHandler")?.GetField("originalCardExtrasImagesCache", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo? OriginalCardBackTextureField = typeof(NewSwappingHandler).Assembly.GetType("TCGShopExpansionMod.Handlers.CacheHandler")?.GetField("originalCardBackTexture", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

		private static Sprite? _uiCardBackSprite;

		private static Sprite? _stackBackMeshSprite;

		private static Sprite? _pokemonUiBackSprite;

		private static bool _loggedUiCardBackSource;

		private static bool _loggedStackBackSource;

		private static bool _triedPokemonUiBack;

		public static Sprite? TryGetPokemonUiBackSprite()
		{
			if ((Object)(object)_pokemonUiBackSprite != (Object)null)
			{
				return _pokemonUiBackSprite;
			}
			if (_triedPokemonUiBack)
			{
				return null;
			}
			_triedPokemonUiBack = true;
			string text = Path.Combine(Paths.PluginPath, "TextureReplacer", "objects_textures", "CardBack.png");
			_pokemonUiBackSprite = TryLoadSpriteFromPath(text, "PokemonCardBack");
			if ((Object)(object)_pokemonUiBackSprite != (Object)null)
			{
				Plugin.Log.LogInfo((object)("Pokemon UI card back resolved from TextureReplacer: " + text));
			}
			else
			{
				Plugin.Log.LogWarning((object)("Pokemon UI card back not found at " + text + "; falling back to ExpansionMod CardBack."));
			}
			return _pokemonUiBackSprite;
		}

		public static Sprite? TryGetCachedSprite(string spriteName)
		{
			Sprite val = TryGetSpriteFromCacheList(CardExtrasImagesCacheField, spriteName);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Sprite val2 = TryGetSpriteFromCacheList(OriginalCardExtrasImagesCacheField, spriteName);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			if (spriteName == "T_CardBackMesh")
			{
				object? obj = OriginalCardBackTextureField?.GetValue(null);
				Sprite val3 = (Sprite)((obj is Sprite) ? obj : null);
				if (val3 != null)
				{
					return val3;
				}
			}
			return TryLoadSpriteFromDisk(spriteName);
		}

		public static Sprite? TryGetUiCardBackSprite()
		{
			if ((Object)(object)_uiCardBackSprite != (Object)null)
			{
				return _uiCardBackSprite;
			}
			_uiCardBackSprite = TryGetCachedSprite("CardBack");
			if ((Object)(object)_uiCardBackSprite != (Object)null && !_loggedUiCardBackSource)
			{
				_loggedUiCardBackSource = true;
				Plugin.Log.LogInfo((object)$"Pack UI card back resolved: {"CardBack"} ({((Object)_uiCardBackSprite).name})");
			}
			return _uiCardBackSprite;
		}

		public static Sprite? TryGetStackBackMeshSprite()
		{
			if ((Object)(object)_stackBackMeshSprite != (Object)null)
			{
				return _stackBackMeshSprite;
			}
			_stackBackMeshSprite = TryGetCachedSprite("T_CardBackMesh");
			if ((Object)(object)_stackBackMeshSprite != (Object)null && !_loggedStackBackSource)
			{
				_loggedStackBackSource = true;
				Plugin.Log.LogInfo((object)$"Pack stack mesh back resolved: {"T_CardBackMesh"} ({((Object)_stackBackMeshSprite).name})");
			}
			return _stackBackMeshSprite;
		}

		private static Sprite? TryGetSpriteFromCacheList(FieldInfo? cacheField, string spriteName)
		{
			if (!(cacheField?.GetValue(null) is List<Sprite> list))
			{
				return null;
			}
			return NewSwappingHandler.TryGetSpriteFromCache(list, spriteName);
		}

		private static Sprite? TryLoadSpriteFromDisk(string spriteName)
		{
			string cardExtrasImagesDirectory = GetCardExtrasImagesDirectory();
			if (cardExtrasImagesDirectory == null)
			{
				return null;
			}
			return TryLoadSpriteFromPath(Path.Combine(cardExtrasImagesDirectory, spriteName + ".png"), spriteName);
		}

		private static Sprite? TryLoadSpriteFromPath(string pngPath, string spriteName)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_004f: 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 (!File.Exists(pngPath))
			{
				return null;
			}
			try
			{
				byte[] array = File.ReadAllBytes(pngPath);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array))
				{
					Object.Destroy((Object)(object)val);
					return null;
				}
				((Object)val).name = spriteName;
				Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)obj).name = spriteName;
				return obj;
			}
			catch
			{
				return null;
			}
		}

		private static string? GetCardExtrasImagesDirectory()
		{
			Type type = AccessToolsTypeByName("TCGShopExpansionMod.Patches.PlayerPatches");
			if (type == null)
			{
				return null;
			}
			if (type.GetField("cardExtrasImages", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) is string text && !string.IsNullOrEmpty(text))
			{
				return text.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			}
			if (type.GetField("customExpansionPackImages", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(null) is string text2 && !string.IsNullOrEmpty(text2))
			{
				return Path.Combine(text2.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), "CardExtrasImages");
			}
			return null;
		}

		private static Type? AccessToolsTypeByName(string name)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType(name, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			return null;
		}
	}
	internal static class CardOpeningSequenceFieldAccess
	{
		private const BindingFlags InstanceAny = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

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

		public static object? GetValue(CardOpeningSequence sequence, string fieldName)
		{
			return GetField(fieldName)?.GetValue(sequence);
		}

		public static void SetValue(CardOpeningSequence sequence, string fieldName, object? value)
		{
			GetField(fieldName)?.SetValue(sequence, value);
		}

		private static FieldInfo? GetField(string fieldName)
		{
			if (Fields.TryGetValue(fieldName, out var value))
			{
				return value;
			}
			FieldInfo field = typeof(CardOpeningSequence).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				Fields[fieldName] = field;
			}
			return field;
		}
	}
	internal static class CardUiDisplayContext
	{
		public static Card3dUIGroup? ResolveCard3dGroup(CardUI cardUi)
		{
			if ((Object)(object)cardUi == (Object)null)
			{
				return null;
			}
			object? value = CardUiFieldAccess.GetValue(cardUi, "m_Card3dUIGroup");
			Card3dUIGroup val = (Card3dUIGroup)((value is Card3dUIGroup) ? value : null);
			if (val != null)
			{
				return val;
			}
			return ((Component)cardUi).GetComponentInParent<Card3dUIGroup>();
		}

		public static bool IsBinderAlbumCard(CardUI cardUi)
		{
			if ((Object)(object)cardUi == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)cardUi).GetComponentInParent<BinderPageGrp>() != (Object)null)
			{
				return true;
			}
			Card3dUIGroup? obj = ResolveCard3dGroup(cardUi);
			if ((Object)(object)((obj != null) ? ((Component)obj).GetComponentInParent<BinderPageGrp>() : null) != (Object)null)
			{
				return true;
			}
			InteractableCard3d val = Card3dInteractableRegistry.FindForCardUi(cardUi);
			if ((Object)(object)val != (Object)null)
			{
				if (!val.m_IsCardAlbumCard)
				{
					return (Object)(object)val.m_CollectionBinderFlipAnimCtrl != (Object)null;
				}
				return true;
			}
			return false;
		}

		public static bool ShouldUseRotatableWorldCardBack(CardUI cardUi)
		{
			if ((Object)(object)cardUi == (Object)null || IsFlatAlbumOrBinderCard(cardUi))
			{
				return false;
			}
			if (PackOpeningState.IsPackOpeningInProgress() || PackOpeningState.IsFanRowVisible())
			{
				return false;
			}
			if ((Object)(object)ResolveCard3dGroup(cardUi) == (Object)null)
			{
				return false;
			}
			InteractableCard3d val = Card3dInteractableRegistry.FindForCardUi(cardUi);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (val.m_IsCardAlbumCard || (Object)(object)val.m_CollectionBinderFlipAnimCtrl != (Object)null)
			{
				return false;
			}
			return val.IsDisplayedOnShelf();
		}

		public static bool IsFlatAlbumOrBinderCard(CardUI cardUi)
		{
			if (IsBinderAlbumCard(cardUi))
			{
				return true;
			}
			InteractableCard3d val = Card3dInteractableRegistry.FindForCardUi(cardUi);
			if ((Object)(object)val != (Object)null)
			{
				if (!val.m_IsCardAlbumCard)
				{
					return (Object)(object)val.m_CollectionBinderFlipAnimCtrl != (Object)null;
				}
				return true;
			}
			return false;
		}
	}
	internal static class CardUiFieldAccess
	{
		private const BindingFlags InstanceAny = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

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

		public static object? GetValue(CardUI cardUi, string fieldName)
		{
			return GetField(fieldName)?.GetValue(cardUi);
		}

		private static FieldInfo? GetField(string fieldName)
		{
			if (Fields.TryGetValue(fieldName, out var value))
			{
				return value;
			}
			FieldInfo field = typeof(CardUI).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				Fields[fieldName] = field;
			}
			return field;
		}
	}
	internal static class CashRegisterTmpRepair
	{
		private const int DefaultHudImageQueue = 3005;

		private static bool _loggedQueueSample;

		public static void RepairHierarchy(Transform? root, string reason)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			PhoneFontMaterialSnapshot.CaptureIfNeeded();
			int num = ResolveMaxImageRenderQueue(root);
			int num2 = 0;
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && RepairLabel(val, num))
				{
					num2++;
				}
			}
			PhoneCanvasRepair.EnsurePhoneCanvasesReady(root);
			if (!_loggedQueueSample)
			{
				_loggedQueueSample = true;
				Plugin.Log.LogInfo((object)$"Cash/credit TMP repair sample: maxImageQueue={num}, labels={num2}, reason={reason}.");
			}
			else
			{
				Plugin.Log.LogInfo((object)$"Cash/credit TMP repair ({reason}): {num2} label(s) under '{((Object)root).name}'.");
			}
		}

		private static int ResolveMaxImageRenderQueue(Transform root)
		{
			int num = 3005;
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Material val2 = ((Graphic)val).materialForRendering ?? ((Graphic)val).material;
					if ((Object)(object)val2 != (Object)null && val2.renderQueue > num)
					{
						num = val2.renderQueue;
					}
				}
			}
			return num;
		}

		private static bool RepairLabel(TextMeshProUGUI label, int targetQueue)
		{
			//IL_0091: 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_00a3: 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_00b5: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			TMP_FontAsset font = ((TMP_Text)label).font;
			if ((Object)(object)font == (Object)null)
			{
				return false;
			}
			Material val = ((TMP_Text)label).fontMaterial;
			if ((Object)(object)val != (Object)null && ((Object)val).name != null && ((Object)val).name.StartsWith("PhoneLabel_", StringComparison.Ordinal))
			{
				((TMP_Text)label).fontMaterial = null;
				val = null;
			}
			Material val2 = (((Object)(object)val != (Object)null && ((Object)val).name != null && ((Object)val).name.StartsWith("HudLabel_", StringComparison.Ordinal)) ? val : (((TMP_Text)label).fontMaterial = PhoneFontMaterialSnapshot.CreateHudLabelMaterial(font)));
			int num = targetQueue + 1;
			if (val2.renderQueue < num)
			{
				val2.renderQueue = num;
			}
			if (((Graphic)label).color.a < 0.05f || (((Graphic)label).color.r < 0.05f && ((Graphic)label).color.g < 0.05f && ((Graphic)label).color.b < 0.05f))
			{
				((Graphic)label).color = Color.white;
			}
			((TMP_Text)label).faceColor = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			((Behaviour)label).enabled = true;
			if ((Object)(object)((Component)label).gameObject != (Object)null && !((Component)label).gameObject.activeSelf)
			{
				((Component)label).gameObject.SetActive(true);
			}
			PhoneCanvasRepair.EnsureLabelCanvasChannels(((Graphic)label).canvas);
			CanvasRenderer canvasRenderer = label.canvasRenderer;
			if ((Object)(object)canvasRenderer != (Object)null)
			{
				canvasRenderer.SetColor(Color.white);
				canvasRenderer.SetAlpha(1f);
				canvasRenderer.cull = false;
				canvasRenderer.cullTransparentMesh = false;
				canvasRenderer.materialCount = 1;
				canvasRenderer.SetMaterial(val2, 0);
				if ((Object)(object)font.atlasTexture != (Object)null)
				{
					canvasRenderer.SetTexture((Texture)(object)font.atlasTexture);
				}
			}
			((Graphic)label).SetAllDirty();
			if (((Component)label).gameObject.activeInHierarchy)
			{
				((TMP_Text)label).ForceMeshUpdate(true, false);
			}
			return true;
		}
	}
	internal static class GradedCardCaseSprite
	{
		private const string SpriteName = "GradedCardCase";

		private const int TextureSize = 512;

		private static Sprite? _sprite;

		private static Texture2D? _texture;

		private static bool _loggedSource;

		public static readonly Vector2 SlabAnchorMin = new Vector2(0.17f, 0.05f);

		public static readonly Vector2 SlabAnchorMax = new Vector2(0.83f, 0.95f);

		public static readonly Vector2 FaceAnchorMin = new Vector2(0.26f, 0.09f);

		public static readonly Vector2 FaceAnchorMax = new Vector2(0.74f, 0.75f);

		public static readonly Vector2 HeaderAnchorMin = new Vector2(0.21f, 0.78f);

		public static readonly Vector2 HeaderAnchorMax = new Vector2(0.79f, 0.92f);

		public static Sprite Get()
		{
			if ((Object)(object)_sprite != (Object)null)
			{
				return _sprite;
			}
			Sprite val = TryLoadFromTextureReplacer();
			if ((Object)(object)val != (Object)null && !LooksLikeBrokenStub(val))
			{
				_sprite = val;
				LogSource("TextureReplacer/objects_textures");
				return _sprite;
			}
			Sprite val2 = TryLoadFromPluginResources();
			if ((Object)(object)val2 != (Object)null && !LooksLikeBrokenStub(val2))
			{
				_sprite = val2;
				LogSource("plugin Resources");
				return _sprite;
			}
			_sprite = CreateProceduralSlabSprite();
			LogSource($"procedural {512}x{512}");
			return _sprite;
		}

		private static void LogSource(string source)
		{
			if (!_loggedSource)
			{
				_loggedSource = true;
				Plugin.Log.LogInfo((object)("GradedCardCase sprite restored from " + source + "."));
			}
		}

		private static bool LooksLikeBrokenStub(Sprite sprite)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0077: 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)
			Texture2D texture = sprite.texture;
			if ((Object)(object)texture == (Object)null)
			{
				return true;
			}
			if (((Texture)texture).width <= 64 || ((Texture)texture).height <= 64)
			{
				return true;
			}
			try
			{
				Color32[] pixels = texture.GetPixels32();
				if (pixels == null || pixels.Length == 0)
				{
					return false;
				}
				long num = 0L;
				int num2 = 0;
				int num3 = Mathf.Max(1, pixels.Length / 256);
				int num4 = 0;
				for (int i = 0; i < pixels.Length; i += num3)
				{
					Color32 val = pixels[i];
					num += val.r + val.g + val.b;
					if (val.a > 8)
					{
						num2++;
					}
					num4++;
				}
				if (num4 <= 0)
				{
					return true;
				}
				return (float)num / (float)(num4 * 3) < 4f && num2 > num4 / 2;
			}
			catch
			{
				return false;
			}
		}

		private static Sprite? TryLoadFromTextureReplacer()
		{
			return LoadSpriteFile(Path.Combine(Paths.PluginPath, "TextureReplacer", "objects_textures", "GradedCardCase.png"));
		}

		private static Sprite? TryLoadFromPluginResources()
		{
			return LoadSpriteFile(Path.Combine(Path.GetDirectoryName(typeof(GradedCardCaseSprite).Assembly.Location) ?? string.Empty, "Resources", "GradedCardCase.png"));
		}

		private static Sprite? LoadSpriteFile(string path)
		{
			//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_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_0035: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(path))
			{
				return null;
			}
			try
			{
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					name = "GradedCardCase",
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				if (!ImageConversion.LoadImage(val, array))
				{
					Object.Destroy((Object)(object)val);
					return null;
				}
				Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)obj).name = "GradedCardCase";
				return obj;
			}
			catch
			{
				return null;
			}
		}

		private static Sprite? TryFindLoadedSprite()
		{
			Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
			foreach (Sprite val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Object)val).name != null && (string.Equals(((Object)val).name, "GradedCardCase", StringComparison.OrdinalIgnoreCase) || string.Equals(((Object)val).name, "GradedCardCase(Clone)", StringComparison.OrdinalIgnoreCase)))
				{
					return val;
				}
			}
			return null;
		}

		private static Sprite CreateProceduralSlabSprite()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_002f: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: 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_02aa: 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_02f2: Unknown result type (might be due to invalid IL or missing references)
			_texture = new Texture2D(512, 512, (TextureFormat)4, false)
			{
				name = "GradedCardCase0703",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color32 val = default(Color32);
			((Color32)(ref val))..ctor((byte)0, (byte)0, (byte)0, (byte)0);
			Color32 color = default(Color32);
			((Color32)(ref color))..ctor((byte)18, (byte)20, (byte)24, byte.MaxValue);
			Color32 color2 = default(Color32);
			((Color32)(ref color2))..ctor((byte)72, (byte)78, (byte)88, byte.MaxValue);
			Color32 color3 = default(Color32);
			((Color32)(ref color3))..ctor((byte)175, (byte)182, (byte)195, (byte)240);
			Color32 color4 = default(Color32);
			((Color32)(ref color4))..ctor((byte)36, (byte)40, (byte)46, byte.MaxValue);
			Color32 color5 = default(Color32);
			((Color32)(ref color5))..ctor((byte)14, (byte)15, (byte)18, byte.MaxValue);
			Color32 color6 = default(Color32);
			((Color32)(ref color6))..ctor((byte)175, (byte)182, (byte)192, (byte)230);
			Color32[] array = (Color32[])(object)new Color32[262144];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = val;
			}
			int num = Mathf.RoundToInt(512f * SlabAnchorMin.x);
			int num2 = Mathf.RoundToInt(512f * SlabAnchorMin.y);
			int num3 = Mathf.RoundToInt(512f * SlabAnchorMax.x) - 1;
			int num4 = Mathf.RoundToInt(512f * SlabAnchorMax.y) - 1;
			FillRoundedRect(array, 512, num, num2, num3, num4, 18, color2);
			StrokeRoundedRect(array, 512, num, num2, num3, num4, 18, color3, 3);
			StrokeRoundedRect(array, 512, num + 5, num2 + 5, num3 - 5, num4 - 5, 14, color4, 2);
			int num5 = Mathf.RoundToInt(512f * HeaderAnchorMin.x);
			int num6 = Mathf.RoundToInt(512f * HeaderAnchorMax.x) - 1;
			int num7 = Mathf.RoundToInt(512f * HeaderAnchorMin.y);
			int y = Mathf.RoundToInt(512f * HeaderAnchorMax.y) - 1;
			FillRoundedRect(array, 512, num5, num7, num6, y, 6, color5);
			FillRect(array, 512, num5 + 4, num7 - 3, num6 - 4, num7 - 1, color6);
			int x = Mathf.RoundToInt(512f * FaceAnchorMin.x);
			int x2 = Mathf.RoundToInt(512f * FaceAnchorMax.x) - 1;
			int y2 = Mathf.RoundToInt(512f * FaceAnchorMin.y);
			int y3 = Mathf.RoundToInt(512f * FaceAnchorMax.y) - 1;
			FillRect(array, 512, x, y2, x2, y3, color);
			StrokeRect(array, 512, x, y2, x2, y3, color4, 2);
			_texture.SetPixels32(array);
			_texture.Apply(false, false);
			Sprite obj = Sprite.Create(_texture, new Rect(0f, 0f, 512f, 512f), new Vector2(0.5f, 0.5f), 100f);
			((Object)obj).name = "GradedCardCase0703";
			return obj;
		}

		private static void FillRect(Color32[] pixels, int size, int x0, int y0, int x1, int y1, Color32 color)
		{
			//IL_0042: 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)
			x0 = Mathf.Clamp(x0, 0, size - 1);
			x1 = Mathf.Clamp(x1, 0, size - 1);
			y0 = Mathf.Clamp(y0, 0, size - 1);
			y1 = Mathf.Clamp(y1, 0, size - 1);
			for (int i = y0; i <= y1; i++)
			{
				int num = i * size;
				for (int j = x0; j <= x1; j++)
				{
					pixels[num + j] = color;
				}
			}
		}

		private static void StrokeRect(Color32[] pixels, int size, int x0, int y0, int x1, int y1, Color32 color, int width)
		{
			//IL_0013: 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_0041: 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)
			for (int i = 0; i < width; i++)
			{
				FillRect(pixels, size, x0 + i, y0 + i, x1 - i, y0 + i, color);
				FillRect(pixels, size, x0 + i, y1 - i, x1 - i, y1 - i, color);
				FillRect(pixels, size, x0 + i, y0 + i, x0 + i, y1 - i, color);
				FillRect(pixels, size, x1 - i, y0 + i, x1 - i, y1 - i, color);
			}
		}

		private static void FillRoundedRect(Color32[] pixels, int size, int x0, int y0, int x1, int y1, int radius, Color32 color)
		{
			//IL_0049: 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)
			radius = Mathf.Max(0, Mathf.Min(new int[3]
			{
				radius,
				(x1 - x0) / 2,
				(y1 - y0) / 2
			}));
			for (int i = y0; i <= y1; i++)
			{
				for (int j = x0; j <= x1; j++)
				{
					if (InsideRoundedRect(j, i, x0, y0, x1, y1, radius))
					{
						pixels[i * size + j] = color;
					}
				}
			}
		}

		private static void StrokeRoundedRect(Color32[] pixels, int size, int x0, int y0, int x1, int y1, int radius, Color32 color, int width)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < width; i++)
			{
				FillRoundedRectOutline(pixels, size, x0 + i, y0 + i, x1 - i, y1 - i, Mathf.Max(0, radius - i), color);
			}
		}

		private static void FillRoundedRectOutline(Color32[] pixels, int size, int x0, int y0, int x1, int y1, int radius, Color32 color)
		{
			//IL_0042: 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)
			for (int i = y0; i <= y1; i++)
			{
				for (int j = x0; j <= x1; j++)
				{
					bool num = InsideRoundedRect(j, i, x0, y0, x1, y1, radius);
					bool flag = InsideRoundedRect(j, i, x0 + 1, y0 + 1, x1 - 1, y1 - 1, Mathf.Max(0, radius - 1));
					if (num && !flag)
					{
						pixels[i * size + j] = color;
					}
				}
			}
		}

		private static bool InsideRoundedRect(int x, int y, int x0, int y0, int x1, int y1, int radius)
		{
			if (x < x0 || x > x1 || y < y0 || y > y1)
			{
				return false;
			}
			if (radius <= 0)
			{
				return true;
			}
			if (x < x0 + radius && y < y0 + radius)
			{
				return DistSq(x, y, x0 + radius, y0 + radius) <= radius * radius;
			}
			if (x > x1 - radius && y < y0 + radius)
			{
				return DistSq(x, y, x1 - radius, y0 + radius) <= radius * radius;
			}
			if (x < x0 + radius && y > y1 - radius)
			{
				return DistSq(x, y, x0 + radius, y1 - radius) <= radius * radius;
			}
			if (x > x1 - radius && y > y1 - radius)
			{
				return DistSq(x, y, x1 - radius, y1 - radius) <= radius * radius;
			}
			return true;
		}

		private static int DistSq(int x0, int y0, int x1, int y1)
		{
			int num = x0 - x1;
			int num2 = y0 - y1;
			return num * num + num2 * num2;
		}
	}
	internal static class GradedScratchClearSprite
	{
		private static Sprite? _sprite;

		private static Texture2D? _texture;

		public static Texture2D ClearTexture
		{
			get
			{
				EnsureCreated();
				return _texture;
			}
		}

		public static Sprite Get()
		{
			EnsureCreated();
			return _sprite;
		}

		private static void EnsureCreated()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0042: Expected O, but got Unknown
			//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_005b: 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_0067: 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_0078: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_sprite != (Object)null) || !((Object)(object)_texture != (Object)null))
			{
				_texture = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					name = "GradedScratchClear0703",
					filterMode = (FilterMode)0,
					wrapMode = (TextureWrapMode)1
				};
				_texture.SetPixels((Color[])(object)new Color[4]
				{
					Color.clear,
					Color.clear,
					Color.clear,
					Color.clear
				});
				_texture.Apply(false, true);
				_sprite = Sprite.Create(_texture, new Rect(0f, 0f, 2f, 2f), new Vector2(0.5f, 0.5f), 100f);
				((Object)_sprite).name = "GradedScratchClear0703";
			}
		}
	}
	internal sealed class PackOpeningLateSyncBehaviour : MonoBehaviour
	{
		private const float BootstrapRetryIntervalSeconds = 1f;

		private const int BootstrapGiveUpRetries = 45;

		private float _bootstrapRetryTimer;

		private int _bootstrapRetryCount;

		private bool _packRefsReady;

		private bool _loggedBootstrapSuccess;

		private bool _loggedBootstrapGiveUp;

		private void Update()
		{
			if (_packRefsReady)
			{
				return;
			}
			_bootstrapRetryTimer += Time.unscaledDeltaTime;
			if (_bootstrapRetryTimer < 1f)
			{
				return;
			}
			_bootstrapRetryTimer = 0f;
			_bootstrapRetryCount++;
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			PackOpeningRefsBootstrap.TryBootstrap(instance);
			bool flag = PackOpeningRefsBootstrap.HasMinimumPackOpenRefs(instance);
			bool flag2 = PackOpeningRefsBootstrap.HasOpenSequenceUiRefs(instance);
			if (flag && flag2)
			{
				_packRefsReady = true;
				PackOpeningRefsBootstrap.TryRecoverStart(instance);
				if (!_loggedBootstrapSuccess)
				{
					_loggedBootstrapSuccess = true;
					Plugin.Log.LogInfo((object)("CardOpeningSequence pack refs ready after late sync " + $"(retries={_bootstrapRetryCount}, animator=True, mesh=True, startLerp=True, ui=True)."));
				}
			}
			else if (!_loggedBootstrapGiveUp && _bootstrapRetryCount >= 45)
			{
				_loggedBootstrapGiveUp = true;
				Plugin.Log.LogWarning((object)("CardOpeningSequence pack ref late sync giving up after " + $"{45}s: minRefs={flag}, uiRefs={flag2}, " + $"animator={(Object)(object)instance.m_CardPackAnimator != (Object)null}, mesh={(Object)(object)instance.m_CardPackMesh != (Object)null}, " + $"startLerp={(Object)(object)instance.m_StartLerpTransform != (Object)null}. " + "Pack wrapper animation may stay broken until scene objects are restored from vanilla 0.70.3."));
			}
		}

		private void LateUpdate()
		{
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if (!PackOpeningState.ShouldSyncPackPresentation(instance))
			{
				return;
			}
			try
			{
				PackOpeningState.SyncFromSequence(instance);
				int stateIndex = instance.m_StateIndex;
				if (stateIndex >= 0 && stateIndex < 7)
				{
					PackOpening0703Patches.SyncAllPackOpeningPresentations(instance);
				}
				else if (stateIndex >= 7)
				{
					PackOpening0703Patches.HidePackVisualsDuringFanRow(instance);
					PackOpening0703Patches.SyncAllFanRowPresentations(instance);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Pack opening late sync failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}
	}
	internal static class PackOpeningRefsBootstrap
	{
		private const int CardDataPoolSize = 10;

		private static bool _loggedBootstrap;

		private static bool _loggedDiagnostics;

		private static bool _loggedPoolRepair;

		private static bool _loggedPackOpenReadiness;

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

		private static bool _loggedFanDiagnostics;

		private static readonly string[] OpenCardClipNames = new string[4] { "OpenCardSlideExit", "OpenCardNewCard", "OpenCardFinalReveal", "OpenCardDefaultPos" };

		public static void TryBootstrap(CardOpeningSequence sequence)
		{
			if (!((Object)(object)sequence == (Object)null))
			{
				bool flag = false;
				flag |= TryBootstrapFromOpeningUiAnchor(sequence);
				flag |= TryBootstrapFromLocalHierarchy(sequence);
				if (!HasMinimumPackOpenRefs(sequence) || !HasOpenSequenceUiRefs(sequence))
				{
					flag |= TryBootstrapFromSceneSearch(sequence);
				}
				flag |= TryBootstrapCardLists(sequence);
				flag |= TryBootstrapAnimationAndIcons(sequence);
				flag |= TryBootstrapOpenPackVfx(sequence);
				flag |= EnsureCardOpeningUiGroup(sequence);
				EnsurePackOpenFeedbackIcons(sequence);
				TryEnsureCardDataPools(sequence);
				if (flag && !_loggedBootstrap)
				{
					_loggedBootstrap = true;
					Plugin.Log.LogWarning((object)"Repaired missing CardOpeningSequence pack references from scene search (sharedassets port).");
				}
				if ((!HasMinimumPackOpenRefs(sequence) || !HasOpenSequenceUiRefs(sequence)) && !_loggedDiagnostics)
				{
					_loggedDiagnostics = true;
					LogDiagnostics(sequence);
				}
			}
		}

		public static bool HasMinimumPackOpenRefs(CardOpeningSequence sequence)
		{
			if ((Object)(object)sequence.m_CardPackAnimator != (Object)null && (Object)(object)sequence.m_CardPackMesh != (Object)null)
			{
				return (Object)(object)sequence.m_StartLerpTransform != (Object)null;
			}
			return false;
		}

		public static bool HasOpenSequenceUiRefs(CardOpeningSequence sequence)
		{
			if ((Object)(object)sequence.m_CardOpeningUIGroup != (Object)null && (Object)(object)sequence.m_CardOpeningSequenceUI != (Object)null && (Object)(object)sequence.m_CardOpeningRotateToFrontAnim != (Object)null && sequence.m_Card3dUIList != null && sequence.m_Card3dUIList.Count > 0 && sequence.m_CardAnimList != null)
			{
				return sequence.m_CardAnimList.Count > 0;
			}
			return false;
		}

		public static void TryEnsureCardDataPools(CardOpeningSequence sequence)
		{
			if ((EnsureCardDataPool(sequence, "m_CardDataPool") | EnsureCardDataPool(sequence, "m_CardDataPool2")) && !_loggedPoolRepair)
			{
				_loggedPoolRepair = true;
				Plugin.Log.LogWarning((object)"Repaired empty CardOpeningSequence card data pools after Start() failure (sharedassets port).");
			}
		}

		public static bool EnsureCardOpeningUiGroup(CardOpeningSequence sequence)
		{
			if ((Object)(object)sequence.m_CardOpeningUIGroup != (Object)null)
			{
				return false;
			}
			if (sequence.m_Card3dUIList != null && sequence.m_Card3dUIList.Count > 0)
			{
				Transform parent = ((Component)sequence.m_Card3dUIList[0]).transform.parent;
				if ((Object)(object)parent != (Object)null)
				{
					sequence.m_CardOpeningUIGroup = ((Component)parent).gameObject;
					return true;
				}
			}
			if ((Object)(object)sequence.m_CardOpeningSequenceUI != (Object)null)
			{
				Transform transform = ((Component)sequence.m_CardOpeningSequenceUI).transform;
				sequence.m_CardOpeningUIGroup = (((Object)(object)transform.parent != (Object)null) ? ((Component)transform.parent).gameObject : ((Component)transform).gameObject);
				return true;
			}
			return false;
		}

		public static bool TryRunReadyingCardPack(CardOpeningSequence sequence, Item item)
		{
			//IL_00bf: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			EnsureCardOpeningUiGroup(sequence);
			if (!HasMinimumPackOpenRefs(sequence) || (Object)(object)sequence.m_CardOpeningUIGroup == (Object)null || (Object)(object)item == (Object)null)
			{
				return false;
			}
			object value = CardOpeningSequenceFieldAccess.GetValue(sequence, "m_IsReadyingToOpen");
			if (value is bool && (bool)value)
			{
				return true;
			}
			CardOpeningSequenceFieldAccess.SetValue(sequence, "m_IsScreenActive", true);
			CSingleton<InteractionPlayerController>.Instance.EnterLockMoveMode();
			CSingleton<InteractionPlayerController>.Instance.OnEnterOpenPackState();
			CardOpeningSequenceFieldAccess.SetValue(sequence, "m_IsReadyingToOpen", true);
			CardOpeningSequenceFieldAccess.SetValue(sequence, "m_IsReadyToOpen", false);
			CardOpeningSequenceFieldAccess.SetValue(sequence, "m_LerpPosTimer", 0f);
			CardOpeningSequenceFieldAccess.SetValue(sequence, "m_CurrentItem", item);
			((Component)sequence.m_CardPackAnimator).transform.position = sequence.m_StartLerpTransform.position;
			((Component)sequence.m_CardPackAnimator).transform.rotation = sequence.m_StartLerpTransform.rotation;
			((Component)sequence.m_CardPackAnimator).transform.localScale = sequence.m_StartLerpTransform.localScale;
			if ((Object)(object)item.m_Mesh != (Object)null)
			{
				((Renderer)sequence.m_CardPackMesh).material = ((Renderer)item.m_Mesh).sharedMaterial;
			}
			((Component)sequence.m_CardPackAnimator).gameObject.SetActive(true);
			((Component)item).gameObject.SetActive(false);
			sequence.m_CardOpeningUIGroup.SetActive(false);
			sequence.m_CardPackAnimator.Play("PackOpenAnim", -1, 0f);
			CSingleton<InteractionPlayerController>.Instance.m_BlackBGWorldUIFade.SetFadeIn(3f, 0f);
			TutorialManager.SetGameUIVisible(false);
			CenterDot.SetVisibility(false);
			GameUIScreen.HideEnterGoNextDayIndicatorVisible();
			InteractionPlayerController.TempHideToolTip();
			InteractionPlayerController.AddToolTip((EGameAction)30, true, false);
			InteractionPlayerController.AddToolTip((EGameAction)29, false, false);
			InteractionPlayerController.SetAllHoldItemVisibility(false);
			CSingleton<InteractionPlayerController>.Instance.m_CameraFOVController.StartLerpToFOV(40f);
			SoundManager.GenericPop(1f, 1f);
			return true;
		}

		public static bool TryRunInitOpenSequence(CardOpeningSequence sequence)
		{
			EnsureCardOpeningUiGroup(sequence);
			if ((Object)(object)sequence.m_CardPackAnimator == (Object)null || (Object)(object)sequence.m_CardOpeningUIGroup == (Object)null || sequence.m_Card3dUIList == null || sequence.m_Card3dUIList.Count == 0)
			{
				return false;
			}
			sequence.m_CardPackAnimator.speed = 0f;
			((Component)sequence.m_CardPackAnimator).gameObject.SetActive(true);
			sequence.m_CardPackAnimator.Play("PackOpenAnim", -1, 0f);
			if ((Object)(object)sequence.m_CardOpeningRotateToFrontAnim != (Object)null)
			{
				sequence.m_CardOpeningRotateToFrontAnim.Play("CardOpenSeq0_Idle");
			}
			sequence.m_CardOpeningUIGroup.SetActive(true);
			if ((Object)(object)sequence.m_NewCardIcon != (Object)null)
			{
				sequence.m_NewCardIcon.SetActive(false);
			}
			if ((Object)(object)sequence.m_HighValueCardIcon != (Object)null)
			{
				sequence.m_HighValueCardIcon.SetActive(false);
			}
			InteractionPlayerController.RemoveToolTip((EGameAction)29);
			InteractionPlayerController.RemoveToolTip((EGameAction)30);
			InteractionPlayerController.AddToolTip((EGameAction)30, true, false);
			object value = CardOpeningSequenceFieldAccess.GetValue(sequence, "m_MultiplierStateTimer");
			if (value is float)
			{
				_ = (float)value;
				CGameManager instance = CSingleton<CGameManager>.Instance;
				float num = (((Object)(object)instance != (Object)null) ? instance.m_OpenPackSpeedSlider : 0f);
				CardOpeningSequenceFieldAccess.SetValue(sequence, "m_MultiplierStateTimer", 1f + 2.5f * num);
			}
			CardOpeningSequenceFieldAccess.SetValue(sequence, "m_HighValueCardThreshold", 10f + (float)CPlayerData.m_ShopLevel / 5f * 2f);
			return true;
		}

		public static void LogPackOpenReadiness(CardOpeningSequence sequence)
		{
			if (!_loggedPackOpenReadiness)
			{
				_loggedPackOpenReadiness = true;
				string value = (((Object)(object)sequence.m_CardOpeningRotateToFrontAnim != (Object)null) ? GetHierarchyPath(((Component)sequence.m_CardOpeningRotateToFrontAnim).transform) : "null");
				Plugin.Log.LogWarning((object)("Pack open readiness: " + $"animator={(Object)(object)sequence.m_CardPackAnimator != (Object)null}, mesh={(Object)(object)sequence.m_CardPackMesh != (Object)null}, " + $"startLerp={(Object)(object)sequence.m_StartLerpTransform != (Object)null}, " + $"uiGroup={(Object)(object)sequence.m_CardOpeningUIGroup != (Object)null}, rotateAnim={(Object)(object)sequence.m_CardOpeningRotateToFrontAnim != (Object)null}, " + $"rotatePath={value}, newCardIcon={(Object)(object)sequence.m_NewCardIcon != (Object)null}, highValueIcon={(Object)(object)sequence.m_HighValueCardIcon != (Object)null}, " + $"card3d={sequence.m_Card3dUIList?.Count ?? 0}, cardAnim={sequence.m_CardAnimList?.Count ?? 0}, " + $"cardAnimClips={sequence.m_CardAnimList != null && CardAnimListHasOpenCardClips(sequence.m_CardAnimList)}, " + $"showAllPos={sequence.m_ShowAllCardPosList?.Count ?? 0}, openVfx={(Object)(object)sequence.m_OpenPackVFX != (Object)null}, " + $"sequenceUi={(Object)(object)sequence.m_CardOpeningSequenceUI != (Object)null}, " + $"enableTooltip={CSingleton<CGameManager>.Instance?.m_EnableTooltip}"));
				if ((Object)(object)sequence.m_CardPackAnimator == (Object)null || (Object)(object)sequence.m_CardPackMesh == (Object)null || (Object)(object)sequence.m_StartLerpTransform == (Object)null)
				{
					Plugin.Log.LogWarning((object)"Pack open visuals incomplete: animator/mesh/startLerp still missing at pack-open time (UI card fan may still run). Check sharedassets scene objects vs vanilla 0.70.3.");
				}
			}
		}

		public static void ResetOpenDiagnostics()
		{
			_dumpedStackStates.Clear();
			_loggedFanDiagnostics = false;
		}

		public static void DumpCardStackDiagnostics(CardOpeningSequence sequence)
		{
			//IL_0067: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_0174: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d2: 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_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: 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_035d: 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_0431: 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)
			if (sequence.m_Card3dUIList == null || sequence.m_Card3dUIList.Count == 0)
			{
				return;
			}
			int stateIndex = sequence.m_StateIndex;
			if (stateIndex < 2 || stateIndex > 6 || _dumpedStackStates.Contains(stateIndex))
			{
				return;
			}
			_dumpedStackStates.Add(stateIndex);
			Camera val = CSingleton<InteractionPlayerController>.Instance?.m_Cam;
			Vector3 val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform.position : Vector3.zero);
			Vector3 val3 = (((Object)(object)val != (Object)null) ? ((Component)val).transform.forward : Vector3.forward);
			int currentOpenedCardIndex = PackOpeningState.GetCurrentOpenedCardIndex();
			Plugin.Log.LogWarning((object)$"CardStack dump at state={sequence.m_StateIndex} openedIndex={currentOpenedCardIndex} count={sequence.m_Card3dUIList.Count}");
			for (int i = 0; i < sequence.m_Card3dUIList.Count; i++)
			{
				Card3dUIGroup val4 = sequence.m_Card3dUIList[i];
				if ((Object)(object)val4 == (Object)null)
				{
					Plugin.Log.LogWarning((object)$"CardStack[{i}] = null");
					continue;
				}
				Transform transform = ((Component)val4).transform;
				float value = (((Object)(object)val != (Object)null) ? Vector3.Distance(transform.position, val2) : (-1f));
				float value2 = Vector3.Dot(transform.forward, val3);
				CardUI cardUI = val4.m_CardUI;
				bool value3 = (Object)(object)cardUI?.m_CardFront != (Object)null && cardUI.m_CardFront.activeSelf;
				bool value4 = (Object)(object)cardUI?.m_CardBack != (Object)null && cardUI.m_CardBack.activeSelf;
				object obj;
				if (cardUI == null)
				{
					obj = null;
				}
				else
				{
					Image cardBackImage = cardUI.m_CardBackImage;
					obj = ((cardBackImage != null) ? cardBackImage.sprite : null);
				}
				string value5 = (((Object)obj != (Object)null) ? ((Object)cardUI.m_CardBackImage.sprite).name : "null");
				bool value6 = (Object)(object)val4.m_CardBackMesh != (Object)null && val4.m_CardBackMesh.activeSelf;
				CardData val5 = (((Object)(object)cardUI != (Object)null) ? cardUI.GetCardData() : null);
				string value7 = ((val5 != null) ? ((object)Unsafe.As<ECardExpansionType, ECardExpansionType>(ref val5.expansionType)/*cast due to .constrained prefix*/).ToString() : "null");
				if ((Object)(object)val4.m_CardBackMesh != (Object)null)
				{
					Renderer component = val4.m_CardBackMesh.GetComponent<Renderer>();
					if (component != null && (Object)(object)component.sharedMaterial != (Object)null && (Object)(object)component.sharedMaterial.mainTexture != (Object)null)
					{
						_ = ((Object)component.sharedMaterial.mainTexture).name;
					}
				}
				Vector3 lossyScale = transform.lossyScale;
				string value8 = "front=null";
				if ((Object)(object)cardUI?.m_CardFront != (Object)null)
				{
					Transform transform2 = cardUI.m_CardFront.transform;
					float value9 = (((Object)(object)val != (Object)null) ? Vector3.Dot(transform2.forward, val3) : 0f);
					float value10 = (((Object)(object)val != (Object)null) ? Vector3.Distance(transform2.position, val2) : (-1f));
					value8 = $"frontLossy={transform2.lossyScale.x:F2} frontFacing={value9:F2} frontDist={value10:F1} frontActiveHier={cardUI.m_CardFront.activeInHierarchy}";
				}
				string value11 = "back=null";
				if ((Object)(object)cardUI?.m_CardBack != (Object)null)
				{
					Transform transform3 = cardUI.m_CardBack.transform;
					float value12 = (((Object)(object)val != (Object)null) ? Vector3.Dot(transform3.forward, val3) : 0f);
					float value13 = (((Object)(object)val != (Object)null) ? Vector3.Distance(transform3.position, val2) : (-1f));
					value11 = $"backLossy={transform3.lossyScale.x:F2} backFacing={value12:F2} backDist={value13:F1} backActiveHier={cardUI.m_CardBack.activeInHierarchy}";
				}
				Plugin.Log.LogWarning((object)$"CardStack[{i}] name={((Object)transform).name} sib={transform.GetSiblingIndex()} active={((Component)val4).gameObject.activeSelf} openIdx={currentOpenedCardIndex} expansion={value7} facing={value2:F2} frontActive={value3} backActive={value4} cardLossy={lossyScale.x:F2} camDist={value:F1} {value8} {value11} backSprite={value5} backMeshActive={value6}");
			}
		}

		public static void DumpFanDiagnostics(CardOpeningSequence sequence)
		{
			//IL_0055: 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_005a: 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_0064: 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_00ad: 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_0102: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: 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_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			if (_loggedFanDiagnostics || sequence.m_StateIndex < 7 || sequence.m_Card3dUIList == null || sequence.m_Card3dUIList.Count == 0)
			{
				return;
			}
			_loggedFanDiagnostics = true;
			Camera val = CSingleton<InteractionPlayerController>.Instance?.m_Cam;
			Vector3 val2 = (((Object)(object)val != (Object)null) ? ((Component)val).transform.position : Vector3.zero);
			Vector3 val3 = (((Object)(object)val != (Object)null) ? ((Component)val).transform.forward : Vector3.forward);
			Plugin.Log.LogWarning((object)$"FanDump at state={sequence.m_StateIndex} camPos={val2} camForward={val3}");
			for (int i = 0; i < sequence.m_Card3dUIList.Count; i++)
			{
				Card3dUIGroup val4 = sequence.m_Card3dUIList[i];
				if (!((Object)(object)val4 == (Object)null))
				{
					Transform transform = ((Component)val4).transform;
					float value = Vector3.Dot(transform.position - val2, ((Vector3)(ref val3)).normalized);
					float value2 = Vector3.Distance(transform.position, val2);
					Canvas val5 = (((Object)(object)val4.m_CardUI != (Object)null) ? ((Component)val4.m_CardUI).GetComponentInParent<Canvas>() : null);
					string value3 = (((Object)(object)val5 != (Object)null) ? $"canvas={((Object)val5).name} mode={val5.renderMode} order={val5.sortingOrder} override={val5.overrideSorting}" : "canvas=null");
					int value4 = -1;
					Canvas val6 = null;
					if ((Object)(object)val4.m_CardUI != (Object)null && (Object)(object)val4.m_CardUI.m_CardFrontImage != (Object)null)
					{
						Material materialForRendering = ((Graphic)val4.m_CardUI.m_CardFrontImage).materialForRendering;
						value4 = (((Object)(object)materialForRendering != (Object)null) ? materialForRendering.renderQueue : (-1));
						val6 = ((Graphic)val4.m_CardUI.m_CardFrontImage).canvas;
					}
					string value5 = (((Object)(object)val6 != (Object)null) ? $"frontCanvas={((Object)val6).name} fOrder={val6.sortingOrder} fOverride={val6.overrideSorting}" : "frontCanvas=null");
					Plugin.Log.LogWarning((object)$"FanCard[{i}] name={((Object)transform).name} active={((Component)val4).gameObject.activeSelf} worldPos={transform.position} depth={value:F3} camDist={value2:F3} frontQueue={value4} {value3} {value5}");
				}
			}
			if (sequence.m_ShowAllCardPosList != null)
			{
				for (int j = 0; j < sequence.m_ShowAllCardPosList.Count; j++)
				{
					Transform val7 = sequence.m_ShowAllCardPosList[j];
					if (!((Object)(object)val7 == (Object)null))
					{
						float value6 = Vector3.Dot(val7.position - val2, ((Vector3)(ref val3)).normalized);
						Plugin.Log.LogWarning((object)$"FanPos[{j}] name={((Object)val7).name} worldPos={val7.position} depth={value6:F3}");
					}
				}
			}
			DumpCardOpeningUiOverlay(sequence, val, val2, val3);
			DumpBlackBgBackdrop(val, val2, val3);
		}

		private static void DumpBlackBgBackdrop(Camera? cam, Vector3 camPos, Vector3 camForward)
		{
			//IL_007e: 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_0083: 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_00a4: 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_00ac: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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)
			InteractionPlayerController instance = CSingleton<InteractionPlayerController>.Instance;
			MaterialFadeInOut val = (((Object)(object)instance != (Object)null) ? instance.m_BlackBGWorldUIFade : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Backdrop: m_BlackBGWorldUIFade is NULL");
				return;
			}
			MeshRenderer mesh = val.m_Mesh;
			if ((Object)(object)mesh == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Backdrop: m_BlackBGWorldUIFade.m_Mesh is NULL");
				return;
			}
			Material material = ((Renderer)mesh).material;
			Color val2 = (Color)(((Object)(object)material != (Object)null) ? material.color : new Color(-1f, -1f, -1f, -1f));
			Transform transform = ((Component)mesh).transform;
			float value = (((Object)(object)cam != (Object)null) ? Vector3.Dot(transform.position - camPos, ((Vector3)(ref camForward)).normalized) : (-1f));
			int value2 = (((Object)(object)material != (Object)null) ? material.renderQueue : (-1));
			Plugin.Log.LogWarning((object)$"Backdrop: meshEnabled={((Renderer)mesh).enabled} active={((Component)mesh).gameObject.activeInHierarchy} matColor={val2} matAlpha={val2.a:F3} worldPos={transform.position} depth={value:F3} scale={transform.lossyScale} renderQueue={value2} sortLayer={((Renderer)mesh).sortingLayerID} sortOrder={((Renderer)mesh).sortingOrder} matName={(((Object)(object)material != (Object)null) ? ((Object)material).name : "null")} srcMat={(((Object)(object)val.m_Mat != (Object)null) ? ((Object)val.m_Mat).name : "null")}");
		}

		private static void DumpCardOpeningUiOverlay(CardOpeningSequence sequence, Camera? cam, Vector3 camPos, Vector3 camForward)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			Image[] array = Object.FindObjectsOfType<Image>(false);
			Plugin.Log.LogWarning((object)$"FanOverlay: scene-wide scan of {array.Length} active Image(s)");
			int num = 0;
			for (int i = 0; i < array.Length; i++)
			{
				if (num >= 30)
				{
					break;
				}
				Image val = array[i];
				if (!((Object)(object)val == (Object)null) && ((Behaviour)val).enabled)
				{
					Rect worldRectApprox = GetWorldRectApprox(((Graphic)val).rectTransform);
					bool num2 = ((Rect)(ref worldRectApprox)).width > 800f && ((Rect)(ref worldRectApprox)).height > 600f;
					bool flag = ((Graphic)val).color.a > 0.4f && ((Graphic)val).color.r < 0.4f && ((Graphic)val).color.g < 0.4f && ((Graphic)val).color.b < 0.4f;
					if (num2 || flag)
					{
						Canvas canvas = ((Graphic)val).canvas;
						string value = (((Object)(object)canvas != (Object)null) ? $"{((Object)canvas).name}/{canvas.renderMode}/order={canvas.sortingOrder}" : "null");
						float value2 = (((Object)(object)cam != (Object)null) ? Vector3.Dot(((Component)val).transform.position - camPos, ((Vector3)(ref camForward)).normalized) : (-1f));
						Plugin.Log.LogWarning((object)$"FanOverlayImg name={((Object)val).name} path={GetHierarchyPath(((Component)val).transform)} active={((Component)val).gameObject.activeSelf} color={((Graphic)val).color} screenRect={((Rect)(ref worldRectApprox)).width:F0}x{((Rect)(ref worldRectApprox)).height:F0} depth={value2:F3} canvas={value}");
						num++;
					}
				}
			}
		}

		private static Rect GetWorldRectApprox(RectTransform rt)
		{
			//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_0074: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0095: 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_00a7: 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_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_0040: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rt.GetWorldCorners(array);
			Camera val = CSingleton<InteractionPlayerController>.Instance?.m_Cam;
			if ((Object)(object)val == (Object)null)
			{
				float num = Vector3.Distance(array[0], array[3]);
				float num2 = Vector3.Distance(array[0], array[1]);
				return new Rect(0f, 0f, num, num2);
			}
			Vector3 val2 = val.WorldToScreenPoint(array[0]);
			Vector3 val3 = val.WorldToScreenPoint(array[2]);
			return new Rect(val2.x, val2.y, Mathf.Abs(val3.x - val2.x), Mathf.Abs(val3.y - val2.y));
		}

		public static void EnsurePackOpenFeedbackIcons(CardOpeningSequence sequence)
		{
			Transform parent = (((Object)(object)sequence.m_CardOpeningUIGroup != (Object)null) ? sequence.m_CardOpeningUIGroup.transform : ((Component)sequence).transform);
			if ((Object)(object)sequence.m_NewCardIcon == (Object)null)
			{
				sequence.m_NewCardIcon = FindSceneGameObjectByName("NewCardIcon") ?? EnsureRuntimeStubObject(parent, "NewCardIcon0703Bootstrap");
			}
			if ((Object)(object)sequence.m_HighValueCardIcon == (Object)null)
			{
				sequence.m_HighValueCardIcon = FindSceneGameObjectByName("HighValueCardIcon") ?? EnsureRuntimeStubObject(parent, "HighValueCardIcon0703Bootstrap");
			}
			sequence.m_NewCardIcon.SetActive(false);
			sequence.m_HighValueCardIcon.SetActive(false);
		}

		private static GameObject EnsureRuntimeStubObject(Transform parent, string name)
		{
			//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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			Transform val = parent.Find(name);
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			GameObject val2 = new GameObject(name);
			val2.transform.SetParent(parent, false);
			val2.SetActive(false);
			return val2;
		}

		private static bool TryBootstrapFromOpeningUiAnchor(CardOpeningSequence sequence)
		{
			//IL_0032: 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)
			CardOpeningSequenceUI[] array = FindSceneComponents<CardOpeningSequenceUI>();
			if (array.Length == 0)
			{
				return false;
			}
			CardOpeningSequenceUI val = null;
			int num = int.MinValue;
			foreach (CardOpeningSequenceUI val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					int num2 = 100 - (int)Vector3.Distance(((Component)val2).transform.position, ((Component)sequence).transform.position);
					Card3dUIGroup[] componentsInChildren = ((Component)val2).GetComponentsInChildren<Card3dUIGroup>(true);
					num2 += componentsInChildren.Length * 10;
					if (num2 > num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			bool flag = false;
			if ((Object)(object)sequence.m_CardOpeningSequenceUI == (Object)null)
			{
				sequence.m_CardOpeningSequenceUI = val;
				flag = true;
			}
			Transform val3 = null;
			int num3 = 0;
			Transform val4 = ((Component)val).transform;
			for (int j = 0; j < 10; j++)
			{
				if (!((Object)(object)val4 != (Object)null))
				{
					break;
				}
				Card3dUIGroup[] componentsInChildren2 = ((Component)val4).GetComponentsInChildren<Card3dUIGroup>(true);
				if (componentsInChildren2.Length > num3)
				{
					num3 = componentsInChildren2.Length;
					val3 = val4;
				}
				val4 = val4.parent;
			}
			if ((Object)(object)val3 != (Object)null)
			{
				flag |= TryAssignFromTransformTree(val3, sequence);
			}
			return flag;
		}

		private static bool TryBootstrapOpenPackVfx(CardOpeningSequence sequence)
		{
			//IL_008d: 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)
			if ((Object)(object)sequence.m_OpenPackVFX != (Object)null)
			{
				return false;
			}
			ParticleSystem[] array = FindSceneComponents<ParticleSystem>();
			ParticleSystem val = null;
			int num = int.MinValue;
			foreach (ParticleSystem val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					int num2 = 0;
					string hierarchyPath = GetHierarchyPath(((Component)val2).transform);
					if (hierarchyPath.IndexOf("OpenPack", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						num2 += 80;
					}
					if (hierarchyPath.IndexOf("CardOpening", StringComparison.OrdinalIgnoreCase) >= 0 || hierarchyPath.IndexOf("PackOpen", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						num2 += 40;
					}
					float num3 = Vector3.Distance(((Component)val2).transform.position, ((Component)sequence).transform.position);
					if (num3 < 25f)
					{
						num2 += Math.Max(0, 20 - (int)num3);
					}
					if (num2 > num)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if ((Object)(object)val != (Object)null && num > 0)
			{
				sequence.m_OpenPackVFX = val;
				return true;
			}
			return false;
		}

		private static bool EnsureCardDataPool(CardOpeningSequence sequence, string fieldName)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (!(CardOpeningSequenceFieldAccess.GetValue(sequence, fieldName) is List<CardData> list))
			{
				return false;
			}
			if (list.Count >= 10)
			{
				return false;
			}
			while (list.Count < 10)
			{
				list.Add(new CardData());
			}
			return true;
		}

		public static void TryRecoverStart(CardOpeningSequence sequence)
		{
			TryEnsureCardDataPools(sequence);
			if ((Object)(object)sequence.m_CardPackAnimator == (Object)null || (Object)(object)sequence.m_CardOpeningUIGroup == (Object)null)
			{
				return;
			}
			try
			{
				((Component)sequence.m_CardPackAnimator).gameObject.SetActive(false);
				sequence.m_CardPackAnimator.speed = 0f;
				sequence.m_CardOpeningUIGroup.SetActive(false);
				if ((Object)(object)sequence.m_NewCardIcon != (Object)null)
				{
					sequence.m_NewCardIcon.SetActive(false);
				}
				if ((Object)(object)sequence.m_HighValueCardIcon != (Object)null)
				{
					sequence.m_HighValueCardIcon.SetActive(false);
				}
				if ((Object)(object)sequence.m_CardOpeningSequenceUI != (Object)null)
				{
					if ((Object)(object)sequence.m_CardOpeningSequenceUI.m_CardValueTextGrp != (Object)null)
					{
						sequence.m_CardOpeningSequenceUI.m_CardValueTextGrp.SetActive(false);
					}
					if ((Object)(object)sequence.m_CardOpeningSequenceUI.m_TotalCardValueTextGrp != (Object)null)
					{
						sequence.m_CardOpeningSequenceUI.m_TotalCardValueTextGrp.SetActive(false);
					}
					if ((Object)(object)sequence.m_CardOpeningSequenceUI.m_FoilRainbowGlowingBG != (Object)null)
					{
						sequence.m_CardOpeningSequenceUI.m_FoilRainbowGlowingBG.SetActive(false);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("CardOpeningSequence start recovery failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static bool TryBootstrapFromLocalHierarchy(CardOpeningSequence sequence)
		{
			bool flag = false;
			Transform[] array = (Transform[])(object)new Transform[2]
			{
				((Component)sequence).transform,
				((Component)sequence).transform.parent
			};
			foreach (Transform val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					flag |= TryAssignFromTransformTree(val, sequence);
					if (HasMinimumPackOpenRefs(sequence))
					{
						return flag;
					}
				}
			}
			return flag;
		}

		private static bool TryBootstrapFromSceneSearch(CardOpeningSequence sequence)
		{
			bool flag = false;
			if ((Object)(object)sequence.m_CardOpeningSequenceUI == (Object)null)
			{
				CardOpeningSequenceUI[] array = FindSceneComponents<CardOpeningSequenceUI>();
				if (array.Length != 0)
				{
					sequence.m_CardOpeningSequenceUI = array[0];
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardOpeningUIGroup == (Object)null)
			{
				Transform val = FindSceneTransformByName("CardOpeningUIGroup");
				if ((Object)(object)val != (Object)null)
				{
					sequence.m_CardOpeningUIGroup = ((Component)val).gameObject;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_StartLerpTransform == (Object)null)
			{
				sequence.m_StartLerpTransform = FindSceneTransformByName("StartLerpTransform") ?? FindSceneTransformByName("StartLerpPos") ?? FindSceneTransformByName("PackStartLerpTransform");
				if ((Object)(object)sequence.m_StartLerpTransform != (Object)null)
				{
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardPackAnimator == (Object)null)
			{
				Animator[] array2 = FindSceneComponents<Animator>();
				Animator val2 = null;
				int num = int.MinValue;
				foreach (Animator val3 in array2)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						int num2 = ScorePackAnimatorCandidate(val3, ((Component)sequence).transform);
						if (num2 > num)
						{
							num = num2;
							val2 = val3;
						}
					}
				}
				if ((Object)(object)val2 != (Object)null && num > 0)
				{
					sequence.m_CardPackAnimator = val2;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardPackMesh == (Object)null && (Object)(object)sequence.m_CardPackAnimator != (Object)null)
			{
				sequence.m_CardPackMesh = ((Component)sequence.m_CardPackAnimator).GetComponent<SkinnedMeshRenderer>() ?? ((Component)sequence.m_CardPackAnimator).GetComponentInChildren<SkinnedMeshRenderer>(true);
				if ((Object)(object)sequence.m_CardPackMesh != (Object)null)
				{
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardPackMesh == (Object)null)
			{
				SkinnedMeshRenderer[] array3 = FindSceneComponents<SkinnedMeshRenderer>();
				SkinnedMeshRenderer val4 = null;
				int num3 = int.MinValue;
				foreach (SkinnedMeshRenderer val5 in array3)
				{
					if (!((Object)(object)val5 == (Object)null))
					{
						int num4 = ScorePackMeshCandidate(val5, ((Component)sequence).transform);
						if (num4 > num3)
						{
							num3 = num4;
							val4 = val5;
						}
					}
				}
				if ((Object)(object)val4 != (Object)null && num3 > 0)
				{
					sequence.m_CardPackMesh = val4;
					if ((Object)(object)sequence.m_CardPackAnimator == (Object)null)
					{
						sequence.m_CardPackAnimator = ((Component)val4).GetComponentInParent<Animator>(true);
					}
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_StartLerpTransform == (Object)null && (Object)(object)sequence.m_CardPackAnimator != (Object)null)
			{
				sequence.m_StartLerpTransform = EnsureRuntimeStartLerpTransform(sequence);
				flag = true;
			}
			flag |= TryBootstrapAnimationAndIcons(sequence);
			return flag | TryBootstrapCardLists(sequence);
		}

		private static bool TryBootstrapAnimationAndIcons(CardOpeningSequence sequence)
		{
			bool result = false;
			EnsurePackOpenFeedbackIcons(sequence);
			if ((Object)(object)sequence.m_CardOpeningRotateToFrontAnim == (Object)null || IsPerCardPackAnimation(sequence.m_CardOpeningRotateToFrontAnim))
			{
				Animation val = FindPackOpeningSequenceAnimation(sequence);
				if ((Object)(object)val != (Object)null)
				{
					sequence.m_CardOpeningRotateToFrontAnim = val;
					result = true;
				}
			}
			if ((Object)(object)sequence.m_NewCardIcon != (Object)null && (Object)(object)sequence.m_HighValueCardIcon != (Object)null)
			{
				result = true;
			}
			return result;
		}

		private static Animation? FindPackOpeningSequenceAnimation(CardOpeningSequence sequence)
		{
			Animation val = FindAnimationWithClip("CardOpenSeq1_RotateToFront", ((Component)sequence).transform);
			if ((Object)(object)val != (Object)null && !IsPerCardPackAnimation(val))
			{
				return val;
			}
			val = FindAnimationWithClip("CardOpenSeq0_Idle", ((Component)sequence).transform);
			if ((Object)(object)val != (Object)null && !IsPerCardPackAnimation(val))
			{
				return val;
			}
			return null;
		}

		private static bool IsPerCardPackAnimation(Animation animation)
		{
			return GetHierarchyPath(((Component)animation).transform).IndexOf("Card3d", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool TryBootstrapCardLists(CardOpeningSequence sequence)
		{
			bool result = false;
			if (sequence.m_Card3dUIList == null || sequence.m_Card3dUIList.Count == 0)
			{
				List<Card3dUIGroup> list = CollectCard3dGroups(sequence);
				if (list.Count > 0)
				{
					sequence.m_Card3dUIList = list;
					result = true;
				}
			}
			if (sequence.m_Card3dUIList != null && sequence.m_Card3dUIList.Count > 0 && (sequence.m_CardAnimList == null || sequence.m_CardAnimList.Count != sequence.m_Card3dUIList.Count || !CardAnimListHasOpenCardClips(sequence.m_CardAnimList)))
			{
				List<Animation> list2 = new List<Animation>(sequence.m_Card3dUIList.Count);
				for (int i = 0; i < sequence.m_Card3dUIList.Count; i++)
				{
					Card3dUIGroup val = sequence.m_Card3dUIList[i];
					Animation val2 = (((Object)(object)val != (Object)null) ? FindOpenCardAnimationFor(val) : null);
					if ((Object)(object)val2 != (Object)null)
					{
						list2.Add(val2);
					}
				}
				if (list2.Count == sequence.m_Card3dUIList.Count)
				{
					sequence.m_CardAnimList = list2;
					result = true;
				}
			}
			if (sequence.m_ShowAllCardPosList == null || sequence.m_ShowAllCardPosList.Count == 0 || ShowAllCardPositionsLookLikeAnimGroupFallback(sequence))
			{
				List<Transform> list3 = CollectShowAllCardPositions(sequence);
				if (list3.Count > 0)
				{
					sequence.m_ShowAllCardPosList = list3;
					result = true;
				}
			}
			return result;
		}

		private static bool CardAnimListHasOpenCardClips(List<Animation> cardAnims)
		{
			for (int i = 0; i < cardAnims.Count; i++)
			{
				Animation val = cardAnims[i];
				if ((Object)(object)val == (Object)null || !AnimationHasAnyOpenCardClip(val))
				{
					return false;
				}
			}
			return true;
		}

		private static bool AnimationHasAnyOpenCardClip(Animation animation)
		{
			for (int i = 0; i < OpenCardClipNames.Length; i++)
			{
				if (AnimationHasClip(animation, OpenCardClipNames[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static Animation? FindOpenCardAnimationFor(Card3dUIGroup card3d)
		{
			if ((Object)(object)card3d.m_Anim != (Object)null && AnimationHasAnyOpenCardClip(card3d.m_Anim))
			{
				return card3d.m_Anim;
			}
			Transform val = ((Component)card3d).transform;
			for (int i = 0; i < 12; i++)
			{
				if (!((Object)(object)val != (Object)null))
				{
					break;
				}
				Animation component = ((Component)val).GetComponent<Animation>();
				if ((Object)(object)component != (Object)null && AnimationHasAnyOpenCardClip(component))
				{
					return component;
				}
				val = val.parent;
			}
			Animation[] componentsInChildren = ((Component)card3d).GetComponentsInChildren<Animation>(true);
			for (int j = 0; j < componentsInChildren.Length; j++)
			{
				if ((Object)(object)componentsInChildren[j] != (Object)null && AnimationHasAnyOpenCardClip(componentsInChildren[j]))
				{
					return componentsInChildren[j];
				}
			}
			return null;
		}

		private static bool ShowAllCardPositionsLookLikeAnimGroupFallback(CardOpeningSequence sequence)
		{
			if (sequence.m_ShowAllCardPosList == null || sequence.m_ShowAllCardPosList.Count == 0)
			{
				return false;
			}
			for (int i = 0; i < sequence.m_ShowAllCardPosList.Count; i++)
			{
				Transform val = sequence.m_ShowAllCardPosList[i];
				if ((Object)(object)val != (Object)null && ((Object)val).name.IndexOf("CardUIAnim", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static List<Card3dUIGroup> CollectCard3dGroups(CardOpeningSequence sequence)
		{
			List<Card3dUIGroup> list = new List<Card3dUIGroup>();
			if ((Object)(object)sequence.m_CardOpeningUIGroup != (Object)null)
			{
				AppendSortedCardGroups(sequence.m_CardOpeningUIGroup.GetComponentsInChildren<Card3dUIGroup>(true), list);
			}
			if (list.Count == 0)
			{
				Card3dUIGroup[] array = FindSceneComponents<Card3dUIGroup>();
				int num = array.Length;
				if (num >= 7 && num <= 12)
				{
					AppendSortedCardGroups(array, list);
				}
				else
				{
					foreach (Card3dUIGroup val in array)
					{
						if (!((Object)(object)val == (Object)null))
						{
							string hierarchyPath = GetHierarchyPath(((Component)val).transform);
							if (hierarchyPath.IndexOf("CardOpening", StringComparison.OrdinalIgnoreCase) >= 0 || hierarchyPath.IndexOf("OpenPack", StringComparison.OrdinalIgnoreCase) >= 0 || hierarchyPath.IndexOf("PackOpen", StringComparison.OrdinalIgnoreCase) >= 0)
							{
								list.Add(val);
							}
						}
					}
					list.Sort(CompareSiblingOrder);
				}
			}
			list.Reverse();
			return list;
		}

		private static void AppendSortedCardGroups(IReadOnlyList<Card3dUIGroup> source, List<Card3dUIGroup> destination)
		{
			for (int i = 0; i < source.Count; i++)
			{
				Card3dUIGroup val = source[i];
				if ((Object)(object)val != (Object)null && !destination.Contains(val))
				{
					destination.Add(val);
				}
			}
			destination.Sort(CompareCardGroupOrder);
		}

		private static int CompareCardGroupOrder(Card3dUIGroup left, Card3dUIGroup right)
		{
			int num = ExtractTrailingNumber((left != null) ? ((Object)((Component)left).transform).name : null);
			int num2 = ExtractTrailingNumber((right != null) ? ((Object)((Component)right).transform).name : null);
			if (num >= 0 && num2 >= 0 && num != num2)
			{
				return num.CompareTo(num2);
			}
			return CompareSiblingOrder(left, right);
		}

		private static int ExtractTrailingNumber(string? name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return -1;
			}
			int num = name.Length - 1;
			while (num >= 0 && char.IsDigit(name[num]))
			{
				num--;
			}
			if (num == name.Length - 1)
			{
				return -1;
			}
			if (!int.TryParse(name.Substring(num + 1), out var result))
			{
				return -1;
			}
			return result;
		}

		private static int CompareSiblingOrder(Card3dUIGroup left, Card3dUIGroup right)
		{
			Transform val = ((left != null) ? ((Component)left).transform : null);
			Transform val2 = ((right != null) ? ((Component)right).transform : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return 0;
			}
			if ((Object)(object)val.parent == (Object)(object)val2.parent)
			{
				return val.GetSiblingIndex().CompareTo(val2.GetSiblingIndex());
			}
			return string.Compare(GetHierarchyPath(val), GetHierarchyPath(val2), StringComparison.Ordinal);
		}

		private static List<Transform> CollectShowAllCardPositions(CardOpeningSequence sequence)
		{
			List<Transform> list = new List<Transform>();
			CollectShowAllCardPositionsUnderRoot(((Object)(object)sequence.m_CardOpeningUIGroup != (Object)null) ? sequence.m_CardOpeningUIGroup.transform : (((Object)(object)sequence.m_CardOpeningSequenceUI != (Object)null) ? ((Component)sequence.m_CardOpeningSequenceUI).transform : ((Component)sequence).transform), list);
			if (list.Count == 0)
			{
				Transform[] array = FindSceneComponents<Transform>();
				foreach (Transform val in array)
				{
					if ((Object)(object)val != (Object)null && ((Object)val).name.StartsWith("ShowAllCardPos", StringComparison.OrdinalIgnoreCase))
					{
						list.Add(val);
					}
				}
			}
			list.Sort(CompareShowAllCardPositionOrder);
			return list;
		}

		private static void CollectShowAllCardPositionsUnderRoot(Transform? root, List<Transform> positions)
		{
			if (!((Object)(object)root == (Object)null))
			{
				if (((Object)root).name.StartsWith("ShowAllCardPos", StringComparison.OrdinalIgnoreCase))
				{
					positions.Add(root);
				}
				for (int i = 0; i < root.childCount; i++)
				{
					CollectShowAllCardPositionsUnderRoot(root.GetChild(i), positions);
				}
			}
		}

		private static int CompareShowAllCardPositionOrder(Transform left, Transform right)
		{
			int num = ExtractTrailingNumber(((Object)left).name);
			int num2 = ExtractTrailingNumber(((Object)right).name);
			if (num >= 0 && num2 >= 0 && num != num2)
			{
				return num.CompareTo(num2);
			}
			return string.Compare(((Object)left).name, ((Object)right).name, StringComparison.OrdinalIgnoreCase);
		}

		private static Animation? FindAnimationWithClip(string clipName, Transform sequenceTransform)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			Animation[] array = FindSceneComponents<Animation>();
			Animation result = null;
			int num = int.MinValue;
			foreach (Animation val in array)
			{
				if (!((Object)(object)val == (Object)null) && AnimationHasClip(val, clipName))
				{
					int num2 = 0;
					string hierarchyPath = GetHierarchyPath(((Component)val).transform);
					if (hierarchyPath.IndexOf("CardOpening", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						num2 += 50;
					}
					if (hierarchyPath.IndexOf("Rotate", StringComparison.OrdinalIgnoreCase) >= 0 || hierarchyPath.IndexOf("OpenSeq", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						num2 += 30;
					}
					if (hierarchyPath.IndexOf("Card3d", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						num2 -= 100;
					}
					float num3 = Vector3.Distance(((Component)val).transform.position, sequenceTransform.position);
					if (num3 < 25f)
					{
						num2 += Math.Max(0, 20 - (int)num3);
					}
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private static bool AnimationHasClip(Animation animation, string clipName)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			foreach (AnimationState item in animation)
			{
				AnimationState val = item;
				if ((TrackedReference)(object)val != (TrackedReference)null && string.Equals(val.name, clipName, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static GameObject? FindSceneGameObjectByName(string name)
		{
			Transform? obj = FindSceneTransformByName(name);
			if (obj == null)
			{
				return null;
			}
			return ((Component)obj).gameObject;
		}

		private static bool TryAssignFromTransformTree(Transform root, CardOpeningSequence sequence)
		{
			bool flag = false;
			if ((Object)(object)sequence.m_CardPackAnimator == (Object)null)
			{
				Animator componentInChildren = ((Component)root).GetComponentInChildren<Animator>(true);
				if ((Object)(object)componentInChildren != (Object)null && ScorePackAnimatorCandidate(componentInChildren, ((Component)sequence).transform) > 0)
				{
					sequence.m_CardPackAnimator = componentInChildren;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardPackMesh == (Object)null)
			{
				SkinnedMeshRenderer componentInChildren2 = ((Component)root).GetComponentInChildren<SkinnedMeshRenderer>(true);
				if ((Object)(object)componentInChildren2 != (Object)null && ScorePackMeshCandidate(componentInChildren2, ((Component)sequence).transform) > 0)
				{
					sequence.m_CardPackMesh = componentInChildren2;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_StartLerpTransform == (Object)null)
			{
				Transform val = FindDeepChild(root, "StartLerpTransform") ?? FindDeepChild(root, "StartLerpPos");
				if ((Object)(object)val != (Object)null)
				{
					sequence.m_StartLerpTransform = val;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardOpeningUIGroup == (Object)null)
			{
				Transform val2 = FindDeepChild(root, "CardOpeningUIGroup");
				if ((Object)(object)val2 != (Object)null)
				{
					sequence.m_CardOpeningUIGroup = ((Component)val2).gameObject;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardOpeningSequenceUI == (Object)null)
			{
				CardOpeningSequenceUI componentInChildren3 = ((Component)root).GetComponentInChildren<CardOpeningSequenceUI>(true);
				if ((Object)(object)componentInChildren3 != (Object)null)
				{
					sequence.m_CardOpeningSequenceUI = componentInChildren3;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_CardOpeningRotateToFrontAnim == (Object)null || IsPerCardPackAnimation(sequence.m_CardOpeningRotateToFrontAnim))
			{
				Animation val3 = FindPackOpeningSequenceAnimation(sequence);
				if ((Object)(object)val3 != (Object)null)
				{
					sequence.m_CardOpeningRotateToFrontAnim = val3;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_NewCardIcon == (Object)null)
			{
				Transform val4 = FindDeepChild(root, "NewCardIcon");
				if ((Object)(object)val4 != (Object)null)
				{
					sequence.m_NewCardIcon = ((Component)val4).gameObject;
					flag = true;
				}
			}
			if ((Object)(object)sequence.m_HighValueCardIcon == (Object)null)
			{
				Transform val5 = FindDeepChild(root, "HighValueCardIcon");
				if ((Object)(object)val5 != (Object)null)
				{
					sequence.m_HighValueCardIcon = ((Component)val5).gameObject;
					flag = true;
				}
			}
			return flag | TryBootstrapCardLists(sequence);
		}

		private static int ScorePackAnimatorCandidate(Animator animator, Transform sequenceTransform)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			RuntimeAnimatorController runtimeAnimatorController = animator.runtimeAnimatorController;
			if ((Object)(object)runtimeAnimatorController != (Object)null)
			{
				AnimationClip[] animationClips = runtimeAnimatorController.animationClips;
				foreach (AnimationClip val in animationClips)
				{
					if ((Object)(object)val != (Object)null && ((Object)val).name.IndexOf("PackOpen", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						num += 100;
						break;
					}
				}
			}
			string hierarchyPath = GetHierarchyPath(((Component)animator).transform);
			if (hierarchyPath.IndexOf("CardOpening", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				num += 40;
			}
			if (hierarchyPath.IndexOf("CardPack", StringComparison.OrdinalIgnoreCase) >= 0 || hierarchyPath.IndexOf("PackOpen", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				num += 30;
			}
			float num2 = Vector3.Distance(((Component)animator).transform.position, sequenceTransform.position);
			if (num2 < 25f)
			{
				num += Math.Max(0, 20 - (int)num2);
			}
			return num;
		}

		private static int ScorePackMeshCandidate(SkinnedMeshRenderer mesh, Transform sequenceTransform)
		{
			//IL_004b: 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)
			int num = 0;
			string hierarchyPath = GetHierarchyPath(((Component)mesh).transform);
			if (hierarchyPath.IndexOf("CardPack", StringComparison.OrdinalIgnoreCase) >= 0 || hierarchyPath.IndexOf("PackOpen", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				num += 50;
			}
			if (hierarchyPath.IndexOf("CardOpening", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				num += 30;
			}
			float num2 = Vector3.Distance(((Component)mesh).transform.position, sequenceTransform.position);
			if (num2 < 25f)
			{
				num += Math.Max(0, 20 - (int)num2);
			}
			return num;
		}

		private static Transform EnsureRuntimeStartLerpTransform(CardOpeningSequence sequence)
		{
			//IL_0078: 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_00d3: 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_009b: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)sequence.m_CardPackAnimator).transform;
			Transform val = (((Object)(object)transform.parent != (Object)null) ? transform.parent : ((Component)sequence).transform);
			Transform val2 = val.Find("PackOpenStartLerp0703Bootstrap");
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			InteractionPlayerController instance = CSingleton<InteractionPlayerController>.Instance;
			Transform val3 = ((instance?.m_HoldCardPackPosList != null && instance.m_HoldCardPackPosList.Count > 0) ? instance.m_HoldCardPackPosList[0] : null);
			Transform transform2 = new GameObject("PackOpenStartLerp0703Bootstrap").transform;
			transform2.SetParent(val, false);
			if ((Object)(object)val3 != (Object)null)
			{
				transform2.position = val3.position;
				transform2.rotation = val3.rotation;
				transform2.localScale = val3.lossyScale;
			}
			else
			{
				transform2.localPosition = transform.localPosition;
				transform2.localRotation = transform.localRotation;
				transform2.localScale = transform.localScale;
			}
			return transform2;
		}

		private static T[] FindSceneComponents<T>() where T : Component
		{
			T[] array = Resources.FindObjectsOfTypeAll<T>();
			List<T> list = new List<T>(array.Length);
			foreach (T val in array)
			{
				if (!((Object)(object)val == (Object)null) && IsSceneObject(((Component)val).gameObject))
				{
					list.Add(val);
				}
			}
			return list.ToArray();
		}

		private static Transform? FindSceneTransformByName(string name)
		{
			Transform[] array = FindSceneComponents<Transform>();
			foreach (Transform val in array)
			{
				if (((Object)val).name == name)
				{
					return val;
				}
			}
			return null;
		}

		private static bool IsSceneObject(GameObject gameObject)
		{
			//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)
			if ((Object)(object)gameObject != (Object)null)
			{
				Scene scene = gameObject.scene;
				return ((Scene)(ref scene)).IsValid();
			}
			return false;
		}

		private static string GetHierarchyPath(Transform transform)
		{
			string text = ((Object)transform).name;
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static Transform? FindDeepChild(Transform root, string name)
		{
			if (((Object)root).name == name)
			{
				return root;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform val = FindDeepChild(root.GetChild(i), name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void LogDiagnostics(CardOpeningSequence sequence)
		{
			Animator[] array = FindSceneComponents<Animator>();
			int num = 0;
			for (int i = 0; i < array.Length; i++)
			{
				if (ScorePackAnimatorCandidate(array[i], ((Component)sequence).transform) > 0)
				{
					num++;
				}
			}
			SkinnedMeshRenderer[] array2 = FindSceneComponents<SkinnedMeshRenderer>();
			Transform val = FindSceneTransformByName("StartLerpTransform");
			Plugin.Log.LogError((object)("CardOpeningSequence pack refs still missing after scene search. " + $"animator={(Object)(object)sequence.m_CardPackAnimator != (Object)null}, mesh={(Object)(object)sequence.m_CardPackMesh != (Object)null}, " + $"startLerp={(Object)(object)sequence.m_StartLerpTransform != (Object)null}, uiGroup={(Object)(object)sequence.m_CardOpeningUIGroup != (Object)null}, " + $"rotateAnim={(Object)(object)sequence.m_CardOpeningRotateToFrontAnim != (Object)null}, card3dCount={sequence.m_Card3dUIList?.Count ?? 0}, " + $"cardAnimCount={sequence.m_CardAnimList?.Count ?? 0}, " + $"sceneAnimators={array.Length}, packAnimatorCandidates={num}, " + $"sceneSkinnedMeshes={array2.Length}, namedStartLerp={(Object)(object)val != (Object)null}"));
		}
	}
	internal static class PackOpeningState
	{
		private const float FlipFrontRevealSlider = 0.45f;

		private const float FrontFacingDotThreshold = 0f;

		private static Func<CardOpeningSequence, int>? _openedCardIndexGetter;

		private static Func<CardOpeningSequence, float>? _sliderGetter;

		private static int _cachedOpenedCardIndex;

		private static int _cachedStateIndex;

		private static float _cachedSlider;

		public static bool IsCardFrontTowardCamera(Card3dUIGroup card3d)
		{
			//IL_0038: 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)
			if ((Object)(object)card3d == (Object)null)
			{
				return false;
			}
			Camera val = CSingleton<InteractionPlayerController>.Instance?.m_Cam;
			if ((Object)(object)val == (Object)null)
			{
				return _cachedStateIndex >= 5;
			}
			return Vector3.Dot(((Component)card3d).transform.forward, ((Component)val).transform.forward) > 0f;
		}

		public static void SyncFromSequence(CardOpeningSequence sequence)
		{
			if (!((Object)(object)sequence == (Object)null))
			{
				_cachedStateIndex = sequence.m_StateIndex;
				_cachedOpenedCardIndex = ReadOpenedCardIndex(sequence);
				_cachedSlider = ReadSlider(sequence);
			}
		}

		public static bool IsPackOpeningInProgress()
		{
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if (!ShouldSyncPackPresentation(instance))
			{
				return false;
			}
			int stateIndex = instance.m_StateIndex;
			if (stateIndex >= 0)
			{
				return stateIndex < 7;
			}
			return false;
		}

		public static bool ShouldSyncPackPresentation(CardOpeningSequence? sequence)
		{
			if ((Object)(object)sequence == (Object)null || !sequence.IsActive())
			{
				return false;
			}
			if ((Object)(object)sequence.m_CardOpeningUIGroup != (Object)null && !sequence.m_CardOpeningUIGroup.activeSelf)
			{
				return false;
			}
			return true;
		}

		public static bool IsPackFlipState()
		{
			int cachedStateIndex = _cachedStateIndex;
			if (cachedStateIndex >= 4)
			{
				return cachedStateIndex <= 6;
			}
			return false;
		}

		public static int GetPackStackTopCardIndex()
		{
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if (instance?.m_Card3dUIList == null)
			{
				return -1;
			}
			for (int num = instance.m_Card3dUIList.Count - 1; num >= 0; num--)
			{
				Card3dUIGroup val = instance.m_Card3dUIList[num];
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf)
				{
					return num;
				}
			}
			return -1;
		}

		public static int GetPackStackBackCardIndex()
		{
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if (instance?.m_Card3dUIList == null || instance.m_Card3dUIList.Count == 0)
			{
				return -1;
			}
			int cachedStateIndex = _cachedStateIndex;
			if (cachedStateIndex >= 0 && cachedStateIndex < 4)
			{
				return GetPackStackTopCardIndex();
			}
			int num = instance.m_Card3dUIList.Count - 1;
			Card3dUIGroup val = instance.m_Card3dUIList[num];
			if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf)
			{
				return num;
			}
			return GetPackStackTopCardIndex();
		}

		public static bool ShouldShowPackBackFace(Card3dUIGroup card3d)
		{
			if (!IsPackOpeningInProgress() || (Object)(object)card3d == (Object)null || IsPackFlipState())
			{
				return false;
			}
			int packCardIndex = GetPackCardIndex(card3d);
			if (packCardIndex < 0)
			{
				return false;
			}
			return packCardIndex == GetCurrentOpenedCardIndex();
		}

		public static bool ShouldShowStackedFrontFace(Card3dUIGroup card3d)
		{
			if (!IsPackFlipState() || (Object)(object)card3d == (Object)null)
			{
				return false;
			}
			int packCardIndex = GetPackCardIndex(card3d);
			if (packCardIndex >= 0)
			{
				return packCardIndex > GetCurrentOpenedCardIndex();
			}
			return false;
		}

		public static bool ShouldShowActiveCardFlipBack(Card3dUIGroup card3d)
		{
			if (!IsPackFlipState() || (Object)(object)card3d == (Object)null)
			{
				return false;
			}
			if (GetCurrentOpenedCardIndex() != 0)
			{
				return false;
			}
			if (GetPackCardIndex(card3d) != GetCurrentOpenedCardIndex())
			{
				return false;
			}
			return !ShouldShowFrontDuringPackFlip(card3d);
		}

		public static int GetPackCardIndex(Card3dUIGroup card3d)
		{
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if (instance?.m_Card3dUIList == null || (Object)(object)card3d == (Object)null)
			{
				return -1;
			}
			int num = instance.m_Card3dUIList.IndexOf(card3d);
			if (num >= 0)
			{
				return num;
			}
			if ((Object)(object)card3d.m_CardUI != (Object)null)
			{
				for (int i = 0; i < instance.m_Card3dUIList.Count; i++)
				{
					if ((Object)(object)instance.m_Card3dUIList[i]?.m_CardUI == (Object)(object)card3d.m_CardUI)
					{
						return i;
					}
				}
			}
			return -1;
		}

		public static bool IsFanRowVisible()
		{
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if ((Object)(object)instance == (Object)null || !instance.IsActive())
			{
				return false;
			}
			return instance.m_StateIndex >= 7;
		}

		public static bool ShouldShowFrontDuringPackFlip(Card3dUIGroup card3d)
		{
			if (!IsPackFlipState() || (Object)(object)card3d == (Object)null)
			{
				return false;
			}
			if (GetPackCardIndex(card3d) != GetCurrentOpenedCardIndex())
			{
				return false;
			}
			return _cachedStateIndex switch
			{
				4 => _cachedSlider >= 0.45f, 
				5 => true, 
				6 => _cachedSlider < 0.5f, 
				_ => false, 
			};
		}

		public static int GetCurrentOpenedCardIndex()
		{
			CardOpeningSequence instance = CSingleton<CardOpeningSequence>.Instance;
			if ((Object)(object)instance == (Object)null || !instance.IsActive())
			{
				return -1;
			}
			return _cachedOpenedCardIndex;
		}

		private static int ReadOpenedCardIndex(CardOpeningSequence sequence)
		{
			try
			{
				if (_openedCardIndexGetter == null)
				{
					_openedCardIndexGetter = CreateOpenedCardIndexGetter();
				}
				if (_openedCardIndexGetter != null)
				{
					return _openedCardIndexGetter(sequence);
				}
			}
			catch (Exception)
			{
			}
			object obj = typeof(CardOpeningSequence).GetField("m_CurrentOpenedCardIndex", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(sequence);
			if (obj is int)
			{
				return (int)obj;
			}
			return 0;
		}

		private static float ReadSlider(CardOpeningSequence sequence)
		{
			try
			{
				if (_sliderGetter == null)
				{
					_sliderGetter = CreateSliderGetter();
				}
				if (_sliderGetter != null)
				{
					return _sliderGetter(sequence);
				}
			}
			catch (Exception)
			{
			}
			object obj = typeof(CardOpeningSequence).GetField("m_Slider", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(sequence);
			if (obj is float)
			{
				return (float)obj;
			}
			return 0f;
		}

		private static Func<CardOpeningSequence, int>? CreateOpenedCardIndexGetter()
		{
			FieldInfo field = AccessTools.Field(typeof(CardOpeningSequence), "m_CurrentOpenedCardIndex");
			if (field == null)
			{
				return null;
			}
			return delegate(CardOpeningSequence sequence)
			{
				object value = field.GetValue(sequence);
				return (value is int) ? ((int)value) : 0;
			};
		}

		private static Func<CardOpeningSequence, float>? CreateSliderGetter()
		{
			FieldInfo field = AccessTools.Field(typeof(CardOpeningSequence), "m_Slider");
			if (field == null)
			{
				return null;
			}
			return delegate(CardOpeningSequence sequence)
			{
				object value = field.GetValue(sequence);
				return (value is float) ? ((float)value) : 0f;
			};
		}
	}
	internal static class PhoneAppUiScope
	{
		private static readonly string[] PhoneScreenRootNameTokens = new string[20]
		{
			"UI_PhoneScreen", "RestockItem", "RentBill", "ScannerRestock", "FurnitureShop", "ExpansionShop", "CheckPrice", "HireWorker", "CustomerReview", "BuyDeco",
			"Decoration", "GradeCard", "HostTournament", "CameraPhone", "PhotoGallery", "BarcodeScanner", "Checkout", "AddToCart", "GameEvent", "SortUI"
		};

		public static bool IsPhoneAppTransform(Transform? transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return false;
			}
			PhoneManager val = PhoneManagerAccess.FindPhoneManager();
			if ((Object)(object)val?.m_PhoneGrp != (Object)null && transform.IsChildOf(val.m_PhoneGrp))
			{
				return true;
			}
			if ((Object)(object)val != (Object)null && IsTransformUnderPhoneManagerScreen(transform, val))
			{
				return true;
			}
			return HasPhoneScreenRootName(transform);
		}

		public static IEnumerable<Transform> EnumeratePhoneUiRoots(PhoneManager phoneManager)
		{
			if ((Object)(object)phoneManager.m_PhoneGrp != (Object)null)
			{
				yield return phoneManager.m_PhoneGrp;
			}
			foreach (UIScreenBase item in EnumeratePhoneManagerScreens(phoneManager))
			{
				if ((Object)(object)item != (Object)null)
				{
					yield return ((Component)item).transform;
				}
			}
			if ((Object)(object)phoneManager.m_CameraPhoneModeUIScreen != (Object)null)
			{
				yield return ((Component)phoneManager.m_CameraPhoneModeUIScreen).transform;
			}
		}

		public static Transform? ResolvePhoneScreenContentRoot(Transform? fromTransform)
		{
			UIScreenBase val = FindOwnerScreen(fromTransform);
			if ((Object)(object)val?.m_ScreenGroup != (Object)null)
			{
				return val.m_ScreenGroup.transform;
			}
			return ResolvePhoneAppScreenRoot(fromTransform);
		}

		public static UIScreenBase? FindOwnerScreen(Transform? fromTransform)
		{
			if ((Object)(object)fromTransform == (Object)null)
			{
				return null;
			}
			UIScreenBase component = ((Component)fromTransform).GetComponent<UIScreenBase>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			PhoneManager val = PhoneManagerAccess.FindPhoneManager();
			if ((Object)(object)val != (Object)null)
			{
				foreach (UIScreenBase item in EnumeratePhoneManagerScreens(val))
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					if ((Object)(object)fromTransform == (Object)(object)((Component)item).transform || fromTransform.IsChildOf(((Component)item).transform))
					{
						return item;
					}
					if ((Object)(object)item.m_ScreenGroup != (Object)null)
					{
						Transform transform = item.m_ScreenGroup.transform;
						if ((Object)(object)fromTransform == (Object)(object)transform || fromTransform.IsChildOf(transform))
						{
							return item;
						}
					}
				}
			}
			return ((Component)fromTransform).GetComponentInParent<UIScreenBase>();
		}

		public static Transform? ResolvePhoneAppScreenRoot(Transform? fromTransform)
		{
			if ((Object)(object)fromTransform == (Object)null)
			{
				return null;
			}
			PhoneManager val = PhoneManagerAccess.FindPhoneManager();
			if ((Object)(object)val != (Object)null)
			{
				foreach (UIScreenBase item in EnumeratePhoneManagerScreens(val))
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					Transform transform = ((Component)item).transform;
					if ((Object)(object)fromTransform == (Object)(object)transform || fromTransform.IsChildOf(transform))
					{
						return transform;
					}
					if ((Object)(object)item.m_ScreenGroup != (Object)null)
					{
						Transform transform2 = item.m_ScreenGroup.transform;
						if ((Object)(object)fromTransform == (Object)(object)transform2 || fromTransform.IsChildOf(transform2))
						{
							return transform;
						}
					}
				}
				CameraPhoneModeUIScreen cameraPhoneModeUIScreen = val.m_CameraPhoneModeUIScreen;
				if ((Object)(object)cameraPhoneModeUIScreen != (Object)null)
				{
					Transform transform3 = ((Component)cameraPhoneModeUIScreen).transform;
					if ((Object)(object)fromTransform == (Object)(object)transform3 || fromTransform.IsChildOf(transform3))
					{
						return transform3;
					}
					if ((Object)(object)cameraPhoneModeUIScreen.m_ScreenGrp != (Object)null)
					{
						Transform transform4 = cameraPhoneModeUIScreen.m_ScreenGrp.transform;
						if ((Object)(object)fromTransform == (Object)(object)transform4 || fromTransform.IsChildOf(transform4))
						{
							return transform3;
						}
					}
				}
				if ((Object)(object)val.m_PhoneGrp != (Object)null && fromTransform.IsChildOf(val.m_PhoneGrp))
				{
					return val.m_PhoneGrp;
				}
			}
			return FindNamedPhoneScreenRoot(fromTransform) ?? fromTransform;
		}

		public static IEnumerable<UIScreenBase?> EnumerateScreens(PhoneManager phoneManager)
		{
			return EnumeratePhoneManagerScreens(phoneManager);
		}

		public static bool IsPhoneRelatedScreen(UIScreenBase? screen)
		{
			if ((Object)(object)screen == (Object)null)
			{
				return false;
			}
			if (IsPhoneAppTransform(((Component)screen).transform))
			{
				return true;
			}
			PhoneManager val = PhoneManagerAccess.FindPhoneManager();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			foreach (UIScreenBase item in EnumeratePhoneManagerScreens(val))
			{
				if ((Object)(object)item != (Object)null && screen == item)
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasPhoneScreenRootName(Transform transform)
		{
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				string name = ((Object)val).name;
				string[] phoneScreenRootNameTokens = PhoneScreenRootNameTokens;
				foreach (string value in phoneScreenRootNameTokens)
				{
					if (name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
				val = val.parent;
			}
			return false;
		}

		private static Transform? FindNamedPhoneScreenRoot(Transform fromTransform)
		{
			Transform result = null;
			Transform val = fromTransform;
			while ((Object)(object)val != (Object)null)
			{
				if (HasPhoneScreenRootName(val))
				{
					result = val;
				}
				val = val.parent;
			}
			return result;
		}

		private static bool IsTransformUnderPhoneManagerScreen(Transform transform, PhoneManager phoneManager)
		{
			foreach (UIScreenBase item in EnumeratePhoneManagerScreens(phoneManager))
			{
				if ((Object)(object)item != (Object)null && IsTransformUnderScreen(transform, item))
				{
					return true;
				}
			}
			CameraPhoneModeUIScreen cameraPhoneModeUIScreen = phoneManager.m_CameraPhoneModeUIScreen;
			if ((Object)(object)cameraPhoneModeUIScreen == (Object)null)
			{
				return false;
			}
			if ((Object)(object)transform == (Object)(object)((Component)cameraPhoneModeUIScreen).transform || transform.IsChildOf(((Component)cameraPhoneModeUIScreen).transform))
			{
				return true;
			}
			if ((Object)(object)cameraPhoneModeUIScreen.m_ScreenGrp == (Object)null)
			{
				return false;
			}
			Transform transform2 = cameraPhoneModeUIScreen.m_ScreenGrp.transform;
			if (!((Object)(object)transform == (Object)(object)transform2))
			{
				return transform.IsChildOf(transform2);
			}
			return true;
		}

		private static bool IsTransformUnderScreen(Transform transform, UIScreenBase screen)
		{
			if ((Object)(object)transform == (Object)(object)((Component)screen).transform || transform.IsChildOf(((Component)screen).transform))
			{
				return true;
			}
			if ((Object)(object)screen.m_ScreenGroup == (Object)null)
			{
				return false;
			}
			Transform transform2 = screen.m_ScreenGroup.transform;
			if (!((Object)(object)transform == (Object)(object)transform2))
			{
				return transform.IsChildOf(transform2);
			}
			return true;
		}

		private static IEnumerable<UIScreenBase?> EnumeratePhoneManagerScreens(PhoneManager phoneManager)
		{
			UIScreenBase?[] phoneManagerScreens = GetPhoneManagerScreens(phoneManager);
			foreach (UIScreenBase screen in phoneManagerScreens)
			{
				if (!((Object)(object)screen == (Object)null))
				{
					yield return screen;
					RestockItemScreen restockItemScreen = (RestockItemScreen)(object)((screen is RestockItemScreen) ? screen : null);
					if (restockItemScreen != null)
					{
						yield return (UIScreenBase?)(object)restockItemScreen.m_RestockItemAddToCartScreen;
						yield return (UIScreenBase?)(object)restockItemScreen.m_RestockItemCheckoutScreen;
						yield return restockItemScreen.m_SortUIScreen;
					}
				}
			}
		}

		private static UIScreenBase?[] GetPhoneManagerScreens(PhoneManager phoneManager)
		{
			return (UIScreenBase?[])(object)new UIScreenBase[16]
			{
				(UIScreenBase)phoneManager.m_UI_PhoneScreen,
				(UIScreenBase)phoneManager.m_RestockItemScreen,
				(UIScreenBase)phoneManager.m_RestockItemBoardGameScreen,
				(UIScreenBase)phoneManager.m_FurnitureShopUIScreen,
				(UIScreenBase)phoneManager.m_ExpandShopUIScreen,
				(UIScreenBase)phoneManager.m_SetGameEventUIScreen,
				(UIScreenBase)phoneManager.m_CheckPriceScreen,
				(UIScreenBase)phoneManager.m_HireWorkerScreen,
				(UIScreenBase)phoneManager.m_RentBillScreen,
				(UIScreenBase)phoneManager.m_CustomerReviewScreen,
				(UIScreenBase)phoneManager.m_ShopBuyDecoUIScreen,
				(UIScreenBase)phoneManager.m_GradeCardWebsiteUIScreen,
				(UIScreenBase)phoneManager.m_ScannerRestockScreen,
				(UIScreenBase)phoneManager.m_HostTournamentScreen,
				(UIScreenBase)phoneManager.m_CameraPhoneScreen,
				(UIScreenBase)phoneManager.m_CameraPhotoGalleryScreen
			};
		}
	}
	internal static class PhoneCanvasRepair
	{
		private const AdditionalCanvasShaderChannels RequiredShaderChannels = (AdditionalCanvasShaderChannels)27;

		public static void EnsurePhoneCanvasesReady(Transform? phoneRoot)
		{
			if (!((Object)(object)phoneRoot == (Object)null))
			{
				Canvas[] componentsInChildren = ((Component)phoneRoot).GetComponentsInChildren<Canvas>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					EnsureCanvasChannels(componentsInChildren[i]);
				}
			}
		}

		public static void EnsureLabelCanvasChannels(Canvas? canvas)
		{
			if (!((Object)(object)canvas == (Object)null))
			{
				EnsureCanvasChannels(canvas);
				EnsureCanvasChannels(canvas.rootCanvas);
			}
		}

		private static void EnsureCanvasChannels(Canvas? canvas)
		{
			//IL_000c: 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)
			if (!((Object)(object)canvas == (Object)null))
			{
				canvas.additionalShaderChannels = (AdditionalCanvasShaderChannels)(canvas.additionalShaderChannels | 0x1B);
			}
		}
	}
	internal static class PhoneFontMaterialSnapshot
	{
		private static readonly Dictionary<string, Material> Snapshots = new Dictionary<string, Material>(StringComparer.Ordinal);

		private static bool captured;

		public static void CaptureIfNeeded()
		{
			//IL_008f: 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_00af: Expected O, but got Unknown
			if (captured)
			{
				return;
			}
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name) && !((Object)(object)((TMP_Asset)val).material == (Object)null) && (((Object)val).name.StartsWith("FredokaOne", StringComparison.Ordinal) || ((Object)val).name.StartsWith("LiberationSans", StringComparison.Ordinal)) && !Snapshots.ContainsKey(((Object)val).name))
				{
					Snapshots[((Object)val).name] = new Material(((TMP_Asset)val).material)
					{
						name = "PhoneFontSnapshot_" + ((Object)val).name
					};
					if ((Object)(object)val.atlasTexture != (Object)null)
					{
						Snapshots[((Object)val).name].mainTexture = (Texture)(object)val.atlasTexture;
					}
				}
			}
			captured = Snapshots.Count > 0;
			if (captured)
			{
				Plugin.Log.LogInfo((object)$"Phone font material snapshot captured {Snapshots.Count} TMP material(s).");
			}
		}

		public static void RestoreSharedFontMaterial(TMP_FontAsset font)
		{
			//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_0045: Expected O, but got Unknown
			if (!((Object)(object)font == (Object)null) && !((Object)(object)((TMP_Asset)font).material == (Object)null) && Snapshots.TryGetValue(((Object)font).name, out var value))
			{
				Material val = new Material(value)
				{
					name = ((Object)((TMP_Asset)font).material).name
				};
				if ((Object)(object)font.atlasTexture != (Object)null)
				{
					val.mainTexture = (Texture)(object)font.atlasTexture;
				}
				((TMP_Asset)font).material = val;
				val.renderQueue = 3000;
			}
		}

		public static Material CreateHudLabelMaterial(TMP_FontAsset font)
		{
			//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_0039: Expected O, but got Unknown
			Material value;
			Material val = new Material(Snapshots.TryGetValue(((Object)font).name, out value) ? value : ((TMP_Asset)font).material)
			{
				name = "HudLabel_" + ((Object)font).name
			};
			if ((Object)(object)font.atlasTexture != (Object)null)
			{
				val.mainTexture = (Texture)(object)font.atlasTexture;
			}
			val.renderQueue = 3000;
			return val;
		}

		public static Material CreateLabelMaterial(TMP_FontAsset font)
		{
			//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_0039: Expected O, but got Unknown
			Material value;
			Material val = new Material(Snapshots.TryGetValue(((Object)font).name, out value) ? value : ((TMP_Asset)font).material)
			{
				name = "PhoneLabel_" + ((Object)font).name
			};
			if ((Object)(object)font.atlasTexture != (Object)null)
			{
				val.mainTexture = (Texture)(object)font.atlasTexture;
			}
			return val;
		}

		public static bool IsBorderFont(TMP_FontAsset? font)
		{
			if ((Object)(object)font != (Object)null)
			{
				return ((Object)font).name.IndexOf("border", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}
	}
	internal static class PhoneManagerAccess
	{
		private static PhoneManager? cachedPhoneManager;

		static PhoneManagerAccess()
		{
			SceneManager.sceneLoaded += delegate
			{
				InvalidateCache();
			};
			SceneManager.sceneUnloaded += delegate
			{
				InvalidateCache();
			};
		}

		public static void InvalidateCache()
		{
			cachedPhoneManager = null;
		}

		public static PhoneManager? FindPhoneManager()
		{
			if ((Object)(object)cachedPhoneManager != (Object)null)
			{
				return cachedPhoneManager;
			}
			cachedPhoneManager = Object.FindObjectOfType<PhoneManager>();
			return cachedPhoneManager;
		}

		public static PhoneManager? TryGetReadyPhoneManager()
		{
			PhoneManager val = FindPhoneManager();
			if (!IsReady(val))
			{
				return null;
			}
			return val;
		}

		public static bool IsReady(PhoneManager? phoneManager)
		{
			if ((Object)(object)phoneManager != (Object)null && (Object)(object)phoneManager.m_PhoneGrp != (Object)null && (Object)(object)phoneManager.m_UI_PhoneScreen != (Object)null)
			{
				return (Object)(object)phoneManager.m_BarcodeScannerMesh != (Object)null;
			}
			return false;
		}
	}
	internal sealed class PhoneUiLateRepairBehaviour : MonoBehaviour
	{
		private const float ShopSceneRetrySeconds = 0.5f;

		private const float PhoneOpenRepairDelaySeconds = 0.75f;

		private const int PhoneLayoutReadyMaxFrames = 45;

		private float _retryTimer;

		private bool _repairedInShopScene;

		private Coroutine? _deferredHomeRepair;

		private Coroutine? _deferredScreenRepair;

		private Coroutine? _deferredMaterialSweep;

		private Coroutine? _deferredPhoneOpenRefresh;

		private Transform? _pendingScreenRoot;

		internal static PhoneUiLateRepairBehaviour? Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void Update()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (_repairedInShopScene)
			{
				return;
			}
			_retryTimer += Time.unscaledDeltaTime;
			if (!(_retryTimer < 0.5f))
			{
				_retryTimer = 0f;
				Scene activeScene = SceneManager.GetActiveScene();
				if (!(((Scene)(ref activeScene)).name != "Start") && !((Object)(object)PhoneManagerAccess.TryGetReadyPhoneManager()?.m_PhoneGrp == (Object)null))
				{
					PhoneUi0703Patches.SchedulePhoneHomeRepair();
					_repairedInShopScene = true;
					Plugin.Log.LogInfo((object)"Phone UI late repair scheduled for Start scene.");
				}
			}
		}

		public static void RequestDeferredPhoneOpenRefresh()
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				Instance.ScheduleDeferredPhoneOpenRefresh();
			}
		}

		public static void RequestDeferredMaterialSweep()
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				Instance.ScheduleDeferredMaterialSweep();
			}
		}

		public static void RequestDeferredHomeRepair()
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				Instance.ScheduleDeferredHomeRepair();
			}
		}

		public static void RequestDeferredScreenRepair(Transform screenRoot)
		{
			if (!((Object)(object)Instance == (Object)null) && !((Object)(object)screenRoot == (Object)null))
			{
				Instance.ScheduleDeferredScreenRepair(screenRoot);
			}
		}

		private void ScheduleDeferredMaterialSweep()
		{
			if (_deferredMaterialSweep != null)
			{
				((MonoBehaviour)this).StopCoroutine(_deferredMaterialSweep);
			}
			_deferredMaterialSweep = ((MonoBehaviour)this).StartCoroutine(DeferredMaterialSweepRoutine());
		}

		private IEnumerator DeferredMaterialSweepRoutine()
		{
			yield return null;
			try
			{
				PhoneUi0703Patches.RepairFredokaFontAssetsPublic();
				PhoneUi0703Patches.RepairAllPhoneAppLabels(materialOnly: true, activeOnly: false);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Deferred phone TMP repair failed: " + ex.Message));
			}
			_deferredMaterialSweep = null;
		}

		private void ScheduleDeferredPhoneOpenRefresh()
		{
			if (_deferredPhoneOpenRefresh != null)
			{
				((MonoBehaviour)this).StopCoroutine(_deferredPhoneOpenRefresh);
			}
			_deferredPhoneOpenRefresh = ((MonoBehaviour)this).StartCoroutine(DeferredPhoneOpenRefreshRoutine());
		}

		private IEnumerator DeferredPhoneOpenRefreshRoutine()
		{
			for (int frame = 0; frame < 45; frame++)
			{
				if (PhoneUi0703Patches.IsPhoneHomeLayoutReady())
				{
					break;
				}
				yield return null;
			}
			yield return (object)new WaitForSeconds(0.75f);
			try
			{
				PhoneUi0703Patches.RepairAllPhoneAppLabels(materialOnly: true);
				PhoneManager val = PhoneManagerAccess.FindPhoneManager();
				if ((Object)(object)val?.m_PhoneGrp != (Object)null)
				{
					PhoneUi0703Patches.RepairPhoneHomeScreen(val.m_PhoneGrp);
				}
				PhoneUi0703Patches.LogPhoneUiDiagnosticsAfterPhoneOpen();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Deferred phone open refresh failed: " + ex.Message));
			}
			_deferredPhoneOpenRefresh = null;
		}

		private void ScheduleDeferredScreenRepair(Transform screenRoot)
		{
			_pendingScreenRoot = screenRoot;
			if (_deferredScreenRepair != null)
			{
				((MonoBehaviour)this).StopCoroutine(_deferredScreenRepair);
			}
			_deferredScreenRepair = ((MonoBehaviour)this).StartCoroutine(DeferredScreenRepairRoutine());
		}

		private IEnumerator DeferredScreenRepairRoutine()
		{
			Transform screenRoot = _pendingScreenRoot;
			if ((Object)(object)screenRoot == (Object)null)
			{
				_deferredScreenRepair = null;
				yield break;
			}
			float waitSeconds = 0.75f;
			for (int frame = 0; frame < 45; frame++)
			{
				if (PhoneUi0703Patches.IsPhoneScreenLayoutReady(screenRoot))
				{
					waitSeconds = 0.05f;
					break;
				}
				yield return null;
			}
			if (waitSeconds > 0f)
			{
				yield return (object)new WaitForSeconds(waitSeconds);
			}
			if ((Object)(object)_pendingScreenRoot != (Object)null)
			{
				for (int frame = 0; frame < 6; frame++)
				{
					if (PhoneUi0703Patches.RepairPhoneScreen(_pendingScreenRoot) > 0)
					{
						break;
					}
					if (PhoneUi0703Patches.IsPhoneScreenLayoutReady(_pendingScreenRoot))
					{
						break;
					}
					yield return (object)new WaitForSeconds(0.1f);
				}
			}
			_pendingScreenRoot = null;
			_deferredScreenRepair = null;
		}

		private void ScheduleDeferredHomeRepair()
		{
			if (_deferredHomeRepair != null)
			{
				((MonoBehaviour)this).StopCoroutine(_deferredHomeRepair);
			}
			_deferredHomeRepair = ((MonoBehaviour)this).StartCoroutine(DeferredHomeRepairRoutine());
		}

		private IEnumerator DeferredHomeRepairRoutine()
		{
			float waitSeconds = 0.75f;
			for (int frame = 0; frame < 45; frame++)
			{
				if (PhoneUi0703Patches.IsPhoneHomeLayoutReady())
				{
					waitSeconds = 0.05f;
					break;
				}
				yield return null;
			}
			if (waitSeconds > 0f)
			{
				yield return (object)new WaitForSeconds(waitSeconds);
			}
			PhoneManager phoneManager = PhoneManagerAccess.TryGetReadyPhoneManager() ?? PhoneManagerAccess.FindPhoneManager();
			if ((Object)(object)phoneManager?.m_PhoneGrp != (Object)null && PhoneUi0703Patches.RepairPhoneHomeScreen(phoneManager.m_PhoneGrp) == 0)
			{
				yield return (object)new WaitForSeconds(0.15f);
				PhoneUi0703Patches.RepairPhoneHomeScreen(phoneManager.m_PhoneGrp);
			}
			_deferredHomeRepair = null;
		}
	}
	internal sealed class PhoneUiRenderSyncBehaviour : MonoBehaviour
	{
		private Coroutine? _openRefresh;

		internal static PhoneUiRenderSyncBehaviour? Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public static void ScheduleOpenRefresh()
		{
			Instance?.BeginOpenRefresh();
		}

		private void BeginOpenRefresh()
		{
			if (_openRefresh != null)
			{
				((MonoBehaviour)this).StopCoroutine(_openRefresh);
			}
			_openRefresh = ((MonoBehaviour)this).StartCoroutine(OpenRefreshRoutine());
		}

		private IEnumerator OpenRefreshRoutine()
		{
			yield return null;
			yield return null;
			if (PhoneUi0703Patches.IsPhoneModeActive)
			{
				PhoneUi0703Patches.SyncVisiblePhoneLabelMaterials();
			}
			_openRefresh = null;
		}
	}
	[BepInPlugin("local.tcgshop.expansionmod0703patch", "TCGShopExpansionMod 0.70.3 Patch", "1.2.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "local.tcgshop.expansionmod0703patch";

		public const string PluginName = "TCGShopExpansionMod 0.70.3 Patch";

		public const string PluginVersion = "1.2.4";

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			PhoneFontMaterialSnapshot.CaptureIfNeeded();
			Harmony val = new Harmony("local.tcgshop.expansionmod0703patch");
			MethodInfo methodInfo = AccessTools.Method(typeof(NewSwappingHandler), "SetCardExtrasImages", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Log.LogError((object)"Could not find NewSwappingHandler.SetCardExtrasImages.");
				return;
			}
			val.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(NewSwappingHandler0703Patches), "SetCardExtrasImages_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.PatchAll(typeof(CardUI0703Patches));
			val.PatchAll(typeof(PackOpening0703Patches));
			val.PatchAll(typeof(MonsterData0703Patches));
			val.PatchAll(typeof(InteractableCard3d0703Patches));
			val.PatchAll(typeof(LightManager0703Patches));
			val.PatchAll(typeof(GradedCardSetCheckStatusScreen0703Patches));
			try
			{
				GameUi0703Patches.ApplyPatches(val);
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Game UI patches failed (continuing Awake): " + ex.GetType().Name + ": " + ex.Message));
			}
			TryPatchPhoneUi(val);
			TryPatchTextureReplacerGuards(val);
			Type type = AccessTools.TypeByName("TCGShopExpansionMod.Patches.PlayerPatches");
			if (type == null)
			{
				Log.LogError((object)"Could not find TCGShopExpansionMod.Patches.PlayerPatches.");
				return;
			}
			MethodInfo methodInfo2 = AccessTools.Method(type, "CardUI_SetCardUI_Postfix", (Type[])null, (Type[])null);
			if (methodInfo2 != null)
			{
				val.Patch((MethodBase)methodInfo2, new HarmonyMethod(typeof(PlayerPatches0703Patches), "CardUI_SetCardUI_Postfix_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				Log.LogWarning((object)"Could not patch CardUI_SetCardUI_Postfix.");
			}
			MethodInfo methodInfo3 = AccessTools.Method(type, "LightManager_Awake_Prefix", (Type[])null, (Type[])null);
			if (methodInfo3 != null)
			{
				val.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(PlayerPatches0703Patches), "LightManager_Awake_Prefix_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				Log.LogWarning((object)"Could not patch LightManager_Awake_Prefix.");
			}
			MethodInfo methodInfo4 = AccessTools.Method(type, "InitOpenSequence_Postfix", (Type[])null, (Type[])null);
			if (methodInfo4 != null)
			{
				val.Patch((MethodBase)methodInfo4, new HarmonyMethod(typeof(PlayerPatches0703Patches), "InitOpenSequence_BlockExpansionPackBack_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				Log.LogWarning((object)"Could not patch InitOpenSequence_Postfix pack-back paint.");
			}
			MethodInfo methodInfo5 = AccessTools.Method(type, "CardUI_SetCardUI_Main_Postfix", (Type[])null, (Type[])null);
			if (methodInfo5 != null)
			{
				val.Patch((MethodBase)methodInfo5, new HarmonyMethod(typeof(TetramonOverlay0703Patches), "SkipMainPostfixForTetramon_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				Log.LogWarning((object)"Could not patch CardUI_SetCardUI_Main_Postfix for Tetramon skip.");
			}
			TryUnpatchExpansionModHook(val, typeof(CollectionBinderFlipAnimCtrl), "EnterViewUpCloseState", type, "CollectionBinderFlipAnimCtrl_EnterViewUpCloseState_Postfix");
			TryUnpatchExpansionModHook(val, typeof(CollectionBinderUI), "OpenSortAlbumScreen", type, "CollectionBinderUI_OpenSortAlbumScreen_HarmonyPostfix", new Type[3]
			{
				typeof(int),
				typeof(int),
				typeof(bool)
			});
			TryPatchExtrasHandlerCardBacks(val);
			((Component)this).gameObject.AddComponent<PackOpeningLateSyncBehaviour>();
			((Component)this).gameObject.AddComponent<PhoneUiLateRepairBehaviour>();
			((Component)this).gameObject.AddComponent<PhoneUiRenderSyncBehaviour>();
			ArtExpanderBridge.TryInitialize();
			Log.LogInfo((object)"Patched ExpansionMod for game 0.70.3 (album/binder unpatch + HandleCards skip + Tetramon overlay). v1.2.4");
		}

		private static void TryUnpatchExpansionModHook(Harmony harmony, Type gameType, string gameMethodName, Type expansionModType, string expansionModPatchMethodName, Type[]? gameMethodParameters = null)
		{
			try
			{
				MethodInfo methodInfo = ((gameMethodParameters == null) ? AccessTools.Method(gameType, gameMethodName, (Type[])null, (Type[])null) : AccessTools.Method(gameType, gameMethodName, gameMethodParameters, (Type[])null));
				MethodInfo methodInfo2 = AccessTools.Method(expansionModType, expansionModPatchMethodName, (Type[])null, (Type[])null);
				if (methodInfo == null || methodInfo2 == null)
				{
					Log.LogWarning((object)("Could not unpatch " + expansionModPatchMethodName + " (method not found)."));
					return;
				}
				harmony.Unpatch((MethodBase)methodInfo, methodInfo2);
				Log.LogInfo((object)$"Unpatched ExpansionMod {expansionModPatchMethodName} from {gameType.Name}.{gameMethodName}.");
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)$"Failed to unpatch {expansionModPatchMethodName}: {ex.GetType().Name}: {ex.Message}");
			}
		}

		private static void TryPatchPhoneUi(Harmony harmony)
		{
			try
			{
				harmony.PatchAll(typeof(PhoneUi0703Patches));
				Log.LogInfo((object)"Phone UI repair patches applied.");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Failed to apply phone UI repair patches: " + ex.Message));
			}
		}

		private static void TryPatchTextureReplacerGuards(Harmony harmony)
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_0146: Expected O, but got Unknown
			try
			{
				TextureReplacerMaterialGuardPatches.ApplyPatches(harmony);
				Log.LogInfo((object)"TextureReplacer material guard patch applied.");
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to apply TextureReplacer material guard patch: " + ex.Message));
			}
			Type type = TextureReplacerPhoneUiGuardPatches.ResolveTextureReplacerPluginType();
			if (type == null)
			{
				Log.LogWarning((object)"TextureReplacer.BepInExPlugin type not found; skipping phone UI guard patches.");
				return;
			}
			int num = 0;
			num += (TryPatchTextureReplacerMethod(harmony, type, "GetCachedTexture", "GetCachedTexture_Prefix") ? 1 : 0);
			num += (TryPatchTextureReplacerMethod(harmony, type, "GetCachedTexture_static", "GetCachedTexture_Static_Prefix") ? 1 : 0);
			num += (TryPatchTextureReplacerMethod(harmony, type, "ForceWhiteIfNotGrayOrWhite", "ForceWhiteIfNotGrayOrWhite_Prefix") ? 1 : 0);
			num += (TryPatchTextureReplacerMethod(harmony, type, "UpdateTitleTexts", "UpdateTitleTexts_Prefix") ? 1 : 0);
			num += (TryPatchTextureReplacerMethod(harmony, type, "ReplaceItemDataInList", "ReplaceItemDataInList_Prefix", "ReplaceItemDataInList_Postfix") ? 1 : 0);
			num += (TryPatchTextureReplacerMethod(harmony, type, "FixPhone", null, "FixPhone_Postfix") ? 1 : 0);
			MethodInfo methodInfo = AccessTools.Method(type, "DoReplace", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Log.LogWarning((object)"TextureReplacer.DoReplace not found; skipping phone font repair hook.");
			}
			else
			{
				try
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(TextureReplacerPhoneUiGuardPatches), "DoReplace_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(TextureReplacerPhoneUiGuardPatches), "DoReplace_Finalizer", (Type[])null), (HarmonyMethod)null);
					num++;
				}
				catch (Exception ex2)
				{
					Log.LogWarning((object)("Failed to patch TextureReplacer.DoReplace for phone UI repair: " + ex2.Message));
				}
			}
			Log.LogInfo((object)$"TextureReplacer phone UI guard patches applied ({num}).");
		}

		private static bool TryPatchTextureReplacerMethod(Harmony harmony, Type textureReplacerType, string methodName, string? prefix = null, string? postfix = null)
		{
			//IL_003d: 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)
			MethodInfo methodInfo = AccessTools.Method(textureReplacerType, methodName, (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Log.LogDebug((object)("TextureReplacer method not found: " + methodName));
				return false;
			}
			try
			{
				HarmonyMethod val = ((prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(TextureReplacerPhoneUiGuardPatches), prefix, (Type[])null));
				HarmonyMethod val2 = ((postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(TextureReplacerPhoneUiGuardPatches), postfix, (Type[])null));
				harmony.Patch((MethodBase)methodInfo, val, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return true;
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Failed to patch TextureReplacer." + methodName + ": " + ex.Message));
				return false;
			}
		}

		private static void TryPatchExtrasHandlerCardBacks(Harmony harmony)
		{
			Type type = AccessTools.TypeByName("TCGShopExpansionMod.Handlers.ExtrasHandler");
			if (type == null)
			{
				Log.LogWarning((object)"Could not patch ExtrasHandler card back methods.");
				return;
			}
			TryPatchMethod(harmony, AccessTools.Method(type, "SetCardBacks", (Type[])null, (Type[])null), "SetCardBacks_Postfix");
			TryPatchMethod(harmony, AccessTools.Method(type, "SetCardBackPackOpening", (Type[])null, (Type[])null), "SetCardBackPackOpening_Postfix");
		}

		private static void TryPatchMethod(Harmony harmony, MethodInfo? original, string postfixName, string? prefixName = null)
		{
			//IL_0037: 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_0059: Expected O, but got Unknown
			if (original == null)
			{
				Log.LogWarning((object)("Could not find ExtrasHandler method for patch " + postfixName + "."));
				return;
			}
			try
			{
				HarmonyMethod val = ((prefixName == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(ExtrasHandler0703Patches), prefixName, (Type[])null));
				harmony.Patch((MethodBase)original, val, new HarmonyMethod(typeof(ExtrasHandler0703Patches), postfixName, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Log.LogError((object)$"Failed to patch {original.DeclaringType?.Name}.{original.Name}: {ex.Message}");
			}
		}
	}
	internal static class SolidWhiteUiSprite
	{
		private static Sprite? _sprite;

		private static Texture2D? _texture;

		public static Sprite Get()
		{
			//IL_0024: 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_0034: 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_0047: Expected O, but got Unknown
			//IL_0054: 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_0060: 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_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_007d: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_sprite != (Object)null && (Object)(object)_texture != (Object)null)
			{
				return _sprite;
			}
			_texture = new Texture2D(2, 2, (TextureFormat)4, false)
			{
				name = "SolidWhiteUi0703",
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			_texture.SetPixels((Color[])(object)new Color[4]
			{
				Color.white,
				Color.white,
				Color.white,
				Color.white
			});
			_texture.Apply(false, true);
			_sprite = Sprite.Create(_texture, new Rect(0f, 0f, 2f, 2f), new Vector2(0.5f, 0.5f), 100f);
			((Object)_sprite).name = "SolidWhiteUi0703";
			return _sprite;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "TCGShopExpansionMod0703Patch";

		public const string PLUGIN_NAME = "TCGShopExpansionMod 0.70.3 Compatibility Patch";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace TCGShopExpansionMod0703Patch.Patches
{
	internal static class CardUI0703Patches
	{
		private const int MaxSuppressedSetCardUiWarnings = 5;

		private static int SuppressedSetCardUiWarningCount;

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(CardUI), "SetCardUI", new Type[] { typeof(CardData) })]
		public static Exception SetCardUI_Finalizer(CardUI __instance, CardData cardData, Exception __exception)
		{
			try
			{
				ApplyTetramonPresentation(__instance, cardData);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Pokemon card overlay failed: " + ex.GetType().Name + ": " + ex.Message));
			}
			if (__exception != null)
			{
				LogSuppressedSetCardUiError(__exception);
				return null;
			}
			return null;
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(CardUI), "SetCardUI", new Type[] { typeof(CardData) })]
		public static void SetCardUI_Postfix_Last(CardUI __instance, CardData cardData)
		{
			try
			{
				ApplyTetramonPresentation(__instance, cardData);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Pokemon card overlay (late) failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CardUI), "SetBrightness", new Type[] { typeof(float) })]
		public static void SetBrightness_Postfix(CardUI __instance)
		{
			try
			{
				TetramonOverlay0703Patches.SuppressTetramonHoverChromeBleed(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Pokemon hover chrome fix failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(CardUI), "SetFoilMaterialList")]
		public static void SetFoilMaterialList_Postfix(CardUI __instance)
		{
			try
			{
				TetramonOverlay0703Patches.RepairAlbumHoFoilMainTex(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Album foil MainTex repair failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(CardUI), "SetFoilBlendedMaterialList")]
		public static void SetFoilBlendedMaterialList_Postfix(CardUI __instance)
		{
			try
			{
				TetramonOverlay0703Patches.RepairAlbumHoFoilMainTex(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Album foil blended MainTex repair failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(CardUI), "ShowGradedCardCase")]
		public static void ShowGradedCardCase_Postfix(CardUI __instance, bool isShow)
		{
			if (!isShow)
			{
				return;
			}
			try
			{
				TetramonOverlay0703Patches.AfterGradedCaseLayoutChanged(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Graded case face repair failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(CardUI), "ShowSimplifiedCullingGradedCardCase")]
		public static void ShowSimplifiedCullingGradedCardCase_Postfix(CardUI __instance, bool isShow)
		{
			if (!isShow)
			{
				return;
			}
			try
			{
				TetramonOverlay0703Patches.AfterGradedCaseLayoutChanged(__instance, albumSimplified: true);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Simplified graded case face repair failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(Card3dUIGroup), "SetSimplifyCardDistanceCull")]
		public static void SetSimplifyCardDistanceCull_Postfix(Card3dUIGroup __instance, bool isCull)
		{
			try
			{
				TetramonOverlay0703Patches.AfterSimplifyCardDistanceCull(__instance, isCull);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Simplify graded cull face repair failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static void ApplyTetramonPresentation(CardUI __instance, CardData cardData)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null) && cardData != null)
			{
				if (cardData.cardGrade > 0)
				{
					TetramonOverlay0703Patches.ApplyGradedCardPresentationPublic(__instance, cardData);
				}
				else if ((int)cardData.expansionType != 0)
				{
					TetramonOverlay0703Patches.ApplyNonTetramonPresentation(__instance, cardData);
				}
				else
				{
					TetramonOverlay0703Patches.SetCardUI_ApplyTetramonOverlay(__instance, cardData);
				}
			}
		}

		private static void LogSuppressedSetCardUiError(Exception exception)
		{
			SuppressedSetCardUiWarningCount++;
			if (SuppressedSetCardUiWarningCount <= 5)
			{
				Plugin.Log.LogWarning((object)("Suppressed ExpansionMod SetCardUI error: " + exception.GetType().Name));
				if (SuppressedSetCardUiWarningCount == 5)
				{
					Plugin.Log.LogWarning((object)"Further ExpansionMod SetCardUI suppressions will be silent this session (HandleCards is skipped on 0.70.3).");
				}
			}
		}
	}
	internal static class ExtrasHandler0703Patches
	{
		public static void SetCardBacks_Postfix(Card3dUIGroup __0)
		{
			AfterExpansionModSetCardBack(__0);
		}

		public static void SetCardBackPackOpening_Postfix(Card3dUIGroup __0)
		{
			AfterExpansionModSetCardBack(__0);
		}

		private static void AfterExpansionModSetCardBack(Card3dUIGroup card3dUI)
		{
			//IL_0073: 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)
			CardUI val = card3dUI?.m_CardUI;
			CardData val2 = ((val != null) ? val.GetCardData() : null);
			if ((Object)(object)val == (Object)null || val2 == null)
			{
				return;
			}
			if (val2.cardGrade > 0)
			{
				InteractableCard3d val3 = Card3dInteractableRegistry.FindForCardUi(val);
				if ((Object)(object)val3 != (Object)null && val3.IsDisplayedOnShelf())
				{
					TetramonOverlay0703Patches.ApplyGradedHeldPresentation(val, card3dUI);
					return;
				}
				if ((int)val2.expansionType != 0)
				{
					TetramonOverlay0703Patches.ApplyGradedCardPresentationPublic(val, val2);
				}
				else
				{
					TetramonOverlay0703Patches.ApplyGradedHeldPresentation(val, card3dUI);
				}
				TetramonOverlay0703Patches.HideGradedCardBackFaces(val);
			}
			else if ((int)val2.expansionType != 0)
			{
				if (!PackOpeningState.IsPackOpeningInProgress())
				{
					if (CardUiDisplayContext.ShouldUseRotatableWorldCardBack(val))
					{
						TetramonOverlay0703Patches.ConfigureCard3dForFrontDisplay(val);
					}
					else
					{
						TetramonOverlay0703Patches.ApplyFlatScreenCardPresentation(val, card3dUI);
					}
				}
			}
			else if (PackOpeningState.IsPackOpeningInProgress())
			{
				if (PackOpeningState.ShouldShowFrontDuringPackFlip(card3dUI))
				{
					TetramonOverlay0703Patches.ApplyPackOpeningFlipFrontPresentation(val, card3dUI);
				}
				else
				{
					TetramonOverlay0703Patches.ConfigurePackOpeningCardPresentation(val, card3dUI);
				}
			}
			else if (CardUiDisplayContext.IsBinderAlbumCard(val) || CardUiDisplayContext.IsFlatAlbumOrBinderCard(val) || !CardUiDisplayContext.ShouldUseRotatableWorldCardBack(val))
			{
				TetramonOverlay0703Patches.ApplyFlatScreenCardPresentation(val, card3dUI);
			}
			else
			{
				TetramonOverlay0703Patches.SyncTetramonCardBackAfterExpansionMod(val, card3dUI);
			}
		}
	}
	internal static class GameUi0703Patches
	{
		public static int ApplyPatches(Harmony harmony)
		{
			int num = 0;
			num += TryPostfix(harmony, typeof(EndOfDayReportScreen), "OnPressGoNextDay", "EndOfDay_OnPressGoNextDay_Postfix");
			num += TryPostfix(harmony, typeof(EndOfDayReportScreen), "OnPressGoNextButton", "EndOfDay_OnPressGoNextButton_Postfix");
			num += TryPostfix(harmony, typeof(EndOfDayReportScreen), "DelayGoNextDay", "EndOfDay_DelayGoNextDay_Postfix");
			num += TryPostfix(harmony, typeof(UI_CashCounterScreen), "OnEnable", "CashCounter_OnEnable_Postfix");
			num += TryPostfix(harmony, typeof(UI_CashCounterScreen), "Init", "CashCounter_Init_Postfix");
			num += TryPostfix(harmony, typeof(UI_CashCounterScreen), "OnItemScanned", "CashCounter_OnItemScanned_Postfix");
			num += TryPostfix(harmony, typeof(UI_CashCounterScreen), "OnCardScanned", "CashCounter_OnCardScanned_Postfix");
			num += TryPostfix(harmony, typeof(UI_CreditCardScreen), "EnableCreditCardMode", "CreditCard_EnableCreditCardMode_Postfix");
			num += TryPostfix(harmony, typeof(UI_CheckoutItemBar), "AddScannedItem", "CheckoutItemBar_AddScannedItem_Postfix");
			Plugin.Log.LogInfo((object)$"Game UI patches applied ({num}).");
			return num;
		}

		private static int TryPostfix(Harmony harmony, Type targetType, string methodName, string patchMethodName)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(targetType, methodName, (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Plugin.Log.LogWarning((object)$"Game UI skip: {targetType.Name}.{methodName} not found.");
					return 0;
				}
				MethodInfo methodInfo2 = AccessTools.Method(typeof(GameUi0703Patches), patchMethodName, (Type[])null, (Type[])null);
				if (methodInfo2 == null)
				{
					Plugin.Log.LogWarning((object)("Game UI skip: patch method " + patchMethodName + " missing."));
					return 0;
				}
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return 1;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)$"Game UI patch {targetType.Name}.{methodName} failed: {ex.GetType().Name}: {ex.Message}");
				return 0;
			}
		}

		public static void EndOfDay_OnPressGoNextDay_Postfix()
		{
			ClearNextDayPrompt("OnPressGoNextDay");
		}

		public static void EndOfDay_OnPressGoNextButton_Postfix()
		{
			ClearNextDayPrompt("OnPressGoNextButton");
		}

		public static void EndOfDay_DelayGoNextDay_Postfix()
		{
			ClearNextDayPrompt("DelayGoNextDay");
		}

		private static void ClearNextDayPrompt(string reason)
		{
			try
			{
				GameUIScreen.HideEnterGoNextDayIndicatorVisible();
				GameUIScreen.ResetEnterGoNextDayIndicatorVisible();
				GameUIScreen instance = CSingleton<GameUIScreen>.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					if ((Object)(object)instance.m_PressEnterGoNextDayIndicator != (Object)null)
					{
						instance.m_PressEnterGoNextDayIndicator.SetActive(false);
					}
					if ((Object)(object)instance.m_PressEnterGoNextDayIndicatorText != (Object)null)
					{
						instance.m_PressEnterGoNextDayIndicatorText.SetActive(false);
					}
					if ((Object)(object)instance.m_GoNextDayIconGrp != (Object)null)
					{
						((Component)instance.m_GoNextDayIconGrp).gameObject.SetActive(false);
					}
					Plugin.Log.LogInfo((object)("Cleared next-day prompt (" + reason + ")."));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Clear next-day prompt failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		public static void CashCounter_OnEnable_Postfix(UI_CashCounterScreen __instance)
		{
			RepairCheckoutScreen(((Object)(object)__instance != (Object)null) ? ((Component)__instance).transform : null, "CashCounter.OnEnable");
		}

		public static void CashCounter_Init_Postfix(UI_CashCounterScreen __instance)
		{
			RepairCheckoutScreen(((Object)(object)__instance != (Object)null) ? ((Component)__instance).transform : null, "CashCounter.Init");
		}

		public static void CashCounter_OnItemScanned_Postfix(UI_CashCounterScreen __instance)
		{
			RepairCheckoutScreen(((Object)(object)__instance != (Object)null) ? ((Component)__instance).transform : null, "CashCounter.OnItemScanned");
		}

		public static void CashCounter_OnCardScanned_Postfix(UI_CashCounterScreen __instance)
		{
			RepairCheckoutScreen(((Object)(object)__instance != (Object)null) ? ((Component)__instance).transform : null, "CashCounter.OnCardScanned");
		}

		public static void CreditCard_EnableCreditCardMode_Postfix(UI_CreditCardScreen __instance)
		{
			RepairCheckoutScreen(((Object)(object)__instance != (Object)null) ? ((Component)__instance).transform : null, "CreditCard.EnableCreditCardMode");
		}

		public static void CheckoutItemBar_AddScannedItem_Postfix(UI_CheckoutItemBar __instance)
		{
			RepairCheckoutScreen(((Object)(object)__instance != (Object)null) ? ((Component)__instance).transform : null, "CheckoutItemBar.AddScannedItem");
		}

		private static void RepairCheckoutScreen(Transform? root, string reason)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			try
			{
				if (!TutorialManager.IsGameUIVisible())
				{
					TutorialManager.SetGameUIVisible(true);
					Plugin.Log.LogInfo((object)("Restored Game UI visibility during " + reason + "."));
				}
				InteractionPlayerController instance = CSingleton<InteractionPlayerController>.Instance;
				MaterialFadeInOut val = (((Object)(object)instance != (Object)null) ? instance.m_BlackBGWorldUIFade : null);
				if ((Object)(object)val != (Object)null)
				{
					val.SetFadeOut(0f, 0f);
				}
				if ((Object)(object)((Component)root).gameObject != (Object)null && !((Component)root).gameObject.activeSelf)
				{
					((Component)root).gameObject.SetActive(true);
				}
				CashRegisterTmpRepair.RepairHierarchy(root, reason);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)$"Checkout UI repair failed ({reason}): {ex.GetType().Name}: {ex.Message}");
			}
		}
	}
	internal static class GradedCardSetCheckStatusScreen0703Patches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(GradedCardSetCheckStatusScreen), "UpdateSetUI")]
		public static bool UpdateSetUI_Prefix(GradedCardSetCheckStatusScreen __instance, int setSlotIndex)
		{
			try
			{
				List<GradeCardPanelUI> gradeCardPanelUIList = __instance.m_GradeCardPanelUIList;
				if (gradeCardPanelUIList == null || gradeCardPanelUIList.Count == 0)
				{
					return false;
				}
				List<GradeCardSubmitSet> gradeCardInProgressList = CPlayerData.m_GradeCardInProgressList;
				if (gradeCardInProgressList != null && setSlotIndex >= 0 && setSlotIndex < gradeCardInProgressList.Count && gradeCardInProgressList[setSlotIndex] != null)
				{
					GradeCardSubmitSet val = gradeCardInProgressList[setSlotIndex];
					InventoryBase instance = CSingleton<InventoryBase>.Instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						MonsterData_ScriptableObject monsterData_SO = instance.m_MonsterData_SO;
						obj = ((monsterData_SO != null) ? monsterData_SO.GetGradeCardServiceData(val.m_ServiceLevel) : null);
					}
					GradeCardServiceData val2 = (GradeCardServiceData)obj;
					if (val2 != null && (Object)(object)__instance.m_SetNameText != (Object)null)
					{
						string translation = LocalizationManager.GetTranslation("XXX Set YYY", true, 0, true, false, (GameObject)null, (string)null, true);
						translation = translation.Replace("XXX", val2.GetServiceName());
						translation = translation.Replace("YYY", (setSlotIndex + 1).ToString());
						((TMP_Text)__instance.m_SetNameText).text = translation;
					}
					if ((Object)(object)__instance.m_DeliveryDaysText != (Object)null && val2 != null)
					{
						int num = val2.m_ServiceDays - val.m_DayPassed;
						string text = ((num > 1) ? "Delivery in XXX days" : "Delivery in XXX day");
						((TMP_Text)__instance.m_DeliveryDaysText).text = LocalizationManager.GetTranslation(text, true, 0, true, false, (GameObject)null, (string)null, true).Replace("XXX", num.ToString());
					}
					List<CardData> cardDataList = val.m_CardDataList;
					int num2 = cardDataList?.Count ?? 0;
					if (num2 > gradeCardPanelUIList.Count)
					{
						Plugin.Log.LogWarning((object)$"Graded set slot {setSlotIndex} has {num2} cards but only {gradeCardPanelUIList.Count} panels; clamping display.");
					}
					for (int i = 0; i < gradeCardPanelUIList.Count; i++)
					{
						GradeCardPanelUI val3 = gradeCardPanelUIList[i];
						if (!((Object)(object)val3 == (Object)null))
						{
							CardData val4 = ((cardDataList != null && i < num2) ? cardDataList[i] : null);
							val3.UpdateCardUI(val4);
						}
					}
				}
				else
				{
					for (int j = 0; j < gradeCardPanelUIList.Count; j++)
					{
						GradeCardPanelUI obj2 = gradeCardPanelUIList[j];
						if (obj2 != null)
						{
							obj2.UpdateCardUI((CardData)null);
						}
					}
				}
				int num3 = ((AccessTools.Field(typeof(GradedCardSetCheckStatusScreen), "m_PageMaxIndex")?.GetValue(__instance) is int num4) ? num4 : Math.Max(0, (gradeCardInProgressList?.Count ?? 1) - 1));
				int num5 = ((AccessTools.Field(typeof(GradedCardSetCheckStatusScreen), "m_PageIndex")?.GetValue(__instance) is int num6) ? num6 : setSlotIndex);
				if ((Object)(object)__instance.m_PageText != (Object)null)
				{
					((TMP_Text)__instance.m_PageText).text = $"{setSlotIndex + 1} / {num3 + 1}";
				}
				if ((Object)(object)__instance.m_NextButton != (Object)null)
				{
					((Selectable)__instance.m_NextButton).interactable = num5 < num3;
				}
				if ((Object)(object)__instance.m_PreviousButton != (Object)null)
				{
					((Selectable)__instance.m_PreviousButton).interactable = num5 > 0;
				}
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("GradedCardSetCheckStatusScreen.UpdateSetUI safe path failed: " + ex.GetType().Name + ": " + ex.Message));
				return true;
			}
		}
	}
	internal static class InteractableCard3d0703Patches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(InteractableCardCompartment), "SetCardOnShelf")]
		public static void SetCardOnShelf_Postfix(InteractableCard3d card)
		{
			if (!((Object)(object)card?.m_Card3dUI == (Object)null) && card.IsDisplayedOnShelf())
			{
				Card3dInteractableRegistry.Register(card.m_Card3dUI, card);
				EnableDisplayCulling(card.m_Card3dUI);
				RefreshDisplayPresentation(card);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InteractableCard3d), "SetIsDisplayedOnShelf")]
		public static void SetIsDisplayedOnShelf_Postfix(InteractableCard3d __instance, bool isDisplayedOnShelf)
		{
			if (isDisplayedOnShelf && !((Object)(object)__instance.m_Card3dUI == (Object)null))
			{
				Card3dInteractableRegistry.Register(__instance.m_Card3dUI, __instance);
				EnableDisplayCulling(__instance.m_Card3dUI);
				RefreshDisplayPresentation(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InteractableCard3d), "Start")]
		public static void Start_Postfix(InteractableCard3d __instance)
		{
			if ((Object)(object)__instance.m_Card3dUI != (Object)null && __instance.m_IsCard3dUIFollow)
			{
				Card3dInteractableRegistry.Register(__instance.m_Card3dUI, __instance);
				if (__instance.IsDisplayedOnShelf())
				{
					EnableDisplayCulling(__instance.m_Card3dUI);
					RefreshDisplayPresentation(__instance);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InteractableCard3d), "SetCardUIFollow")]
		public static void SetCardUIFollow_Postfix(InteractableCard3d __instance, Card3dUIGroup card3dUI)
		{
			Card3dInteractableRegistry.Register(card3dUI, __instance);
			if (__instance.IsDisplayedOnShelf())
			{
				EnableDisplayCulling(card3dUI);
				RefreshDisplayPresentation(__instance);
				return;
			}
			CardUI val = card3dUI?.m_CardUI;
			if (!((Object)(object)val == (Object)null))
			{
				CardData cardData = val.GetCardData();
				if (cardData != null && cardData.cardGrade > 0)
				{
					TetramonOverlay0703Patches.ApplyGradedHeldPresentation(val, card3dUI);
				}
				else if (__instance.m_IsCardAlbumCard || (Object)(object)__instance.m_CollectionBinderFlipAnimCtrl != (Object)null || !CardUiDisplayContext.ShouldUseRotatableWorldCardBack(val))
				{
					TetramonOverlay0703Patches.ApplyFlatScreenCardPresentation(val, card3dUI);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(InteractableCard3d), "OnDestroyed")]
		public static void OnDestroyed_Prefix(InteractableCard3d __instance)
		{
			Card3dInteractableRegistry.UnregisterInteractable(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InteractableCard3d), "OnFinishLerp")]
		public static void OnFinishLerp_Postfix(InteractableCard3d __instance)
		{
			if (__instance.IsDisplayedOnShelf())
			{
				RefreshDisplayPresentation(__instance);
			}
		}

		private static void EnableDisplayCulling(Card3dUIGroup card3d)
		{
			card3d.m_IgnoreCulling = true;
			card3d.SetAlwaysCulling(false, true);
			card3d.SetSimplifyCardDistanceCull(false);
			if ((Object)(object)card3d.m_CardUIAnimGrp != (Object)null)
			{
				((Component)card3d.m_CardUIAnimGrp).gameObject.SetActive(true);
			}
			card3d.m_CardUI.SetFoilCullListVisibility(true);
			card3d.m_CardUI.ResetFarDistanceCull();
			TetramonOverlay0703Patches.ReassertWorldCardFoilPolicy(card3d.m_CardUI);
		}

		private static void RefreshDisplayPresentation(InteractableCard3d interactable)
		{
			CardUI val = interactable.m_Card3dUI?.m_CardUI;
			CardData val2 = ((val != null) ? val.GetCardData() : null);
			if ((Object)(object)val == (Object)null || val2 == null)
			{
				return;
			}
			TetramonOverlay0703Patches.ReassertWorldCardFoilPolicy(val);
			if (CardUiDisplayContext.ShouldUseRotatableWorldCardBack(val))
			{
				if (val2.cardGrade > 0)
				{
					TetramonOverlay0703Patches.ApplyGradedHeldPresentation(val, interactable.m_Card3dUI);
				}
				else
				{
					TetramonOverlay0703Patches.ConfigureCard3dForFrontDisplay(val);
				}
			}
		}

		public static void AlignDisplayCardUiToSlot(InteractableCard3d interactable)
		{
			//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_0046: 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_005c: 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_0079: 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: Unknown result type (might be due to invalid IL or missing references)
			Card3dUIGroup card3dUI = interactable.m_Card3dUI;
			CardUI val = card3dUI?.m_CardUI;
			if (!((Object)(object)card3dUI?.m_CardUIAnimGrp == (Object)null) && !((Object)(object)val?.m_CardFront == (Object)null))
			{
				Vector3 toCustomer = ResolveDisplayCustomerViewDirection(interactable);
				float num = ResolveDisplayAnimGroupTargetY(interactable, val, toCustomer);
				Transform cardUIAnimGrp = card3dUI.m_CardUIAnimGrp;
				Vector3 localEulerAngles = cardUIAnimGrp.localEulerAngles;
				if (Mathf.Abs(Mathf.DeltaAngle(localEulerAngles.y, num)) > 1f)
				{
					cardUIAnimGrp.localRotation = Quaternion.Euler(localEulerAngles.x, num, localEulerAngles.z);
				}
			}
		}

		private static float ResolveDisplayAnimGroupTargetY(InteractableCard3d interactable, CardUI cardUi, Vector3 toCustomer)
		{
			//IL_0062: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			Transform val = ResolvePutCardLocation(interactable);
			if ((Object)(object)val != (Object)null)
			{
				Vector3 forward = val.forward;
				forward.y = 0f;
				if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
				{
					((Vector3)(ref forward)).Normalize();
					if (!(Vector3.Dot(forward, toCustomer) >= 0f))
					{
						return 180f;
					}
					return 0f;
				}
			}
			if (!(Vector3.Dot(cardUi.m_CardFront.transform.forward, toCustomer) >= 0f))
			{
				return 0f;
			}
			return 180f;
		}

		private static Transform? ResolvePutCardLocation(InteractableCard3d interactable)
		{
			InteractableCardCompartment componentInParent = ((Component)interactable).GetComponentInParent<InteractableCardCompartment>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return null;
			}
			Card3dUIGroup card3dUI = interactable.m_Card3dUI;
			object obj;
			if (card3dUI == null)
			{
				obj = null;
			}
			else
			{
				CardUI cardUI = card3dUI.m_CardUI;
				obj = ((cardUI != null) ? cardUI.GetCardData() : null);
			}
			CardData val = (CardData)obj;
			if (componentInParent.m_NoneGradedCardUseAltCardLocation && val != null && val.cardGrade == 0 && (Object)(object)componentInParent.m_PutCardLocationAlt != (Object)null)
			{
				return componentInParent.m_PutCardLocationAlt;
			}
			return componentInParent.m_PutCardLocation;
		}

		private static Vector3 ResolveDisplayCustomerViewDirection(InteractableCard3d interactable)
		{
			//IL_0031: 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_0075: 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_0047: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)interactable).GetComponentInParent<InteractableCardCompartment>()?.m_CustomerStandLoc;
			Transform val2 = ResolvePutCardLocation(interactable);
			Vector3 val3 = (((Object)(object)val2 != (Object)null) ? val2.position : ((Component)interactable).transform.position);
			if ((Object)(object)val != (Object)null)
			{
				Vector3 val4 = val.position - val3;
				val4.y = 0f;
				if (((Vector3)(ref val4)).sqrMagnitude > 0.0001f)
				{
					return ((Vector3)(ref val4)).normalized;
				}
			}
			return ((Component)interactable).transform.forward;
		}
	}
	internal static class LightManager0703Patches
	{
		[HarmonyFinalizer]
		[HarmonyPatch(typeof(LightManager), "Awake")]
		public static Exception Awake_Finalizer(Exception __exception)
		{
			if (__exception == null)
			{
				return null;
			}
			Plugin.Log.LogWarning((object)("Suppressed ExpansionMod LightManager.Awake error: " + __exception.GetType().Name));
			return null;
		}
	}
	internal static class MonsterData0703Patches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(MonsterData_ScriptableObject), "GetCardBackSprite")]
		public static void GetCardBackSprite_Postfix(ECardExpansionType cardExpansionType, ref Sprite __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)cardExpansionType == 0 && PackOpeningState.IsPackOpeningInProgress())
			{
				Sprite val = CardExtrasCacheAccess.TryGetUiCardBackSprite();
				if ((Object)(object)val != (Object)null)
				{
					__result = val;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MonsterData_ScriptableObject), "GetGradedCardScratchTexture")]
		public static bool GetGradedCardScratchTexture_Prefix(ref Sprite __result)
		{
			__result = GradedScratchClearSprite.Get();
			return false;
		}
	}
	internal static class NewSwappingHandler0703Patches
	{
		public static bool SetCardExtrasImages_Prefix()
		{
			Plugin.Log.LogDebug((object)"Skipping SetCardExtrasImages (obsolete global lists on 0.70.3).");
			return false;
		}
	}
	internal static class PackOpening0703Patches
	{
		private const int PackBackdropRenderQueue = 2999;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CardOpeningSequence), "Start")]
		public static void Start_Prefix(CardOpeningSequence __instance)
		{
			PackOpeningRefsBootstrap.TryBootstrap(__instance);
			PackOpeningRefsBootstrap.TryEnsureCardDataPools(__instance);
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(CardOpeningSequence), "Start")]
		public static Exception Start_Finalizer(CardOpeningSequence __instance, Exception __exception)
		{
			PackOpeningRefsBootstrap.TryBootstrap(__instance);
			PackOpeningRefsBootstrap.TryRecoverStart(__instance);
			if (__exception != null)
			{
				Plugin.Log.LogWarning((object)("CardOpeningSequence.Start recovered after bootstrap: " + __exception.GetType().Name));
				return null;
			}
			return null;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CardOpeningSequence), "ReadyingCardPack")]
		public static bool ReadyingCardPack_Prefix(CardOpeningSequence __instance, Item item)
		{
			PackOpeningRefsBootstrap.TryBootstrap(__instance);
			PackOpeningRefsBootstrap.TryEnsureCardDataPools(__instance);
			PackOpeningRefsBootstrap.LogPackOpenReadiness(__instance);
			PackOpeningRefsBootstrap.ResetOpenDiagnostics();
			TetramonOverlay0703Patches.ResetBackMeshDiagnostics();
			RestorePackVisuals(__instance);
			if (PackOpeningRefsBootstrap.TryRunReadyingCardPack(__instance, item))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CardOpeningSequence), "GetPackContent")]
		public static void GetPackContent_Prefix(CardOpeningSequence __instance)
		{
			PackOpeningRefsBootstrap.TryBootstrap(__instance);
			PackOpeningRefsBootstrap.TryEnsureCardDataPools(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CardOpeningSequence), "InitOpenSequence")]
		public static bool InitOpenSequence_Prefix(CardOpeningSequence __instance)
		{
			PackOpeningRefsBootstrap.TryBootstrap(__instance);
			PackOpeningRefsBootstrap.TryEnsureCardDataPools(__instance);
			PackOpeningRefsBootstrap.TryRecoverStart(__instance);
			PackOpeningRefsBootstrap.EnsurePackOpenFeedbackIcons(__instance);
			ArtExpanderBridge.DumpBackAssetNames();
			if (PackOpeningRefsBootstrap.TryRunInitOpenSequence(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CardOpeningSequence), "OpenScreen", new Type[]
		{
			typeof(ECollectionPackType),
			typeof(bool),
			typeof(bool)
		})]
		public static void OpenScreen_Prefix(CardOpeningSequence __instance)
		{
			PackOpeningRefsBootstrap.TryBootstrap(__instance);
			PackOpeningRefsBootstrap.TryEnsureCardDataPools(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CardOpeningSequence), "OpenScreen", new Type[]
		{
			typeof(ECollectionPackType),
			typeof(bool),
			typeof(bool)
		})]
		public static void OpenScreen_Postfix(CardOpeningSequence __instance)
		{
			if (PackOpeningState.ShouldSyncPackPresentation(__instance))
			{
				PackOpeningState.SyncFromSequence(__instance);
				SyncAllPackOpeningPresentations(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CardOpeningSequence), "InitOpenSequence")]
		public static void InitOpenSequence_Postfix(CardOpeningSequence __instance)
		{
			if (PackOpeningState.ShouldSyncPackPresentation(__instance))
			{
				PackOpeningState.SyncFromSequence(__instance);
				SyncAllPackOpeningPresentations(__instance);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CardOpeningSequence), "Update")]
		public static void Update_Prefix(CardOpeningSequence __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && __instance.IsActive())
			{
				PackOpeningRefsBootstrap.TryBootstrap(__instance);
				PackOpeningRefsBootstrap.EnsurePackOpenFeedbackIcons(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(CardOpeningSequence), "Update")]
		public static void CardOpeningSequence_Update_Last(CardOpeningSequence __instance)
		{
			if (!PackOpeningState.ShouldSyncPackPresentation(__instance))
			{
				return;
			}
			try
			{
				PackOpeningState.SyncFromSequence(__instance);
				int stateIndex = __instance.m_StateIndex;
				EnsureBackdropBelowPackCards();
				PackOpeningRefsBootstrap.DumpCardStackDiagnostics(__instance);
				if (stateIndex >= 0 && stateIndex < 7)
				{
					SyncAllPackOpeningPresentations(__instance);
				}
				else if (stateIndex >= 7)
				{
					PackOpeningRefsBootstrap.DumpFanDiagnostics(__instance);
					HidePackVisualsDuringFanRow(__instance);
					SyncAllFanRowPresentations(__instance);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Pack opening sync failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}

		private static void EnsureBackdropBelowPackCards()
		{
			InteractionPlayerController instance = CSingleton<InteractionPlayerController>.Instance;
			MaterialFadeInOut val = (((Object)(object)instance != (Object)null) ? instance.m_BlackBGWorldUIFade : null);
			MeshRenderer val2 = (((Object)(object)val != (Object)null) ? val.m_Mesh : null);
			if (!((Object)(object)val2 == (Object)null))
			{
				Material material = ((Renderer)val2).material;
				if ((Object)(object)material != (Object)null && material.renderQueue != 2999)
				{
					material.renderQueue = 2999;
				}
			}
		}

		public static void RestorePackVisuals(CardOpeningSequence sequence)
		{
			if (!((Object)(object)sequence.m_CardPackMesh == (Object)null))
			{
				((Renderer)sequence.m_CardPackMesh).enabled = true;
				Transform val = ((Component)sequence.m_CardPackMesh).transform;
				if ((Object)(object)val.parent != (Object)null)
				{
					val = val.parent;
				}
				Renderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<Renderer>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = true;
				}
			}
		}

		public static void HidePackVisualsDuringFanRow(CardOpeningSequence sequence)
		{
			if ((Object)(object)sequence.m_CardPackMesh != (Object)null)
			{
				((Renderer)sequence.m_CardPackMesh).enabled = false;
				((Renderer)sequence.m_CardPackMesh).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)sequence.m_CardPackMesh).receiveShadows = false;
				Transform val = ((Component)sequence.m_CardPackMesh).transform;
				if ((Object)(object)val.parent != (Object)null)
				{
					val = val.parent;
				}
				Renderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<Renderer>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = false;
					componentsInChildren[i].shadowCastingMode = (ShadowCastingMode)0;
				}
			}
		}

		public static void SyncAllPackOpeningPresentations(CardOpeningSequence sequence)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (sequence.m_Card3dUIList == null)
			{
				return;
			}
			for (int i = 0; i < sequence.m_Card3dUIList.Count; i++)
			{
				Card3dUIGroup val = sequence.m_Card3dUIList[i];
				CardUI val2 = val?.m_CardUI;
				CardData val3 = ((val2 != null) ? val2.GetCardData() : null);
				if (!((Object)(object)val2 == (Object)null) && val3 != null && (int)val3.expansionType == 0)
				{
					TetramonOverlay0703Patches.ConfigurePackOpeningCardPresentation(val2, val);
					if (PackOpeningState.IsCardFrontTowardCamera(val))
					{
						TetramonOverlay0703Patches.SetCardUI_ApplyTetramonOverlay(val2, val3, forceFrontOverlay: true);
					}
				}
			}
		}

		public static void SyncAllFanRowPresentations(CardOpeningSequence sequence)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (sequence.m_Card3dUIList == null)
			{
				return;
			}
			for (int i = 0; i < sequence.m_Card3dUIList.Count; i++)
			{
				Card3dUIGroup val = sequence.m_Card3dUIList[i];
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeSelf)
				{
					CardUI cardUI = val.m_CardUI;
					CardData val2 = ((cardUI != null) ? cardUI.GetCardData() : null);
					if (!((Object)(object)cardUI == (Object)null) && val2 != null && (int)val2.expansionType == 0)
					{
						TetramonOverlay0703Patches.ApplyPackOpeningFanRowPresentation(cardUI, val);
						TetramonOverlay0703Patches.SetCardUI_ApplyTetramonOverlay(cardUI, val2, forceFrontOverlay: true);
					}
				}
			}
		}
	}
	internal static class PhoneUi0703Patches
	{
		private readonly struct PhoneLabelGeometry
		{
			public float FontSize { get; }

			public bool AutoSizing { get; }

			public Vector3 LocalScale { get; }

			public Vector3 LocalPosition { get; }

			public bool WordWrap { get; }

			public TextOverflowModes Overflow { get; }

			public PhoneLabelGeometry(float fontSize, bool autoSizing, Vector3 localScale, Vector3 localPosition, bool wordWrap, TextOverflowModes overflow)
			{
				//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_0016: 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_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)
				FontSize = fontSize;
				AutoSizing = autoSizing;
				LocalScale = localScale;
				LocalPosition = localPosition;
				WordWrap = wordWrap;
				Overflow = overflow;
			}
		}

		private static readonly Dictionary<string, string> PhoneButtonDefaultLabels = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["PhoneButtonGrp_ScannerOrder"] = "Scanner",
			["PhoneButtonGrp_HostTournament"] = "Tournament",
			["PhoneButtonGrp_CameraTakePhoto"] = "Camera",
			["PhoneButtonGrp_PhotoGallery"] = "Gallery",
			["PhoneButtonGrp_RestockBoardGame"] = "Board Games",
			["PhoneButtonGrp_CustomerReview"] = "Reviews",
			["PhoneButtonGrp_Restock"] = "Restock",
			["PhoneButtonGrp_Furniture"] = "Furniture",
			["PhoneButtonGrp_ExpandShop"] = "Expand",
			["PhoneButtonGrp_Setting"] = "Settings",
			["PhoneButtonGrp_GameEvent"] = "Events",
			["PhoneButtonGrp_PriceCheck"] = "Check Price",
			["PhoneButtonGrp_Hiring"] = "Hire",
			["PhoneButtonGrp_RentBill"] = "Bills",
			["PhoneButtonGrp_BuyDecoration"] = "Decorate",
			["PhoneButtonGrp_Grading"] = "Grade"
		};

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

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

		private static bool fontsCached;

		private static bool loggedPhoneUiDiagnostics;

		private static bool loggedSubScreenLayering;

		private static readonly string[] TmpShaderNames = new string[2] { "TextMeshPro/Distance Field", "TextMeshPro/Mobile/Distance Field" };

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

		private const int PhoneUiDefaultImageQueue = 3005;

		private const float PhoneWorldMaxFontSize = 8.5f;

		private const float PhoneWorldScaleMin = 5E-05f;

		private const float PhoneWorldScaleMax = 0.05f;

		internal static bool IsPhoneModeActive { get; private set; }

		[HarmonyPostfix]
		[HarmonyPatch(typeof(LocalizationManager), "GetTranslation", new Type[]
		{
			typeof(string),
			typeof(bool),
			typeof(int),
			typeof(bool),
			typeof(bool),
			typeof(GameObject),
			typeof(string),
			typeof(bool)
		})]
		public static void LocalizationManager_GetTranslation_Postfix(string Term, ref string __result)
		{
			if (string.IsNullOrEmpty(__result) && !string.IsNullOrEmpty(Term))
			{
				__result = Term;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ItemData), "GetName")]
		public static void ItemData_GetName_Postfix(ItemData __instance, ref string __result)
		{
			if (string.IsNullOrEmpty(__result))
			{
				if (!string.IsNullOrEmpty(__instance.name))
				{
					__result = LocalizationManager.GetTranslation(__instance.name, true, 0, true, false, (GameObject)null, (string)null, true);
				}
				if (string.IsNullOrEmpty(__result))
				{
					__result = ResolveExpansionPackDisplayName(__instance.name);
				}
				if (string.IsNullOrEmpty(__result) && !string.IsNullOrEmpty(__instance.name))
				{
					__result = __instance.name;
				}
			}
		}

		public static void RepairPhoneUi(Transform? root)
		{
			RepairPhoneHomeScreen(root);
		}

		public static void SchedulePhoneScreenRepair(Transform? screenRoot)
		{
			Transform val = PhoneAppUiScope.ResolvePhoneScreenContentRoot(screenRoot);
			if (!((Object)(object)val == (Object)null))
			{
				PhoneUiLateRepairBehaviour.RequestDeferredScreenRepair(val);
			}
		}

		public static void SchedulePhoneAppRepair(Transform? fromTransform)
		{
			SchedulePhoneScreenRepair(fromTransform);
		}

		public static bool IsPhoneScreenLayoutReady(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return false;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy && IsLabelLayoutReady(val))
				{
					return true;
				}
			}
			return false;
		}

		public static void RepairAllPhoneAppTmpMaterials()
		{
			RepairAllPhoneAppLabels(materialOnly: true);
		}

		public static void RepairAllPhoneAppLabels(bool materialOnly = false, bool activeOnly = true)
		{
			try
			{
				ResetFontCache();
				RepairFredokaFontAssetsPublic();
				PhoneManager val = PhoneManagerAccess.FindPhoneManager();
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Log.LogInfo((object)"Phone TMP repair skipped: PhoneManager not found.");
					return;
				}
				PhoneCanvasRepair.EnsurePhoneCanvasesReady(val.m_PhoneGrp);
				int num = 0;
				HashSet<int> hashSet = new HashSet<int>();
				foreach (Transform item in PhoneAppUiScope.EnumeratePhoneUiRoots(val))
				{
					TextMeshProUGUI[] componentsInChildren = ((Component)item).GetComponentsInChildren<TextMeshProUGUI>(true);
					foreach (TextMeshProUGUI val2 in componentsInChildren)
					{
						if ((Object)(object)val2 == (Object)null || !hashSet.Add(((Object)val2).GetInstanceID()) || (activeOnly && !((Component)val2).gameObject.activeInHierarchy))
						{
							continue;
						}
						if (materialOnly)
						{
							if (EnsurePhoneLabelMaterial(val2))
							{
								num++;
							}
						}
						else if (RepairPhoneWorldLabel(val2, skipScopeCheck: true))
						{
							num++;
						}
					}
				}
				Plugin.Log.LogInfo((object)(materialOnly ? $"Phone TMP material sweep repaired {num} label material(s)." : $"Phone TMP label repair refreshed {num} label(s)."));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Phone TMP repair failed: " + ex.Message));
			}
		}

		public static int RepairPhoneScreen(Transform? screenRoot)
		{
			Transform val = PhoneAppUiScope.ResolvePhoneScreenContentRoot(screenRoot);
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			if (!loggedSubScreenLayering && IsPhoneModeActive)
			{
				loggedSubScreenLayering = true;
				DumpPhoneCanvasLayering(val, "SUB:" + (((Object)(object)screenRoot != (Object)null) ? ((Object)screenRoot).name : ((Object)val).name));
			}
			int num = 0;
			int num2 = 0;
			try
			{
				ResetFontCache();
				RepairFredokaFontAssetsPublic();
				RestoreScannerTitleTexts(val);
				TextMeshProUGUI[] componentsInChildren = ((Component)val).GetComponentsInChildren<TextMeshProUGUI>(true);
				foreach (TextMeshProUGUI val2 in componentsInChildren)
				{
					if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy && RepairPhoneWorldLabel(val2, skipScopeCheck: true))
					{
						num++;
						if (RefreshPhoneLabelMesh(val2))
						{
							num2++;
						}
					}
				}
				if (num2 > 0)
				{
					Canvas.ForceUpdateCanvases();
				}
				Plugin.Log.LogInfo((object)$"Phone screen UI repair on '{((Object)val).name}': {num} label(s), {num2} mesh refresh(es).");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Phone screen UI repair failed: " + ex.Message));
			}
			return num;
		}

		public static void SchedulePhoneHomeRepair()
		{
			PhoneUiLateRepairBehaviour.RequestDeferredHomeRepair();
		}

		public static int RepairPhoneHomeScreen(Transform? root)
		{
			Transform val = ResolvePhoneHomeRoot(root);
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			PhoneCanvasRepair.EnsurePhoneCanvasesReady(PhoneManagerAccess.FindPhoneManager()?.m_PhoneGrp);
			int num = 0;
			try
			{
				ResetFontCache();
				RepairFredokaFontAssetsPublic();
				RestorePhoneHomeButtonLabels(val);
				num += RepairPhoneHomeStatusTexts(val);
				FixPhoneHomeTextClipping(val);
				FixPhoneHomeOverlayArtifacts(val);
				RefreshPhoneLabelsInRoot(val);
				if (IsPhoneModeActive)
				{
					LogPhoneUiDiagnosticsOnce(val);
				}
				Plugin.Log.LogInfo((object)$"Phone home UI repair on '{((Object)val).name}': {num} header label(s).");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Phone UI repair failed: " + ex.Message));
			}
			return num;
		}

		public static bool IsPhoneHomeLayoutReady()
		{
			Transform val = ResolvePhoneHomeRoot(PhoneManagerAccess.TryGetReadyPhoneManager()?.m_PhoneGrp);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if (((Object)val2).name.StartsWith("PhoneButtonGrp_", StringComparison.Ordinal))
				{
					Transform obj = val2.Find("Text");
					TextMeshProUGUI val3 = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
					if ((Object)(object)val3 != (Object)null && IsLabelLayoutReady(val3))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static Transform? ResolvePhoneHomeRoot(Transform? root)
		{
			PhoneManager val = PhoneManagerAccess.FindPhoneManager();
			if ((Object)(object)((UIScreenBase)(val?.m_UI_PhoneScreen?)).m_ScreenGroup != (Object)null)
			{
				return ((UIScreenBase)val.m_UI_PhoneScreen).m_ScreenGroup.transform;
			}
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			if (((Object)root).name == "UI_PhoneScreen_Grp")
			{
				return root;
			}
			Transform val2 = root.Find("UI_PhoneScreen_Grp");
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val3 in componentsInChildren)
			{
				if (((Object)val3).name == "UI_PhoneScreen_Grp")
				{
					return val3;
				}
			}
			if (!((Object)(object)val?.m_UI_PhoneScreen != (Object)null))
			{
				return root;
			}
			return ((Component)val.m_UI_PhoneScreen).transform;
		}

		private static void DumpPhoneCanvasLayering(Transform root, string tag)
		{
			//IL_0064: 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_028d: 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_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Canvas[] componentsInChildren = ((Component)root).GetComponentsInChildren<Canvas>(true);
				foreach (Canvas val in componentsInChildren)
				{
					Plugin.Log.LogInfo((object)$"[{tag}] CANVAS '{GetTransformPath(((Component)val).transform, root)}' mode={val.renderMode} overrideSorting={val.overrideSorting} sortingLayer='{val.sortingLayerName}' sortingOrder={val.sortingOrder} enabled={((Behaviour)val).isActiveAndEnabled}");
				}
				Transform val2 = FindDescendantByName(root, "PhoneButtonGrp_Restock");
				if ((Object)(object)val2 != (Object)null)
				{
					Graphic[] componentsInChildren2 = ((Component)val2).GetComponentsInChildren<Graphic>(true);
					foreach (Graphic val3 in componentsInChildren2)
					{
						Canvas canvas = val3.canvas;
						ManualLogSource log = Plugin.Log;
						DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(59, 8);
						defaultInterpolatedStringHandler.AppendLiteral("[");
						defaultInterpolatedStringHandler.AppendFormatted(tag);
						defaultInterpolatedStringHandler.AppendLiteral("] GFX '");
						defaultInterpolatedStringHandler.AppendFormatted(GetTransformPath(((Component)val3).transform, root));
						defaultInterpolatedStringHandler.AppendLiteral("' type=");
						defaultInterpolatedStringHandler.AppendFormatted(((object)val3).GetType().Name);
						defaultInterpolatedStringHandler.AppendLiteral(" canvas='");
						defaultInterpolatedStringHandler.AppendFormatted(((Object)(object)canvas != (Object)null) ? GetTransformPath(((Component)canvas).transform, root) : "null");
						defaultInterpolatedStringHandler.AppendLiteral("' sortOrder=");
						defaultInterpolatedStringHandler.AppendFormatted(((Object)(object)canvas != (Object)null) ? canvas.sortingOrder : (-999));
						defaultInterpolatedStringHandler.AppendLiteral(" queue=");
						Material materialForRendering = val3.materialForRendering;
						defaultInterpolatedStringHandler.AppendFormatted((materialForRendering != null) ? new int?(materialForRendering.renderQueue) : ((int?)null));
						defaultInterpolatedStringHandler.AppendLiteral(" depth=");
						defaultInterpolatedStringHandler.AppendFormatted(val3.depth);
						defaultInterpolatedStringHandler.AppendLiteral(" sibling=");
						defaultInterpolatedStringHandler.AppendFormatted(((Component)val3).transform.GetSiblingIndex());
						log.LogInfo((object)defaultInterpolatedStringHandler.ToStringAndClear());
					}
				}
				Image[] componentsInChildren3 = ((Component)root).GetComponentsInChildren<Image>(true);
				foreach (Image val4 in componentsInChildren3)
				{
					RectTransform rectTransform = ((Graphic)val4).rectTransform;
					Rect rect = rectTransform.rect;
					if (!(((Rect)(ref rect)).width < 60f))
					{
						rect = rectTransform.rect;
						if (!(((Rect)(ref rect)).height < 60f))
						{
							Canvas canvas2 = ((Graphic)val4).canvas;
							ManualLogSource log2 = Plugin.Log;
							DefaultInterpolatedStringHandler defaultInterpolatedStringHandler2 = new DefaultInterpolatedStringHandler(86, 11);
							defaultInterpolatedStringHandler2.AppendLiteral("[");
							defaultInterpolatedStringHandler2.AppendFormatted(tag);
							defaultInterpolatedStringHandler2.AppendLiteral("] FULLSCREEN '");
							defaultInterpolatedStringHandler2.AppendFormatted(GetTransformPath(((Component)val4).transform, root));
							defaultInterpolatedStringHandler2.AppendLiteral("' rect=(");
							rect = rectTransform.rect;
							defaultInterpolatedStringHandler2.AppendFormatted(((Rect)(ref rect)).width, "F0");
							defaultInterpolatedStringHandler2.AppendLiteral("x");
							rect = rectTransform.rect;
							defaultInterpolatedStringHandler2.AppendFormatted(((Rect)(ref rect)).height, "F0");
							defaultInterpolatedStringHandler2.AppendLiteral(") canvas='");
							defaultInterpolatedStringHandler2.AppendFormatted(((Object)(object)canvas2 != (Object)null) ? GetTransformPath(((Component)canvas2).transform, root) : "null");
							defaultInterpolatedStringHandler2.AppendLiteral("' sortOrder=");
							defaultInterpolatedStringHandler2.AppendFormatted(((Object)(object)canvas2 != (Object)null) ? canvas2.sortingOrder : (-999));
							defaultInterpolatedStringHandler2.AppendLiteral(" queue=");
							Material materialForRendering2 = ((Graphic)val4).materialForRendering;
							defaultInterpolatedStringHandler2.AppendFormatted((materialForRendering2 != null) ? new int?(materialForRendering2.renderQueue) : ((int?)null));
							defaultInterpolatedStringHandler2.AppendLiteral(" depth=");
							defaultInterpolatedStringHandler2.AppendFormatted(((Graphic)val4).depth);
							defaultInterpolatedStringHandler2.AppendLiteral(" sibling=");
							defaultInterpolatedStringHandler2.AppendFormatted(((Component)val4).transform.GetSiblingIndex());
							defaultInterpolatedStringHandler2.AppendLiteral(" colorA=");
							defaultInterpolatedStringHandler2.AppendFormatted(((Graphic)val4).color.a, "F2");
							defaultInterpolatedStringHandler2.AppendLiteral(" raycast=");
							defaultInterpolatedStringHandler2.AppendFormatted(((Graphic)val4).raycastTarget);
							log2.LogInfo((object)defaultInterpolatedStringHandler2.ToStringAndClear());
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[" + tag + "] canvas layering dump failed: " + ex.Message));
			}
		}

		private static Transform? FindDescendantByName(Transform root, string name)
		{
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == name)
				{
					return val;
				}
			}
			return null;
		}

		private static string GetTransformPath(Transform t, Transform stopAt)
		{
			string text = ((Object)t).name;
			Transform parent = t.parent;
			while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)stopAt)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static void SetPhoneHomeContentActive(bool active)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			try
			{
				PhoneManager val = PhoneManagerAccess.FindPhoneManager();
				UI_PhoneScreen val2 = val?.m_UI_PhoneScreen;
				GameObject val3 = ((UIScreenBase)(val2?)).m_ScreenGroup;
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
				{
					return;
				}
				Transform transform = val3.transform;
				List<Transform> list = new List<Transform>();
				foreach (UIScreenBase item in PhoneAppUiScope.EnumerateScreens(val))
				{
					if (!((Object)(object)item == (Object)null) && (object)item != val2)
					{
						list.Add(((Component)item).transform);
						if ((Object)(object)item.m_ScreenGroup != (Object)null)
						{
							list.Add(item.m_ScreenGroup.transform);
						}
					}
				}
				foreach (Transform item2 in transform)
				{
					Transform val4 = item2;
					bool flag = false;
					foreach (Transform item3 in list)
					{
						if ((Object)(object)item3 == (Object)(object)val4 || item3.IsChildOf(val4))
						{
							flag = true;
							break;
						}
					}
					if (!flag && ((Component)val4).gameObject.activeSelf != active)
					{
						((Component)val4).gameObject.SetActive(active);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Phone home content toggle failed: " + ex.Message));
			}
		}

		private static int RepairPhoneHomeStatusTexts(Transform homeRoot)
		{
			int num = 0;
			UI_PhoneScreen val = (PhoneManagerAccess.TryGetReadyPhoneManager() ?? PhoneManagerAccess.FindPhoneManager())?.m_UI_PhoneScreen;
			if ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)val.m_TimeText != (Object)null && RepairPhoneWorldLabel(val.m_TimeText, skipScopeCheck: true))
				{
					num++;
				}
				if ((Object)(object)val.m_DayText != (Object)null && RepairPhoneWorldLabel(val.m_DayText, skipScopeCheck: true))
				{
					num++;
				}
				return num;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)homeRoot).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI label in componentsInChildren)
			{
				if (IsPhoneHeaderLabel(label) && RepairPhoneWorldLabel(label, skipScopeCheck: true))
				{
					num++;
				}
			}
			return num;
		}

		private static bool IsPhoneAppLabel(TextMeshProUGUI label)
		{
			if ((Object)(object)label != (Object)null)
			{
				return PhoneAppUiScope.IsPhoneAppTransform(((TMP_Text)label).transform);
			}
			return false;
		}

		private static bool IsLabelLayoutReady(TextMeshProUGUI label)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Vector3 lossyScale = ((TMP_Text)label).transform.lossyScale;
			if (lossyScale.x > 0.0001f)
			{
				return lossyScale.y > 0.0001f;
			}
			return false;
		}

		public static void RestorePhoneHomeButtonLabels(Transform? root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)val).name.StartsWith("PhoneButtonGrp_", StringComparison.Ordinal) || !PhoneButtonDefaultLabels.TryGetValue(((Object)val).name, out var value))
				{
					continue;
				}
				TextMeshProUGUI[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<TextMeshProUGUI>(true);
				foreach (TextMeshProUGUI val2 in componentsInChildren2)
				{
					if (!((Object)(object)val2 == (Object)null) && !(((Object)val2).name != "Text"))
					{
						string translation = LocalizationManager.GetTranslation(value, true, 0, true, false, (GameObject)null, (string)null, true);
						string text = (string.IsNullOrEmpty(translation) ? value : translation);
						if (!string.Equals(((TMP_Text)val2).text, text, StringComparison.Ordinal))
						{
							((TMP_Text)val2).text = text;
						}
						RepairPhoneWorldLabel(val2, skipScopeCheck: true);
					}
				}
			}
		}

		public static void LogPhoneUiDiagnosticsOnce(Transform? root)
		{
			//IL_0175: 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)
			if (loggedPhoneUiDiagnostics || (Object)(object)root == (Object)null)
			{
				return;
			}
			loggedPhoneUiDiagnostics = true;
			DumpButtonHierarchyOnce(root);
			DumpPhoneCanvasLayering(root, "HOME");
			int num = 0;
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(((Object)val).name != "Text") && !((Object)(object)((TMP_Text)val).transform.parent == (Object)null) && ((Object)((TMP_Text)val).transform.parent).name.StartsWith("PhoneButtonGrp_", StringComparison.Ordinal))
				{
					ManualLogSource log = Plugin.Log;
					DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(101, 11);
					defaultInterpolatedStringHandler.AppendLiteral("Phone UI sample [");
					defaultInterpolatedStringHandler.AppendFormatted(((Object)((TMP_Text)val).transform.parent).name);
					defaultInterpolatedStringHandler.AppendLiteral("]: text='");
					defaultInterpolatedStringHandler.AppendFormatted(((TMP_Text)val).text);
					defaultInterpolatedStringHandler.AppendLiteral("', font='");
					TMP_FontAsset font = ((TMP_Text)val).font;
					defaultInterpolatedStringHandler.AppendFormatted((font != null) ? ((Object)font).name : null);
					defaultInterpolatedStringHandler.AppendLiteral("', fontSize=");
					defaultInterpolatedStringHandler.AppendFormatted(((TMP_Text)val).fontSize, "F1");
					defaultInterpolatedStringHandler.AppendLiteral(", verts=");
					Mesh mesh = ((TMP_Text)val).mesh;
					defaultInterpolatedStringHandler.AppendFormatted((mesh != null) ? mesh.vertexCount : 0);
					defaultInterpolatedStringHandler.AppendLiteral(", ");
					defaultInterpolatedStringHandler.AppendFormatted(DescribePhoneLabelRender(val));
					defaultInterpolatedStringHandler.AppendLiteral(", lossyScale=(");
					defaultInterpolatedStringHandler.AppendFormatted(((TMP_Text)val).transform.lossyScale.x, "F4");
					defaultInterpolatedStringHandler.AppendLiteral(",");
					defaultInterpolatedStringHandler.AppendFormatted(((TMP_Text)val).transform.lossyScale.y, "F4");
					defaultInterpolatedStringHandler.AppendLiteral("), active=");
					defaultInterpolatedStringHandler.AppendFormatted(((Component)val).gameObject.activeInHierarchy);
					defaultInterpolatedStringHandler.AppendLiteral(", canvas=");
					defaultInterpolatedStringHandler.AppendFormatted(DescribePhoneLabelCanvas(val));
					defaultInterpolatedStringHandler.AppendLiteral(", sibling=");
					defaultInterpolatedStringHandler.AppendFormatted(((TMP_Text)val).transform.GetSiblingIndex());
					log.LogInfo((object)defaultInterpolatedStringHandler.ToStringAndClear());
					num++;
					if (num >= 4)
					{
						break;
					}
				}
			}
		}

		public static void LogPhoneUiDiagnosticsAfterPhoneOpen()
		{
			loggedPhoneUiDiagnostics = false;
			LogPhoneUiDiagnosticsOnce(ResolvePhoneHomeRoot(PhoneManagerAccess.FindPhoneManager()?.m_PhoneGrp));
		}

		private static void DumpButtonHierarchyOnce(Transform root)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name != "PhoneButtonGrp_Restock")
				{
					continue;
				}
				Plugin.Log.LogInfo((object)$"Phone button DUMP cell '{((Object)val).name}' rect={DescribeRect(val)} localScale={val.localScale}");
				Transform[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<Transform>(true);
				foreach (Transform val2 in componentsInChildren2)
				{
					if (!((Object)(object)val2 == (Object)(object)val))
					{
						Plugin.Log.LogInfo((object)$"  child '{((Object)val2).name}' active={((Component)val2).gameObject.activeSelf} rect={DescribeRect(val2)} localScale={val2.localScale} localPos={val2.localPosition}");
					}
				}
				break;
			}
		}

		private static string DescribeRect(Transform t)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)(object)((t is RectTransform) ? t : null);
			if (val != null)
			{
				Rect rect = val.rect;
				return $"(w={((Rect)(ref rect)).width:F1},h={((Rect)(ref rect)).height:F1},sizeDelta={val.sizeDelta},anchMin={val.anchorMin},anchMax={val.anchorMax})";
			}
			return "(no RectTransform)";
		}

		private static string DescribePhoneLabelRender(TextMeshProUGUI label)
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: 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_0216: 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)
			CanvasRenderer canvasRenderer = label.canvasRenderer;
			string value;
			if ((Object)(object)canvasRenderer == (Object)null)
			{
				value = "cr=null";
			}
			else
			{
				Material val = ((canvasRenderer.materialCount > 0) ? canvasRenderer.GetMaterial(0) : null);
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(60, 6);
				defaultInterpolatedStringHandler.AppendLiteral("crMatCount=");
				defaultInterpolatedStringHandler.AppendFormatted(canvasRenderer.materialCount);
				defaultInterpolatedStringHandler.AppendLiteral(", crMat='");
				defaultInterpolatedStringHandler.AppendFormatted((val != null) ? ((Object)val).name : null);
				defaultInterpolatedStringHandler.AppendLiteral("', crQueue=");
				defaultInterpolatedStringHandler.AppendFormatted((val != null) ? new int?(val.renderQueue) : ((int?)null));
				defaultInterpolatedStringHandler.AppendLiteral(", crTex='");
				object value2;
				if (val == null)
				{
					value2 = null;
				}
				else
				{
					Texture mainTexture = val.mainTexture;
					value2 = ((mainTexture != null) ? ((Object)mainTexture).name : null);
				}
				defaultInterpolatedStringHandler.AppendFormatted((string?)value2);
				defaultInterpolatedStringHandler.AppendLiteral("', crCull=");
				defaultInterpolatedStringHandler.AppendFormatted(canvasRenderer.cull);
				defaultInterpolatedStringHandler.AppendLiteral(", crAlpha=");
				defaultInterpolatedStringHandler.AppendFormatted(canvasRenderer.GetAlpha(), "F2");
				value = defaultInterpolatedStringHandler.ToStringAndClear();
			}
			Bounds val2 = (Bounds)(((Object)(object)((TMP_Text)label).mesh != (Object)null) ? ((TMP_Text)label).mesh.bounds : default(Bounds));
			float value3 = ((Bounds)(ref val2)).size.y * Mathf.Abs(((TMP_Text)label).transform.lossyScale.y);
			float value4 = ((Bounds)(ref val2)).size.x * Mathf.Abs(((TMP_Text)label).transform.lossyScale.x);
			float value5 = (IsPhoneButtonLabel(label) ? GetButtonIconHeight(label) : GetRectHeight(((TMP_Text)label).rectTransform));
			return $"{value}, faceA={((TMP_Text)label).faceColor.a}, colorA={((Graphic)label).color.a:F2}, refH={value5:F1}, meshLocal=({((Bounds)(ref val2)).size.x:F2}x{((Bounds)(ref val2)).size.y:F2}), meshWorld=({value4:F5}x{value3:F5})";
		}

		private static string DescribePhoneLabelCanvas(TextMeshProUGUI label)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_004e: 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_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_003b: Invalid comparison between Unknown and I4
			Canvas canvas = ((Graphic)label).canvas;
			if ((Object)(object)canvas == (Object)null)
			{
				return "null";
			}
			Canvas rootCanvas = canvas.rootCanvas;
			bool value = (rootCanvas.additionalShaderChannels & 1) != 0 && (rootCanvas.additionalShaderChannels & 8) != 0 && (rootCanvas.additionalShaderChannels & 0x10) > 0;
			return $"{canvas.renderMode}/enabled={((Behaviour)canvas).isActiveAndEnabled}/root='{((Object)rootCanvas).name}'/rootChannels={rootCanvas.additionalShaderChannels}/rootTmpOk={value}";
		}

		private static void ResetFontCache()
		{
			fontsCached = false;
			CachedFredokaFonts.Clear();
		}

		[HarmonyPostfix]
		[HarmonyPriority(999)]
		[HarmonyPatch(typeof(PhoneManager), "EnterPhoneMode")]
		public static void PhoneManager_EnterPhoneMode_Postfix()
		{
			IsPhoneModeActive = true;
			loggedPhoneUiDiagnostics = false;
			loggedSubScreenLayering = false;
			SchedulePhoneHomeRepair();
			PhoneUiLateRepairBehaviour.RequestDeferredPhoneOpenRefresh();
			PhoneUiRenderSyncBehaviour.ScheduleOpenRefresh();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PhoneManager), "ExitPhoneMode")]
		public static void PhoneManager_ExitPhoneMode_Postfix()
		{
			IsPhoneModeActive = false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(UI_PhoneScreen), "OnOpenScreen")]
		public static void UI_PhoneScreen_OnOpenScreen_Postfix(UI_PhoneScreen __instance)
		{
			if ((Object)(object)((UIScreenBase)__instance).m_ScreenGroup != (Object)null && !((UIScreenBase)__instance).m_ScreenGroup.activeSelf)
			{
				((UIScreenBase)__instance).m_ScreenGroup.SetActive(true);
			}
			SetPhoneHomeContentActive(active: true);
			SchedulePhoneHomeRepair();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(UI_PhoneScreen), "OnChildScreenClosed")]
		public static void UI_PhoneScreen_OnChildScreenClosed_Postfix()
		{
			SetPhoneHomeContentActive(active: true);
			SchedulePhoneHomeRepair();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RestockItemPanelUI), "Init")]
		public static void RestockItemPanelUI_Init_Postfix(RestockItemPanelUI __instance)
		{
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RestockItemScreen), "EvaluateRestockItemPanelUI")]
		public static void RestockItemScreen_EvaluateRestockItemPanelUI_Postfix(RestockItemScreen __instance)
		{
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(HireWorkerScreen), "OnOpenScreen")]
		public static void HireWorkerScreen_OnOpenScreen_Postfix(HireWorkerScreen __instance)
		{
			SetPhoneHomeContentActive(active: false);
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(HireWorkerPanelUI), "Init", new Type[]
		{
			typeof(HireWorkerScreen),
			typeof(int)
		})]
		public static void HireWorkerPanelUI_Init_Postfix(HireWorkerPanelUI __instance)
		{
			RepairPhoneWorldLabelsInTransform(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RestockItemScreen), "OnOpenScreen")]
		public static void RestockItemScreen_OnOpenScreen_Postfix(RestockItemScreen __instance)
		{
			SetPhoneHomeContentActive(active: false);
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ScannerRestockScreen), "Awake")]
		public static void ScannerRestockScreen_Awake_Prefix(ScannerRestockScreen __instance)
		{
			CacheScannerTitleTexts(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPriority(1000)]
		[HarmonyPatch(typeof(ScannerRestockScreen), "OnOpenScreen")]
		public static void ScannerRestockScreen_OnOpenScreen_Postfix(ScannerRestockScreen __instance)
		{
			SetPhoneHomeContentActive(active: false);
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RentBillScreen), "OnOpenScreen")]
		public static void RentBillScreen_OnOpenScreen_Postfix(RentBillScreen __instance)
		{
			SetPhoneHomeContentActive(active: false);
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RentBillScreen), "EvaluateUI")]
		public static void RentBillScreen_EvaluateUI_Postfix(RentBillScreen __instance)
		{
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RentBillPanelUI), "EvaluateUI")]
		public static void RentBillPanelUI_EvaluateUI_Postfix(RentBillPanelUI __instance)
		{
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RestockCheckoutItemBar), "UpdateData")]
		public static void RestockCheckoutItemBar_UpdateData_Postfix(RestockCheckoutItemBar __instance)
		{
			RepairPhoneWorldLabelsInTransform(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CheckPricePanelUI), "InitItem")]
		public static void CheckPricePanelUI_InitItem_Postfix(CheckPricePanelUI __instance)
		{
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CheckPricePanelUI), "InitCard")]
		public static void CheckPricePanelUI_InitCard_Postfix(CheckPricePanelUI __instance)
		{
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CustomerReviewPanelUI), "Init")]
		public static void CustomerReviewPanelUI_Init_Postfix(CustomerReviewPanelUI __instance)
		{
			SchedulePhoneAppRepair(((Component)__instance).transform);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(UIScreenBase), "OnOpenScreen")]
		public static void UIScreenBase_OnOpenScreen_Postfix(UIScreenBase __instance)
		{
			if (PhoneAppUiScope.IsPhoneRelatedScreen(__instance))
			{
				if (!(__instance is UI_PhoneScreen))
				{
					SetPhoneHomeContentActive(active: false);
				}
				SchedulePhoneAppRepair(((Component)__instance).transform);
			}
		}

		private static string ResolveExpansionPackDisplayName(string? itemNameKey)
		{
			if (string.IsNullOrEmpty(itemNameKey))
			{
				return string.Empty;
			}
			string text = itemNameKey switch
			{
				"MegabotPack" => "Megabot", 
				"FantasyRPGPack" => "FantasyRPG", 
				"CatJobPack" => "CatJob", 
				"GhostPack" => "Ghost", 
				_ => null, 
			};
			if (text == null)
			{
				return string.Empty;
			}
			string translation = LocalizationManager.GetTranslation(text, true, 0, true, false, (GameObject)null, (string)null, true);
			if (!string.IsNullOrEmpty(translation))
			{
				return translation;
			}
			return TryGetExpansionModPackName(text);
		}

		private static string TryGetExpansionModPackName(string translationKey)
		{
			Type type = AccessTools.TypeByName("TCGShopExpansionMod.Patches.PlayerPatches");
			if (type == null)
			{
				return string.Empty;
			}
			string text = translationKey switch
			{
				"Megabot" => "newMegaBotPackName", 
				"FantasyRPG" => "newFantasyRPGPackName", 
				"CatJob" => "newCatJobPackName", 
				_ => null, 
			};
			if (text == null)
			{
				return string.Empty;
			}
			return (AccessTools.Field(type, text)?.GetValue(null) as string) ?? string.Empty;
		}

		private static void CacheScannerTitleTexts(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(((Object)val).name != "TitleText"))
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (!ScannerTitleTextById.ContainsKey(instanceID) && !string.IsNullOrEmpty(((TMP_Text)val).text))
					{
						ScannerTitleTextById[instanceID] = ((TMP_Text)val).text;
					}
				}
			}
		}

		private static void RestoreScannerTitleTexts(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(((Object)val).name != "TitleText") && string.IsNullOrEmpty(((TMP_Text)val).text))
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (ScannerTitleTextById.TryGetValue(instanceID, out var value) && !string.IsNullOrEmpty(value))
					{
						((TMP_Text)val).text = value;
					}
				}
			}
		}

		public static void RepairTmpInHierarchy(Transform? root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			if (PhoneAppUiScope.IsPhoneAppTransform(root))
			{
				RepairPhoneWorldLabelsInTransform(root);
				return;
			}
			EnsureFontsCached();
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (((Component)val).gameObject.activeInHierarchy)
				{
					RepairHudTmp(val);
				}
			}
		}

		private static void RepairPhoneWorldLabelsInTransform(Transform root)
		{
			EnsureFontsCached();
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					RepairPhoneWorldLabel(val, skipScopeCheck: true);
				}
			}
		}

		private static bool RepairPhoneWorldLabel(TextMeshProUGUI label, bool skipScopeCheck = false)
		{
			if ((Object)(object)label == (Object)null)
			{
				return false;
			}
			if (!skipScopeCheck && !PhoneAppUiScope.IsPhoneAppTransform(((TMP_Text)label).transform))
			{
				return false;
			}
			TMP_FontAsset val = ResolvePhoneFont();
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)label).font = val;
				((TMP_Text)label).fontMaterial = PhoneFontMaterialSnapshot.CreateLabelMaterial(val);
			}
			val = ((TMP_Text)label).font;
			if ((Object)(object)val != (Object)null)
			{
				RepairFontMaterial(val);
			}
			ApplyPhoneLabelColors(label);
			ApplyPhoneWorldFontSizing(label);
			PhoneCanvasRepair.EnsureLabelCanvasChannels(((Graphic)label).canvas);
			EnsurePhoneLabelMaterial(label);
			SyncPhoneLabelCanvasRenderer(label);
			if (IsPhoneButtonLabel(label))
			{
				EnsurePhoneButtonTextDrawOrder(label);
			}
			if (((Component)label).gameObject.activeInHierarchy && ShouldRebuildPhoneLabelMesh(label))
			{
				RefreshPhoneLabelMesh(label);
			}
			((Behaviour)label).enabled = true;
			((Graphic)label).SetAllDirty();
			return true;
		}

		public static void SyncVisiblePhoneLabelMaterials()
		{
			PhoneManager val = PhoneManagerAccess.FindPhoneManager();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			foreach (Transform item in EnumerateActivePhoneUiRoots(val))
			{
				TextMeshProUGUI[] componentsInChildren = ((Component)item).GetComponentsInChildren<TextMeshProUGUI>(true);
				foreach (TextMeshProUGUI val2 in componentsInChildren)
				{
					if ((Object)(object)val2 == (Object)null || !((Component)val2).gameObject.activeInHierarchy || !ShouldRebuildPhoneLabelMesh(val2))
					{
						continue;
					}
					if (!IsPhoneLabelAtlasBound(val2))
					{
						TMP_FontAsset val3 = ResolvePhoneFont();
						if ((Object)(object)val3 != (Object)null)
						{
							((TMP_Text)val2).font = val3;
						}
						EnsurePhoneLabelMaterial(val2);
					}
					if ((Object)(object)((TMP_Text)val2).mesh == (Object)null || ((TMP_Text)val2).mesh.vertexCount == 0)
					{
						((TMP_Text)val2).ForceMeshUpdate(true, false);
					}
				}
			}
		}

		private static IEnumerable<Transform> EnumerateActivePhoneUiRoots(PhoneManager phoneManager)
		{
			foreach (Transform item in PhoneAppUiScope.EnumeratePhoneUiRoots(phoneManager))
			{
				if ((Object)(object)item != (Object)null && ((Component)item).gameObject.activeInHierarchy)
				{
					yield return item;
				}
			}
		}

		private static void FixPhoneHomeTextClipping(Transform homeRoot)
		{
			RectMask2D[] componentsInChildren = ((Component)homeRoot).GetComponentsInChildren<RectMask2D>(true);
			foreach (RectMask2D val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					((Behaviour)val).enabled = false;
				}
			}
			TextMeshProUGUI[] componentsInChildren2 = ((Component)homeRoot).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					((MaskableGraphic)val2).maskable = false;
					((Graphic)val2).raycastTarget = false;
				}
			}
		}

		private static void FixPhoneHomeOverlayArtifacts(Transform homeRoot)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			Transform[] componentsInChildren = ((Component)homeRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)val).name.StartsWith("PhoneButtonGrp_", StringComparison.Ordinal))
				{
					continue;
				}
				foreach (Transform item in val)
				{
					Transform val2 = item;
					switch (((Object)val2).name)
					{
					case "Icon2":
					case "Icon (1)":
					case "Icon (2)":
						((Component)val2).gameObject.SetActive(false);
						break;
					}
				}
			}
		}

		private static void RestorePhoneLabelGeometry(TextMeshProUGUI label)
		{
			//IL_0081: 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_009a: 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_0035: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			int instanceID = ((Object)label).GetInstanceID();
			if (!OriginalLabelGeometry.TryGetValue(instanceID, out var value))
			{
				value = new PhoneLabelGeometry(((TMP_Text)label).fontSize, ((TMP_Text)label).enableAutoSizing, ((TMP_Text)label).transform.localScale, ((TMP_Text)label).transform.localPosition, ((TMP_Text)label).enableWordWrapping, ((TMP_Text)label).overflowMode);
				OriginalLabelGeometry[instanceID] = value;
			}
			((TMP_Text)label).enableAutoSizing = value.AutoSizing;
			((TMP_Text)label).fontSize = value.FontSize;
			((TMP_Text)label).enableWordWrapping = value.WordWrap;
			((TMP_Text)label).overflowMode = value.Overflow;
			Transform transform = ((TMP_Text)label).transform;
			if (transform.localScale != value.LocalScale)
			{
				transform.localScale = value.LocalScale;
			}
			if (transform.localPosition != value.LocalPosition)
			{
				transform.localPosition = value.LocalPosition;
			}
		}

		private static void EnsurePhoneButtonTextDrawOrder(TextMeshProUGUI label)
		{
			((TMP_Text)label).transform.SetAsLastSibling();
		}

		private static void ApplyPhoneLabelColors(TextMeshProUGUI label)
		{
			//IL_0015: 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_0039: 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_0049: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00cf: 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_00db: 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_010b: 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)
			((MaskableGraphic)label).maskable = false;
			if (PhoneFontMaterialSnapshot.IsBorderFont(((TMP_Text)label).font))
			{
				((Graphic)label).color = Color.white;
				((TMP_Text)label).faceColor = Color32.op_Implicit(Color.white);
			}
			else if (IsPhoneHeaderLabel(label))
			{
				((Graphic)label).color = Color.white;
				((TMP_Text)label).faceColor = Color32.op_Implicit(Color.white);
				((TMP_Text)label).outlineColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);
				((TMP_Text)label).outlineWidth = 0.18f;
			}
			else if (IsPhoneButtonLabel(label))
			{
				((Graphic)label).color = Color.white;
				((TMP_Text)label).faceColor = Color32.op_Implicit(Color.white);
				((TMP_Text)label).outlineColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);
				((TMP_Text)label).outlineWidth = 0.18f;
			}
			else if (IsPhoneSolidButtonLabel(label))
			{
				Color32 val = default(Color32);
				((Color32)(ref val))..ctor((byte)35, (byte)35, (byte)35, byte.MaxValue);
				((Graphic)label).color = Color32.op_Implicit(val);
				((TMP_Text)label).faceColor = val;
				((TMP_Text)label).outlineWidth = 0f;
			}
			else if (((Graphic)label).color.a < 0.05f)
			{
				((Graphic)label).color = Color.white;
				((TMP_Text)label).faceColor = Color32.op_Implicit(Color.white);
			}
		}

		private static bool IsPhoneSolidButtonLabel(TextMeshProUGUI label)
		{
			Transform parent = ((TMP_Text)label).transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				string name = ((Object)parent).name;
				if (name.IndexOf("Btn", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Button", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Checkout", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Cart", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Confirm", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Back", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Close", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				parent = parent.parent;
			}
			return false;
		}

		private static void SyncPhoneLabelCanvasRenderer(TextMeshProUGUI label)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			CanvasRenderer canvasRenderer = label.canvasRenderer;
			if ((Object)(object)canvasRenderer == (Object)null)
			{
				return;
			}
			canvasRenderer.SetColor(Color.white);
			canvasRenderer.SetAlpha(1f);
			canvasRenderer.cullTransparentMesh = false;
			canvasRenderer.cull = false;
			Material val = ((Graphic)label).materialForRendering ?? ((TMP_Text)label).fontMaterial;
			if ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name != null && ((Object)val).name.StartsWith("PhoneLabel_", StringComparison.Ordinal))
				{
					val.renderQueue = ResolvePhoneLabelRenderQueue(label);
				}
				canvasRenderer.materialCount = 1;
				canvasRenderer.SetMaterial(val, 0);
				TMP_FontAsset font = ((TMP_Text)label).font;
				Texture val2 = (Texture)(object)((font != null) ? font.atlasTexture : null);
				if ((Object)(object)val2 != (Object)null)
				{
					canvasRenderer.SetTexture(val2);
				}
			}
		}

		private static int ResolvePhoneLabelRenderQueue(TextMeshProUGUI label)
		{
			int num = 3005;
			Transform parent = ((TMP_Text)label).transform.parent;
			if ((Object)(object)parent != (Object)null)
			{
				Image[] componentsInChildren = ((Component)parent).GetComponentsInChildren<Image>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Material materialForRendering = ((Graphic)componentsInChildren[i]).materialForRendering;
					if ((Object)(object)materialForRendering != (Object)null && materialForRendering.renderQueue > num)
					{
						num = materialForRendering.renderQueue;
					}
				}
			}
			return num;
		}

		private static bool EnsurePhoneLabelMaterial(TextMeshProUGUI label)
		{
			//IL_00bc: 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)
			TMP_FontAsset font = ((TMP_Text)label).font;
			if ((Object)(object)((font != null) ? font.atlasTexture : null) == (Object)null || (Object)(object)((TMP_Asset)font).material == (Object)null)
			{
				return false;
			}
			Material val = ((TMP_Text)label).fontMaterial;
			if ((Object)(object)val == (Object)null || !((Object)val).name.StartsWith("PhoneLabel_", StringComparison.Ordinal))
			{
				val = (((TMP_Text)label).fontMaterial = PhoneFontMaterialSnapshot.CreateLabelMaterial(font));
			}
			Texture atlasTexture = (Texture)(object)font.atlasTexture;
			bool result = false;
			if (val.mainTexture != atlasTexture)
			{
				val.mainTexture = atlasTexture;
				result = true;
			}
			Shader val3 = ResolveTmpShader();
			if ((Object)(object)val3 != (Object)null && (Object)(object)val.shader != (Object)(object)val3 && !PhoneFontMaterialSnapshot.IsBorderFont(font))
			{
				val.shader = val3;
				result = true;
			}
			if (val.HasProperty("_FaceColor") && val.GetColor("_FaceColor").a < 0.05f)
			{
				val.SetColor("_FaceColor", Color.white);
				result = true;
			}
			((Graphic)label).SetMaterialDirty();
			return result;
		}

		private static bool IsFontAtlasTexture(Texture? texture)
		{
			if ((Object)(object)texture == (Object)null)
			{
				return false;
			}
			string text = ((Object)texture).name ?? string.Empty;
			if (text.IndexOf("Atlas", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("SDF", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool IsPhoneLabelAtlasBound(TextMeshProUGUI label)
		{
			TMP_FontAsset font = ((TMP_Text)label).font;
			Texture val = (Texture)(object)((font != null) ? font.atlasTexture : null);
			if ((Object)(object)val != (Object)null)
			{
				return ((TMP_Text)label).fontMaterial.mainTexture == val;
			}
			return false;
		}

		private static void RefreshPhoneLabelsInRoot(Transform root)
		{
			bool flag = false;
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy && RefreshPhoneLabelMesh(val))
				{
					flag = true;
				}
			}
			if (flag)
			{
				Canvas.ForceUpdateCanvases();
			}
		}

		private static bool IsPhoneWorldScale(TextMeshProUGUI label)
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Vector3 lossyScale = ((TMP_Text)label).transform.lossyScale;
			float num = Mathf.Max(new float[3]
			{
				Mathf.Abs(lossyScale.x),
				Mathf.Abs(lossyScale.y),
				Mathf.Abs(lossyScale.z)
			});
			if (num >= 5E-05f)
			{
				return num <= 0.05f;
			}
			return false;
		}

		private static bool ShouldRebuildPhoneLabelMesh(TextMeshProUGUI label)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			if (!((Component)label).gameObject.activeInHierarchy)
			{
				return false;
			}
			if (((TMP_Text)label).fontSize > 8.5f)
			{
				return false;
			}
			Canvas canvas = ((Graphic)label).canvas;
			if ((Object)(object)canvas == (Object)null || !((Behaviour)canvas).isActiveAndEnabled || (int)canvas.renderMode != 2)
			{
				return false;
			}
			return IsPhoneWorldScale(label);
		}

		private static bool RefreshPhoneLabelMesh(TextMeshProUGUI label)
		{
			if ((Object)(object)label == (Object)null || !((Component)label).gameObject.activeInHierarchy)
			{
				return false;
			}
			((Graphic)label).SetAllDirty();
			if (!ShouldRebuildPhoneLabelMesh(label))
			{
				return false;
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(((TMP_Text)label).rectTransform);
			((TMP_Text)label).ForceMeshUpdate(true, false);
			if ((Object)(object)((TMP_Text)label).mesh != (Object)null)
			{
				return ((TMP_Text)label).mesh.vertexCount > 0;
			}
			return false;
		}

		private static void RepairHudTmp(TextMeshProUGUI label)
		{
			if (!((Object)(object)label == (Object)null))
			{
				ApplyHudFontSize(label);
				ApplyReadableColors(label);
				((Behaviour)label).enabled = true;
				((Graphic)label).SetAllDirty();
			}
		}

		private static void RepairScreenTmp(TextMeshProUGUI label)
		{
			if (!((Object)(object)label == (Object)null))
			{
				if (IsPhoneAppLabel(label))
				{
					RepairPhoneWorldLabel(label);
				}
				else
				{
					RepairHudTmp(label);
				}
			}
		}

		private static void RepairPhoneFontBinding(TextMeshProUGUI label)
		{
			if ((Object)(object)label == (Object)null)
			{
				return;
			}
			if ((Object)(object)((TMP_Text)label).font != (Object)null && (Object)(object)((TMP_Text)label).font.atlasTexture != (Object)null && ((Object)((TMP_Text)label).font).name.StartsWith("FredokaOne", StringComparison.Ordinal))
			{
				RepairFontMaterial(((TMP_Text)label).font);
				EnsureLabelMaterialUsesFontAtlas(label);
				return;
			}
			TMP_FontAsset val = ResolvePhoneFont();
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)label).font = val;
				RepairFontMaterial(val);
				EnsureLabelMaterialUsesFontAtlas(label);
			}
		}

		private static void EnsureLabelMaterialUsesFontAtlas(TextMeshProUGUI label)
		{
			EnsurePhoneLabelMaterial(label);
		}

		private static void ApplyPhoneWorldFontSizing(TextMeshProUGUI label)
		{
			RestorePhoneLabelGeometry(label);
		}

		private static float GetRectHeight(RectTransform? rect)
		{
			//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)
			if (!((Object)(object)rect == (Object)null))
			{
				Rect rect2 = rect.rect;
				return Mathf.Abs(((Rect)(ref rect2)).height);
			}
			return 0f;
		}

		private static float GetButtonIconHeight(TextMeshProUGUI label)
		{
			//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)
			Transform parent = ((TMP_Text)label).transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				return 0f;
			}
			string[] array = new string[3] { "Icon", "BG", "BtnInteraction" };
			foreach (string text in array)
			{
				Transform obj = parent.Find(text);
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if (val != null)
				{
					Rect rect = val.rect;
					float num = Mathf.Abs(((Rect)(ref rect)).height);
					if (num > 1f)
					{
						return num;
					}
				}
			}
			return GetRectHeight((RectTransform?)(object)((parent is RectTransform) ? parent : null));
		}

		private static void ApplyHudFontSize(TextMeshProUGUI label)
		{
			if (IsPhoneAppLabel(label))
			{
				ApplyPhoneWorldFontSizing(label);
			}
			else if (((TMP_Text)label).fontSize < 8f)
			{
				if (((TMP_Text)label).enableAutoSizing)
				{
					((TMP_Text)label).fontSizeMin = Mathf.Max(((TMP_Text)label).fontSizeMin, 10f);
					((TMP_Text)label).fontSizeMax = Mathf.Max(((TMP_Text)label).fontSizeMax, 24f);
					((TMP_Text)label).fontSize = Mathf.Max(((TMP_Text)label).fontSize, 12f);
				}
				else
				{
					((TMP_Text)label).fontSize = 14f;
				}
			}
		}

		private static bool IsPhoneButtonLabel(TextMeshProUGUI label)
		{
			Transform parent = ((TMP_Text)label).transform.parent;
			if (((Object)label).name == "Text" && (Object)(object)parent != (Object)null)
			{
				return ((Object)parent).name.StartsWith("PhoneButtonGrp_", StringComparison.Ordinal);
			}
			return false;
		}

		private static bool IsPhoneHeaderLabel(TextMeshProUGUI label)
		{
			switch (((Object)label).name)
			{
			case "MobileProviderText":
			case "TimeText":
			case "DayText":
				return true;
			default:
				return false;
			}
		}

		private static void ApplyReadableColors(TextMeshProUGUI label)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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)
			//IL_0014: 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_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_0093: Unknown result type (might be due to invalid IL or missing references)
			Color color = ((Graphic)label).color;
			if (color.a < 0.05f || (color.r < 0.05f && color.g < 0.05f && color.b < 0.05f))
			{
				((Graphic)label).color = Color.white;
			}
			((TMP_Text)label).faceColor = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			if ((IsPhoneAppLabel(label) || IsPhoneButtonLabel(label) || IsPhoneHeaderLabel(label)) && !PhoneFontMaterialSnapshot.IsBorderFont(((TMP_Text)label).font))
			{
				((TMP_Text)label).outlineColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);
				((TMP_Text)label).outlineWidth = Mathf.Max(((TMP_Text)label).outlineWidth, 0.1f);
			}
		}

		private static void RepairFontMaterial(TMP_FontAsset font)
		{
			//IL_0064: 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)
			if (!((Object)(object)((TMP_Asset)(font?)).material == (Object)null) && !((Object)(object)font.atlasTexture == (Object)null))
			{
				if ((object)((TMP_Asset)font).material.mainTexture != font.atlasTexture)
				{
					((TMP_Asset)font).material.mainTexture = (Texture)(object)font.atlasTexture;
				}
				if (((TMP_Asset)font).material.HasProperty("_FaceColor") && ((TMP_Asset)font).material.GetColor("_FaceColor").a < 0.05f)
				{
					((TMP_Asset)font).material.SetColor("_FaceColor", Color.white);
				}
			}
		}

		private static Shader? ResolveTmpShader()
		{
			string[] tmpShaderNames = TmpShaderNames;
			for (int i = 0; i < tmpShaderNames.Length; i++)
			{
				Shader val = Shader.Find(tmpShaderNames[i]);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void EnsureFontsCached()
		{
			if (fontsCached)
			{
				return;
			}
			PhoneFontMaterialSnapshot.CaptureIfNeeded();
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name) && (((Object)val).name.StartsWith("FredokaOne", StringComparison.Ordinal) || ((Object)val).name.StartsWith("LiberationSans", StringComparison.Ordinal)))
				{
					RepairFontMaterial(val);
					PhoneFontMaterialSnapshot.RestoreSharedFontMaterial(val);
					CachedFredokaFonts[((Object)val).name] = val;
				}
			}
			fontsCached = true;
		}

		private static TMP_FontAsset? ResolvePhoneFont()
		{
			EnsureFontsCached();
			if (CachedFredokaFonts.TryGetValue("FredokaOne-Regular SDF", out var value))
			{
				return value;
			}
			if (CachedFredokaFonts.TryGetValue("LiberationSans SDF", out var value2))
			{
				return value2;
			}
			if (CachedFredokaFonts.TryGetValue("FredokaOne-Regular SDF border2", out var value3))
			{
				return value3;
			}
			if (CachedFredokaFonts.TryGetValue("FredokaOne-Regular SDF border", out var value4))
			{
				return value4;
			}
			return null;
		}

		private static TMP_FontAsset? ResolveFredokaFont(TMP_FontAsset? current)
		{
			return ResolvePhoneFont() ?? current;
		}

		public static void RepairFredokaFontAssetsPublic()
		{
			RepairFredokaFontAssets();
		}

		private static void RepairFredokaFontAssets()
		{
			PhoneFontMaterialSnapshot.CaptureIfNeeded();
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name) && (((Object)val).name.StartsWith("FredokaOne", StringComparison.Ordinal) || ((Object)val).name.StartsWith("LiberationSans", StringComparison.Ordinal)))
				{
					RepairFontMaterial(val);
					PhoneFontMaterialSnapshot.RestoreSharedFontMaterial(val);
					CachedFredokaFonts[((Object)val).name] = val;
				}
			}
			fontsCached = true;
		}
	}
	internal static class PlayerPatches0703Patches
	{
		private static FieldInfo? FantasyMaterialField;

		private static FieldInfo? CatJobMaterialField;

		private static FieldInfo? MegabotMaterialField;

		private static FieldInfo? GhostMaterialField;

		public static bool CardUI_SetCardUI_Postfix_Prefix()
		{
			return false;
		}

		public static bool InitOpenSequence_BlockExpansionPackBack_Prefix()
		{
			return false;
		}

		public static bool EnterViewUpCloseState_Postfix_Prefix()
		{
			return false;
		}

		public static bool OpenSortAlbumScreen_Postfix_Prefix()
		{
			return false;
		}

		public static bool LightManager_Awake_Prefix_Prefix()
		{
			EnsureMaterialFields();
			if (!AllPackMaterialsReady())
			{
				Plugin.Log.LogDebug((object)"Skipping LightManager pack-material patch; pack materials not initialized yet.");
				return false;
			}
			return true;
		}

		private static void EnsureMaterialFields()
		{
			if (!(FantasyMaterialField != null))
			{
				Type type = AccessTools.TypeByName("TCGShopExpansionMod.Patches.PlayerPatches");
				if (!(type == null))
				{
					FantasyMaterialField = AccessTools.Field(type, "newFantasyPackMaterial");
					CatJobMaterialField = AccessTools.Field(type, "newCatJobPackMaterial");
					MegabotMaterialField = AccessTools.Field(type, "newMegabotPackMaterial");
					GhostMaterialField = AccessTools.Field(type, "newGhostPackMaterial");
				}
			}
		}

		private static bool AllPackMaterialsReady()
		{
			if (IsMaterialReady(FantasyMaterialField) && IsMaterialReady(CatJobMaterialField) && IsMaterialReady(MegabotMaterialField))
			{
				return IsMaterialReady(GhostMaterialField);
			}
			return false;
		}

		private static bool IsMaterialReady(FieldInfo? field)
		{
			if (field == null)
			{
				return false;
			}
			object? value = field.GetValue(null);
			Material val = (Material)((value is Material) ? value : null);
			if (val != null)
			{
				return (Object)(object)val != (Object)null;
			}
			return false;
		}
	}
	internal static class TetramonOverlay0703Patches
	{
		private const float FullCardMinHeight = 420f;

		private const float FullCardMinWidth = 280f;

		private const float PackBackMeshOverscan = 1f;

		private static readonly string[] CardTextFieldNames = new string[11]
		{
			"m_MonsterNameText", "m_DescriptionText", "m_ArtistText", "m_NumberText", "m_RarityText", "m_Stat1Text", "m_Stat2Text", "m_Stat3Text", "m_Stat4Text", "m_FirstEditionText",
			"m_EvoPreviousStageNameText"
		};

		private static readonly (string TextProperty, string EnabledProperty, string FieldName, bool ForceOnFallback)[] ConfigTextBindings = new(string, string, string, bool)[10]
		{
			("Name", "NameEnabled", "m_MonsterNameText", true),
			("Description", "DescriptionEnabled", "m_DescriptionText", true),
			("ArtistText", "ArtistTextEnabled", "m_ArtistText", false),
			("Number", "NumberEnabled", "m_NumberText", false),
			("Rarity", "RarityEnabled", "m_RarityText", false),
			("Stat1", "Stat1Enabled", "m_Stat1Text", false),
			("Stat2", "Stat2Enabled", "m_Stat2Text", false),
			("Stat3", "Stat3Enabled", "m_Stat3Text", false),
			("Stat4", "Stat4Enabled", "m_Stat4Text", false),
			("EditionText", "EditionTextEnabled", "m_FirstEditionText", false)
		};

		private static bool LoggedFirstFullCard;

		private static bool LoggedFirstCenterArt;

		private static bool LoggedMissingArt;

		private static int _gradedNonTetramonApplyDepth;

		private static bool _loggedGradedTextureSlot;

		private static bool _loggedGradedNonTetramonFace;

		private const string GradedCaseChromeObjectName = "GradedCaseChrome0703";

		private const string GradedCaseHeaderBarObjectName = "GradedCaseHeaderBar0703";

		private const float GradedCardAspect = 0.71428573f;

		private const float GradedSlabBezelX = 0.06f;

		private const float GradedSlabBezelBottom = 0.05f;

		private const float GradedSlabHeaderMinY = 0.8f;

		private const float GradedSlabHeaderMaxY = 0.98f;

		private const float AlbumSimplifiedCaseScaleMul = 1f;

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

		private const string GradedCaseUnderlayObjectName = "GradedCaseUnderlay0703";

		private static bool _loggedGradedFaceLayout;

		private static bool _loggedGradedSlabDump;

		private const string GradedCaseFaceObjectName = "GradedFace0703";

		private const string GradeLabelNameObjectName = "GradeName0703";

		private const string GradeLabelNumberObjectName = "GradeNumber0703";

		private const string GradeLabelDescObjectName = "GradeDesc0703";

		private const string GradeLabelExpansionObjectName = "GradeExpansion0703";

		private static bool _loggedGradeTmpPaths;

		private static bool _loggedAlbumHoloBind;

		private static bool _loggedBackMeshShow;

		private const float DisplayBackUiOverscanScale = 1.14f;

		private const float DisplayBackUiBleedPixels = 14f;

		private const int DisplayCardRenderQueue = 3005;

		public static bool SkipMainPostfixForTetramon_Prefix(CardUI __instance, CardData cardData)
		{
			return false;
		}

		public static void ApplyTetramonCardBackFromCache(CardUI cardUi)
		{
			if (!((Object)(object)cardUi.m_CardBackImage == (Object)null))
			{
				Sprite val = CardExtrasCacheAccess.TryGetUiCardBackSprite();
				if (!((Object)(object)val == (Object)null))
				{
					cardUi.m_CardBackImage.sprite = val;
				}
			}
		}

		public static void ApplyNonTetramonPresentation(CardUI cardUi, CardData cardData)
		{
			if (!((Object)(object)cardUi == (Object)null) && cardData != null)
			{
				ApplyNonTetramonFacePresentation(cardUi, cardData);
			}
		}

		public static void ClearStaleOverlayAfterExpansionSwitch(CardUI cardUi)
		{
			if (!((Object)(object)cardUi == (Object)null))
			{
				CardData cardData = cardUi.GetCardData();
				if (cardData != null)
				{
					ApplyNonTetramonFacePresentation(cardUi, cardData);
					return;
				}
				ClearStaleOverlayChromeOnly(cardUi);
				EnsureReadableWithoutFullCardOverlay(cardUi);
			}
		}

		private static void ApplyNonTetramonFacePresentation(CardUI cardUi, CardData cardData)
		{
			if (cardData.cardGrade > 0)
			{
				ApplyGradedNonTetramonFace(cardUi, cardData);
				FinalizeNonTetramonWorldPresentation(cardUi, cardData);
				return;
			}
			Sprite val = ArtExpanderBridge.LoadCardArt(cardData);
			bool fromBridge = (Object)(object)val != (Object)null;
			if ((Object)(object)val == (Object)null)
			{
				val = ResolveCardArt(cardUi, cardData, out fromBridge);
			}
			if ((Object)(object)val != (Object)null && (fromBridge || LooksLikeFullCard(val)))
			{
				ApplyFullCardOverlay(cardUi, val);
				EnsureAlbumArtAndFoilLayering(cardUi);
				FinalizeNonTetramonWorldPresentation(cardUi, cardData);
			}
			else
			{
				ClearStaleOverlayChromeOnly(cardUi);
				StripAlbumHoFoilMaterials(cardUi);
				EnsureReadableWithoutFullCardOverlay(cardUi);
				FinalizeNonTetramonWorldPresentation(cardUi, cardData);
			}
		}

		private static void FinalizeNonTetramonWorldPresentation(CardUI cardUi, CardData cardData)
		{
			if (!((Object)(object)cardUi == (Object)null) && cardData != null && !PackOpeningState.IsPackOpeningInProgress() && !PackOpeningState.IsFanRowVisible() && cardData.cardGrade <= 0)
			{
				if (CardUiDisplayContext.IsBinderAlbumCard(cardUi) || CardUiDisplayContext.IsFlatAlbumOrBinderCard(cardUi))
				{
					ApplyFlatScreenCardPresentation(cardUi);
				}
				else if (CardUiDisplayContext.ShouldUseRotatableWorldCardBack(cardUi))
				{
					ConfigureCard3dForFrontDisplay(cardUi);
				}
				else
				{
					ApplyFlatScreenCardPresentation(cardUi);
				}
			}
		}

		private static void ApplyGradedNonTetramonFace(CardUI cardUi, CardData cardData, bool albumSimplified = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)cardData.expansionType == 0)
			{
				ApplyGradedCardPresentation(cardUi, cardData);
			}
			else if (_gradedNonTetramonApplyDepth <= 0)
			{
				_gradedNonTetramonApplyDepth++;
				try
				{
					ApplyGradedNonTetramonFaceCore(cardUi, cardData, albumSimplified);
				}
				finally
				{
					_gradedNonTetramonApplyDepth--;
				}
			}
		}

		private static void ApplyGradedNonTetramonFaceCore(CardUI cardUi, CardData cardData, bool albumSimplified)
		{
			//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_0191: 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_01b2: Unknown result type (might be due to invalid IL or missing references)
			Sprite val = ArtExpanderBridge.LoadCardArt(cardData);
			bool fromBridge = (Object)(object)val != (Object)null;
			if ((Object)(object)val == (Object)null)
			{
				val = ResolveCardArt(cardUi, cardData, out fromBridge);
			}
			HideDuplicateAlbumFoilHosts(cardUi);
			StripAlbumHoFoilMaterials(cardUi);
			DisableOverlayImage(cardUi);
			HideGradedCardBackFaces(cardUi);
			DisableGradedHeaderTextureSlot(cardUi);
			RestoreGraded3dSlabFaceVisibility(cardUi);
			if ((Object)(object)val == (Object)null || (!fromBridge && !LooksLikeFullCard(val)))
			{
				ApplyGradedCardPresentation(cardUi, cardData);
				HideGradedCardBackFaces(cardUi);
				DisableGradedHeaderTextureSlot(cardUi);
				HideOccludingGradedSlabMeshes(cardUi);
				EnsureGradeLabelTextsVisible(cardUi);
				return;
			}
			if ((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null)
			{
				ApplyGradedCardPresentation(cardUi, cardData);
				HideGradedCardBackFaces(cardUi);
				DisableGradedHeaderTextureSlot(cardUi);
				return;
			}
			EnsureCardShellVisible(cardUi);
			if (!albumSimplified)
			{
				try
				{
					cardUi.m_Show2DGradedCase = true;
					cardUi.ShowGradedCardCase(true);
				}
				catch
				{
				}
			}
			HideOccludingGradedSlabMeshes(cardUi);
			BlankGraded3dSlabCardBackMaterials(cardUi);
			HideGradedCardBackFaces(cardUi);
			DisableGradedHeaderTextureSlot(cardUi);
			EnsureGradedCaseFillsSlot(cardUi);
			ApplyGradedCaseFaceArt(cardUi, val);
			HideOversizedCardFrontBehindSlab(cardUi);
			HideDuplicateAlbumFoilHosts(cardUi);
			StripAlbumHoFoilMaterials(cardUi);
			EnsureGradeLabelTextsVisible(cardUi);
			DumpGradedSlabHierarchyOnce(cardUi);
			cardUi.m_GradedCardCaseGrp.SetActive(true);
			cardUi.m_GradedCardCaseGrp.transform.SetAsLastSibling();
			AlbumHoFoilRepairBehaviour.EnsureOn(cardUi);
			if (!_loggedGradedNonTetramonFace)
			{
				_loggedGradedNonTetramonFace = true;
				ManualLogSource log = Plugin.Log;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(78, 6);
				defaultInterpolatedStringHandler.AppendLiteral("Graded non-Tetramon: UI GradedFace slab ");
				defaultInterpolatedStringHandler.AppendFormatted(((Object)val).name);
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("(");
				Rect rect = val.rect;
				defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).width);
				defaultInterpolatedStringHandler.AppendLiteral("x");
				rect = val.rect;
				defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).height);
				defaultInterpolatedStringHandler.AppendLiteral("), expansion=");
				defaultInterpolatedStringHandler.AppendFormatted<ECardExpansionType>(cardData.expansionType);
				defaultInterpolatedStringHandler.AppendLiteral(", ");
				defaultInterpolatedStringHandler.AppendLiteral("grade=");
				defaultInterpolatedStringHandler.AppendFormatted(cardData.cardGrade);
				defaultInterpolatedStringHandler.AppendLiteral(", simplified=");
				defaultInterpolatedStringHandler.AppendFormatted(albumSimplified);
				defaultInterpolatedStringHandler.AppendLiteral(".");
				log.LogInfo((object)defaultInterpolatedStringHandler.ToStringAndClear());
			}
		}

		private static void RestoreGraded3dSlabFaceVisibility(CardUI cardUi)
		{
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if ((Object)(object)val.m_CardUIAnimGrp != (Object)null)
			{
				((Component)val.m_CardUIAnimGrp).gameObject.SetActive(true);
			}
			val.m_IgnoreCulling = true;
			try
			{
				val.SetAlwaysCulling(false, true);
			}
			catch
			{
			}
			if ((Object)(object)val.m_GradedCardGrp != (Object)null)
			{
				val.m_GradedCardGrp.SetActive(true);
			}
			if ((Object)(object)val.m_GradedCaseCullCardFrontMeshBlocker != (Object)null)
			{
				val.m_GradedCaseCullCardFrontMeshBlocker.SetActive(false);
			}
			if ((Object)(object)val.m_GradedCaseCullCardBackMeshBlocker != (Object)null)
			{
				val.m_GradedCaseCullCardBackMeshBlocker.SetActive(false);
			}
			HideOccludingGradedSlabMeshes(cardUi);
			if ((Object)(object)val.m_GradedCardBrightnessControl != (Object)null)
			{
				((Behaviour)val.m_GradedCardBrightnessControl).enabled = false;
				if ((Object)(object)((Component)val.m_GradedCardBrightnessControl).gameObject != (Object)null)
				{
					((Component)val.m_GradedCardBrightnessControl).gameObject.SetActive(false);
				}
			}
		}

		private static void HideOccludingGradedSlabMeshes(CardUI cardUi)
		{
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)val.m_GradedCardCullGrp != (Object)null)
				{
					val.m_GradedCardCullGrp.SetActive(false);
					ForceDisableSlabRenderersUnder(val.m_GradedCardCullGrp.transform);
				}
				if ((Object)(object)val.m_SlabTopLayerMesh != (Object)null)
				{
					ForceDisableSlabObject(val.m_SlabTopLayerMesh);
				}
				if ((Object)(object)val.m_GradedCardGrp != (Object)null)
				{
					ForceDisableSlabRenderersUnder(val.m_GradedCardGrp.transform);
					DisableNamedChildren(val.m_GradedCardGrp.transform, "Slab_BaseMesh");
					DisableNamedChildren(val.m_GradedCardGrp.transform, "Slab_TopLayerMesh");
					DisableNamedChildren(val.m_GradedCardGrp.transform, "CardBackMeshBlocker");
					DisableNamedChildren(val.m_GradedCardGrp.transform, "CardFrontMeshBlocker");
				}
			}
		}

		private static void ForceDisableSlabRenderersUnder(Transform root)
		{
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
				{
					string text = ((Object)((Component)val).gameObject).name ?? string.Empty;
					if (text.IndexOf("Slab_", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("MeshBlocker", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("TopLayer", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("BaseMesh", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						ForceDisableSlabObject(((Component)val).gameObject);
					}
				}
			}
		}

		private static void DestroyUiOnlyGradedSlabArtifacts(CardUI cardUi)
		{
		}

		private static void ReparentGradeTmpToCase(object? tmp, Transform caseRoot)
		{
			Behaviour val = (Behaviour)((tmp is Behaviour) ? tmp : null);
			if (val != null && !((Object)(object)((Component)val).transform == (Object)null) && (Object)(object)((Component)val).transform.parent != (Object)(object)caseRoot)
			{
				((Component)val).transform.SetParent(caseRoot, false);
			}
		}

		private static void RestoreSlabObject(GameObject? go)
		{
			//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_0027: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			if (go.transform.localScale == Vector3.zero)
			{
				go.transform.localScale = Vector3.one;
			}
			go.SetActive(true);
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					componentsInChildren[i].enabled = true;
				}
			}
		}

		private static void ForceDisableSlabObject(GameObject go)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			go.SetActive(false);
			go.transform.localScale = Vector3.zero;
			Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					componentsInChildren[i].enabled = false;
				}
			}
		}

		private static void DisableNamedChildren(Transform? root, string childName)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && string.Equals(((Object)val).name, childName, StringComparison.OrdinalIgnoreCase))
				{
					ForceDisableSlabObject(((Component)val).gameObject);
				}
			}
		}

		private static void EnableNamedChildren(Transform? root, string childName)
		{
			//IL_0033: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || !string.Equals(((Object)val).name, childName, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				if (val.localScale == Vector3.zero)
				{
					val.localScale = Vector3.one;
				}
				((Component)val).gameObject.SetActive(true);
				Renderer[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<Renderer>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					if ((Object)(object)componentsInChildren2[j] != (Object)null)
					{
						componentsInChildren2[j].enabled = true;
					}
				}
			}
		}

		private static void HideOversizedCardFrontBehindSlab(CardUI cardUi)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			SetCardFrontCanvasActive(cardUi, active: false);
			if ((Object)(object)cardUi.m_CardFront != (Object)null)
			{
				cardUi.m_CardFront.SetActive(false);
				cardUi.m_CardFront.transform.localScale = Vector3.zero;
			}
			SetImageEnabled(cardUi.m_CardFrontImage, enabled: false);
			SetImageEnabled(cardUi.m_CardFrontImageTopLayer, enabled: false);
			SetImageEnabled(cardUi.m_CenterFrameImage, enabled: false);
			DisableOverlayImage(cardUi);
		}

		private static Image GetOrCreateGradedCaseFaceImage(CardUI cardUi)
		{
			//IL_0032: 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)
			Transform transform = cardUi.m_GradedCardCaseGrp.transform;
			Transform val = transform.Find("GradedFace0703");
			Image result = default(Image);
			if ((Object)(object)val != (Object)null && ((Component)val).TryGetComponent<Image>(ref result))
			{
				return result;
			}
			GameObject val2 = new GameObject("GradedFace0703");
			val2.transform.SetParent(transform, false);
			Image obj = val2.AddComponent<Image>();
			((Graphic)obj).raycastTarget = false;
			((MaskableGraphic)obj).maskable = true;
			return obj;
		}

		private static void ApplyGradedCaseFaceArt(CardUI cardUi, Sprite cardArt)
		{
			//IL_003b: 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_00a2: 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_013f: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: 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_0252: 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_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: 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_02d1: 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_0323: 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_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			RestoreGradedCardCaseFrame(cardUi);
			EnsureGradedCaseChrome(cardUi);
			EnsureGradedCaseFillsSlot(cardUi);
			DisableVanillaGradedCaseNullImages(cardUi);
			Image orCreateGradedCaseFaceImage = GetOrCreateGradedCaseFaceImage(cardUi);
			orCreateGradedCaseFaceImage.sprite = cardArt;
			orCreateGradedCaseFaceImage.overrideSprite = null;
			orCreateGradedCaseFaceImage.type = (Type)0;
			orCreateGradedCaseFaceImage.preserveAspect = false;
			((Graphic)orCreateGradedCaseFaceImage).color = Color.white;
			((Graphic)orCreateGradedCaseFaceImage).raycastTarget = false;
			((MaskableGraphic)orCreateGradedCaseFaceImage).maskable = true;
			((Graphic)orCreateGradedCaseFaceImage).material = null;
			((Behaviour)orCreateGradedCaseFaceImage).enabled = true;
			((Component)orCreateGradedCaseFaceImage).gameObject.SetActive(true);
			Transform transform = cardUi.m_GradedCardCaseGrp.transform;
			RectTransform caseRect = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			RectTransform rectTransform = ((Graphic)orCreateGradedCaseFaceImage).rectTransform;
			((Transform)rectTransform).SetParent(cardUi.m_GradedCardCaseGrp.transform, false);
			((Transform)rectTransform).localScale = Vector3.one;
			((Transform)rectTransform).localRotation = Quaternion.identity;
			LayoutGradedFaceInCaseWindow(rectTransform, caseRect, cardArt);
			((Transform)rectTransform).SetSiblingIndex(2);
			Transform val = cardUi.m_GradedCardCaseGrp.transform.Find("GradedCaseHeaderBar0703");
			if ((Object)(object)val != (Object)null)
			{
				val.SetSiblingIndex(3);
			}
			SanitizeGradedCaseNullSprites(cardUi);
			HideOversizedCardFrontBehindSlab(cardUi);
			EnsureGradedCaseFillsSlot(cardUi);
			if (!_loggedGradedFaceLayout)
			{
				_loggedGradedFaceLayout = true;
				Transform transform2 = cardUi.m_GradedCardCaseGrp.transform;
				Transform simplifiedCullingGradedCardFrontScaling = cardUi.m_SimplifiedCullingGradedCardFrontScaling;
				Image component = cardUi.m_GradedCardCaseGrp.GetComponent<Image>();
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				rectTransform.GetWorldCorners(array);
				float num = Vector3.Distance(array[0], array[3]);
				float num2 = Vector3.Distance(array[0], array[1]);
				float value = ((num2 > 1E-05f) ? (num / num2) : 0f);
				bool value2 = (Object)(object)cardUi.m_CardFront != (Object)null && cardUi.m_CardFront.activeSelf;
				RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				Vector2 val3;
				Rect rect;
				if (!((Object)(object)val2 != (Object)null))
				{
					val3 = Vector2.zero;
				}
				else
				{
					rect = val2.rect;
					val3 = ((Rect)(ref rect)).size;
				}
				Vector2 value3 = val3;
				Vector3[] array2 = (Vector3[])(object)new Vector3[4];
				if ((Object)(object)val2 != (Object)null)
				{
					val2.GetWorldCorners(array2);
				}
				float value4 = (((Object)(object)val2 != (Object)null) ? Vector3.Distance(array2[0], array2[3]) : 0f);
				float value5 = (((Object)(object)val2 != (Object)null) ? Vector3.Distance(array2[0], array2[1]) : 0f);
				Transform parent = transform2.parent;
				RectTransform val4 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				Vector2 val5;
				if (!((Object)(object)val4 != (Object)null))
				{
					val5 = Vector2.zero;
				}
				else
				{
					rect = val4.rect;
					val5 = ((Rect)(ref rect)).size;
				}
				Vector2 value6 = val5;
				ManualLogSource log = Plugin.Log;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(219, 18);
				defaultInterpolatedStringHandler.AppendLiteral("GradedFace UI slab layout faceAnchors=(");
				defaultInterpolatedStringHandler.AppendFormatted(rectTransform.anchorMin.x, "F2");
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(rectTransform.anchorMin.y, "F2");
				defaultInterpolatedStringHandler.AppendLiteral(")-");
				defaultInterpolatedStringHandler.AppendLiteral("(");
				defaultInterpolatedStringHandler.AppendFormatted(rectTransform.anchorMax.x, "F2");
				defaultInterpolatedStringHandler.AppendLiteral(",");
				defaultInterpolatedStringHandler.AppendFormatted(rectTransform.anchorMax.y, "F2");
				defaultInterpolatedStringHandler.AppendLiteral(") ");
				defaultInterpolatedStringHandler.AppendLiteral("faceSizeDelta=");
				defaultInterpolatedStringHandler.AppendFormatted<Vector2>(rectTransform.sizeDelta);
				defaultInterpolatedStringHandler.AppendLiteral(" faceWorldAspect=");
				defaultInterpolatedStringHandler.AppendFormatted(value, "F3");
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("targetAspect=");
				defaultInterpolatedStringHandler.AppendFormatted(0.71428573f, "F3");
				defaultInterpolatedStringHandler.AppendLiteral(" cardFrontActive=");
				defaultInterpolatedStringHandler.AppendFormatted(value2);
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("caseRect=");
				defaultInterpolatedStringHandler.AppendFormatted<Vector2>(value3);
				defaultInterpolatedStringHandler.AppendLiteral(" caseWorld=(");
				defaultInterpolatedStringHandler.AppendFormatted(value4, "F2");
				defaultInterpolatedStringHandler.AppendLiteral("x");
				defaultInterpolatedStringHandler.AppendFormatted(value5, "F2");
				defaultInterpolatedStringHandler.AppendLiteral(") ");
				defaultInterpolatedStringHandler.AppendLiteral("caseLocalScale=");
				defaultInterpolatedStringHandler.AppendFormatted<Vector3>(transform2.localScale);
				defaultInterpolatedStringHandler.AppendLiteral(" pocketRect=");
				defaultInterpolatedStringHandler.AppendFormatted<Vector2>(value6);
				defaultInterpolatedStringHandler.AppendLiteral(" pocketName=");
				Transform parent2 = transform2.parent;
				defaultInterpolatedStringHandler.AppendFormatted((parent2 != null) ? ((Object)parent2).name : null);
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("simplifiedScale=");
				defaultInterpolatedStringHandler.AppendFormatted(((Object)(object)simplifiedCullingGradedCardFrontScaling != (Object)null) ? ((object)simplifiedCullingGradedCardFrontScaling.localScale/*cast due to .constrained prefix*/).ToString() : "n/a");
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("scaleMul=");
				defaultInterpolatedStringHandler.AppendFormatted(1f, "F2");
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("frameSprite=");
				object obj;
				if (component == null)
				{
					obj = null;
				}
				else
				{
					Sprite sprite = component.sprite;
					obj = ((sprite != null) ? ((Object)sprite).name : null);
				}
				if (obj == null)
				{
					obj = "null";
				}
				defaultInterpolatedStringHandler.AppendFormatted((string?)obj);
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("album=");
				defaultInterpolatedStringHandler.AppendFormatted(ShouldUseAlbumSimplifiedCaseScale(cardUi));
				log.LogInfo((object)defaultInterpolatedStringHandler.ToStringAndClear());
			}
		}

		private static void RestoreGradedCardCaseFrame(CardUI cardUi)
		{
			//IL_004d: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null))
			{
				Image val = default(Image);
				if (!cardUi.m_GradedCardCaseGrp.TryGetComponent<Image>(ref val))
				{
					val = cardUi.m_GradedCardCaseGrp.AddComponent<Image>();
				}
				Sprite sprite = GradedCardCaseSprite.Get();
				val.sprite = sprite;
				val.overrideSprite = null;
				val.type = (Type)0;
				val.preserveAspect = false;
				((Graphic)val).color = Color.white;
				((Graphic)val).material = null;
				((Graphic)val).raycastTarget = false;
				((MaskableGraphic)val).maskable = true;
				((Behaviour)val).enabled = true;
				((Component)val).gameObject.SetActive(true);
				RectTransform rectTransform = ((Graphic)val).rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = Vector2.zero;
				rectTransform.offsetMax = Vector2.zero;
			}
		}

		private static void EnsureGradedCaseFillsSlot(CardUI cardUi)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0053: 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_006b: 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)
			if (!((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null))
			{
				Transform transform = cardUi.m_GradedCardCaseGrp.transform;
				Transform simplifiedCullingGradedCardFrontScaling = cardUi.m_SimplifiedCullingGradedCardFrontScaling;
				if (ShouldUseAlbumSimplifiedCaseScale(cardUi) && (Object)(object)simplifiedCullingGradedCardFrontScaling != (Object)null)
				{
					Vector3 localScale = simplifiedCullingGradedCardFrontScaling.localScale;
					transform.localScale = new Vector3(localScale.x * 1f, localScale.y * 1f, localScale.z * 1f);
					transform.localPosition = simplifiedCullingGradedCardFrontScaling.localPosition;
				}
				else
				{
					transform.localScale = Vector3.one;
					Vector3 localPosition = transform.localPosition;
					transform.localPosition = new Vector3(0f, 0f, (Mathf.Abs(localPosition.z) > 0.001f) ? localPosition.z : (-2f));
				}
			}
		}

		private static bool ShouldUseAlbumSimplifiedCaseScale(CardUI cardUi)
		{
			if (CardUiDisplayContext.IsBinderAlbumCard(cardUi))
			{
				return true;
			}
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if ((Object)(object)val?.m_GradedCardCullGrp != (Object)null)
			{
				return !val.m_GradedCardCullGrp.activeSelf;
			}
			return false;
		}

		private static void DisableVanillaGradedCaseNullImages(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null)
			{
				return;
			}
			DisableNullSpritesUnderCase(cardUi, cardUi.m_GradedCardCaseGrp.transform);
			Transform parent = cardUi.m_GradedCardCaseGrp.transform.parent;
			if ((Object)(object)parent != (Object)null)
			{
				DisableNullSpritesUnderCase(cardUi, parent);
				if ((Object)(object)parent.parent != (Object)null)
				{
					DisableNullSpritesUnderCase(cardUi, parent.parent);
				}
			}
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if ((Object)(object)val != (Object)null)
			{
				DisableNullSpritesUnderCase(cardUi, ((Component)val).transform);
			}
			NeutralizeGradedSelectionArtifacts(cardUi);
		}

		private static bool IsOwnGradedCaseObject(string objectName)
		{
			switch (objectName)
			{
			default:
				return objectName == "TetramonOverlay0703";
			case "GradedFace0703":
			case "GradedCaseChrome0703":
			case "GradedCaseHeaderBar0703":
			case "GradedCaseUnderlay0703":
			case "GradedCardCase":
				return true;
			}
		}

		private static void NeutralizeGradedSelectionArtifacts(CardUI cardUi)
		{
			//IL_00bf: 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_00fd: 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_010d: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: 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_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null)
			{
				return;
			}
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			Graphic[] componentsInChildren = ((Component)(((Object)(object)val != (Object)null && (Object)(object)((Component)val).transform.parent != (Object)null) ? ((Component)val).transform.parent : cardUi.m_GradedCardCaseGrp.transform)).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)((Component)val2).gameObject == (Object)null || (!(val2 is Image) && !(val2 is RawImage)) || IsOwnGradedCaseObject(((Object)((Component)val2).gameObject).name) || ((Component)val2).gameObject == cardUi.m_GradedCardCaseGrp)
				{
					continue;
				}
				Image val3 = (Image)(object)((val2 is Image) ? val2 : null);
				bool flag = ((val3 == null) ? ((Object)(object)((RawImage)val2).texture == (Object)null) : ((Object)(object)val3.sprite == (Object)null || (Object)(object)val3.sprite.texture == (Object)null));
				Color color = val2.color;
				bool flag2 = color.a > 0.05f && color.g > 0.55f && color.r < 0.45f && color.b < 0.45f;
				if ((!flag && !flag2) || !((Behaviour)val2).enabled || !((Component)val2).gameObject.activeInHierarchy)
				{
					continue;
				}
				string transformPath = GetTransformPath(((Component)val2).transform);
				if (_loggedGreenArtifacts.Add(transformPath))
				{
					Image val4 = (Image)(object)((val2 is Image) ? val2 : null);
					object obj;
					if (val4 == null)
					{
						obj = "n/a";
					}
					else
					{
						Sprite sprite = val4.sprite;
						obj = ((sprite != null) ? ((Object)sprite).name : null) ?? "null";
					}
					string value = (string)obj;
					RawImage val5 = (RawImage)(object)((val2 is RawImage) ? val2 : null);
					object obj2;
					if (val5 == null)
					{
						obj2 = "n/a";
					}
					else
					{
						Texture texture = val5.texture;
						obj2 = ((texture != null) ? ((Object)texture).name : null) ?? "null";
					}
					string value2 = (string)obj2;
					Plugin.Log.LogWarning((object)$"Graded selection artifact neutralized type={((object)val2).GetType().Name} path={transformPath} color={color} nullGraphic={flag} greenTint={flag2} sprite={value} tex={value2}");
				}
				((Behaviour)val2).enabled = false;
				val2.color = new Color(color.r, color.g, color.b, 0f);
			}
		}

		private static void DisableNullSpritesUnderCase(CardUI cardUi, Transform root)
		{
			//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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
				{
					continue;
				}
				switch (((Object)((Component)val).gameObject).name)
				{
				case "GradedFace0703":
				case "GradedCaseChrome0703":
				case "GradedCaseHeaderBar0703":
				case "GradedCaseUnderlay0703":
				case "GradedCardCase":
				case "TetramonOverlay0703":
					continue;
				}
				if (((Component)val).gameObject == cardUi.m_GradedCardCaseGrp)
				{
					continue;
				}
				if (!((Object)(object)val.sprite == (Object)null) && !((Object)(object)val.sprite.texture == (Object)null))
				{
					Rect rect = val.sprite.rect;
					if (!(((Rect)(ref rect)).width <= 1f))
					{
						continue;
					}
					rect = val.sprite.rect;
					if (!(((Rect)(ref rect)).height <= 1f))
					{
						continue;
					}
				}
				((Behaviour)val).enabled = false;
				((Graphic)val).color = new Color(0f, 0f, 0f, 0f);
				((Component)val).gameObject.SetActive(false);
			}
		}

		private static void EnsureGradedCaseChrome(CardUI cardUi)
		{
			//IL_0046: 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_0082: 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_0098: 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_00ae: 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_00fe: 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_0145: 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_015b: 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_0171: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: 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_022a: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = cardUi.m_GradedCardCaseGrp.transform;
			Sprite val = SolidWhiteUiSprite.Get();
			Image orCreateCaseImage = GetOrCreateCaseImage(transform, "GradedCaseUnderlay0703");
			orCreateCaseImage.sprite = val;
			orCreateCaseImage.overrideSprite = val;
			orCreateCaseImage.type = (Type)0;
			((Graphic)orCreateCaseImage).color = new Color(0.05f, 0.06f, 0.07f, 1f);
			((Graphic)orCreateCaseImage).material = null;
			((Graphic)orCreateCaseImage).raycastTarget = false;
			((Behaviour)orCreateCaseImage).enabled = true;
			((Component)orCreateCaseImage).gameObject.SetActive(true);
			RectTransform rectTransform = ((Graphic)orCreateCaseImage).rectTransform;
			rectTransform.anchorMin = GradedCardCaseSprite.SlabAnchorMin;
			rectTransform.anchorMax = GradedCardCaseSprite.SlabAnchorMax;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			rectTransform.anchoredPosition = Vector2.zero;
			rectTransform.sizeDelta = Vector2.zero;
			((Transform)rectTransform).localScale = Vector3.one;
			((Transform)rectTransform).SetSiblingIndex(0);
			Image orCreateCaseImage2 = GetOrCreateCaseImage(transform, "GradedCaseChrome0703");
			orCreateCaseImage2.sprite = val;
			orCreateCaseImage2.overrideSprite = val;
			orCreateCaseImage2.type = (Type)0;
			((Graphic)orCreateCaseImage2).color = new Color(0.12f, 0.13f, 0.15f, 1f);
			((Graphic)orCreateCaseImage2).material = null;
			((Graphic)orCreateCaseImage2).raycastTarget = false;
			((Behaviour)orCreateCaseImage2).enabled = true;
			((Component)orCreateCaseImage2).gameObject.SetActive(true);
			RectTransform rectTransform2 = ((Graphic)orCreateCaseImage2).rectTransform;
			rectTransform2.anchorMin = GradedCardCaseSprite.FaceAnchorMin;
			rectTransform2.anchorMax = GradedCardCaseSprite.FaceAnchorMax;
			rectTransform2.offsetMin = Vector2.zero;
			rectTransform2.offsetMax = Vector2.zero;
			rectTransform2.anchoredPosition = Vector2.zero;
			rectTransform2.sizeDelta = Vector2.zero;
			((Transform)rectTransform2).localScale = Vector3.one;
			((Transform)rectTransform2).SetSiblingIndex(1);
			Image orCreateCaseImage3 = GetOrCreateCaseImage(transform, "GradedCaseHeaderBar0703");
			orCreateCaseImage3.sprite = val;
			orCreateCaseImage3.overrideSprite = val;
			orCreateCaseImage3.type = (Type)0;
			((Graphic)orCreateCaseImage3).color = new Color(0.06f, 0.07f, 0.09f, 1f);
			((Graphic)orCreateCaseImage3).material = null;
			((Graphic)orCreateCaseImage3).raycastTarget = false;
			((Behaviour)orCreateCaseImage3).enabled = true;
			((Component)orCreateCaseImage3).gameObject.SetActive(true);
			RectTransform rectTransform3 = ((Graphic)orCreateCaseImage3).rectTransform;
			rectTransform3.anchorMin = GradedCardCaseSprite.HeaderAnchorMin;
			rectTransform3.anchorMax = GradedCardCaseSprite.HeaderAnchorMax;
			rectTransform3.offsetMin = Vector2.zero;
			rectTransform3.offsetMax = Vector2.zero;
			rectTransform3.anchoredPosition = Vector2.zero;
			rectTransform3.sizeDelta = Vector2.zero;
			((Transform)rectTransform3).localScale = Vector3.one;
			((Transform)rectTransform3).SetSiblingIndex(3);
			if ((Object)(object)((Component)orCreateCaseImage3).GetComponent<RectMask2D>() == (Object)null)
			{
				((Component)orCreateCaseImage3).gameObject.AddComponent<RectMask2D>();
			}
			Canvas component = ((Component)orCreateCaseImage3).GetComponent<Canvas>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			GraphicRaycaster component2 = ((Component)orCreateCaseImage3).GetComponent<GraphicRaycaster>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
		}

		private static void SanitizeGradedCaseNullSprites(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null)
			{
				return;
			}
			Sprite val = SolidWhiteUiSprite.Get();
			Image[] componentsInChildren = cardUi.m_GradedCardCaseGrp.GetComponentsInChildren<Image>(true);
			foreach (Image val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)((Component)val2).gameObject == (Object)null)
				{
					continue;
				}
				string name = ((Object)((Component)val2).gameObject).name;
				switch (name)
				{
				case "GradedFace0703":
				case "GradedCaseChrome0703":
				case "GradedCaseHeaderBar0703":
				case "GradedCaseUnderlay0703":
				case "GradedCardCase":
					continue;
				}
				if (((Component)val2).gameObject != cardUi.m_GradedCardCaseGrp && !((Object)(object)val2.sprite != (Object)null))
				{
					switch (name)
					{
					case "GradedCaseChrome0703":
					case "GradedCaseHeaderBar0703":
					case "GradedCaseUnderlay0703":
						val2.sprite = val;
						val2.overrideSprite = val;
						break;
					default:
						((Behaviour)val2).enabled = false;
						((Component)val2).gameObject.SetActive(false);
						break;
					}
				}
			}
		}

		private static Image GetOrCreateCaseImage(Transform caseRoot, string objectName)
		{
			//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)
			Transform val = caseRoot.Find(objectName);
			Image result = default(Image);
			if ((Object)(object)val != (Object)null && ((Component)val).TryGetComponent<Image>(ref result))
			{
				return result;
			}
			GameObject val2 = new GameObject(objectName);
			val2.transform.SetParent(caseRoot, false);
			Image obj = val2.AddComponent<Image>();
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		private static void LayoutGradedFaceInCaseWindow(RectTransform faceRect, RectTransform? caseRect, Sprite? art)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0033: 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_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_0082: 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_0093: 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_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_00d5: 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_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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: 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_00f0: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			Vector2 faceAnchorMin = GradedCardCaseSprite.FaceAnchorMin;
			Vector2 faceAnchorMax = GradedCardCaseSprite.FaceAnchorMax;
			Rect rect;
			float num;
			if ((Object)(object)caseRect != (Object)null)
			{
				rect = caseRect.rect;
				if (((Rect)(ref rect)).width > 1f)
				{
					rect = caseRect.rect;
					num = Mathf.Abs(((Rect)(ref rect)).width);
					goto IL_0046;
				}
			}
			num = 900f;
			goto IL_0046;
			IL_0046:
			float num2 = num;
			float num3;
			if ((Object)(object)caseRect != (Object)null)
			{
				rect = caseRect.rect;
				if (((Rect)(ref rect)).height > 1f)
				{
					rect = caseRect.rect;
					num3 = Mathf.Abs(((Rect)(ref rect)).height);
					goto IL_0081;
				}
			}
			num3 = 900f;
			goto IL_0081;
			IL_0081:
			float num4 = num3;
			float num5 = (faceAnchorMax.x - faceAnchorMin.x) * num2;
			float num6 = (faceAnchorMax.y - faceAnchorMin.y) * num4;
			if (num5 <= 1f || num6 <= 1f)
			{
				num5 = 720f;
				num6 = 594f;
			}
			float num7 = 0.71428573f;
			if ((Object)(object)art != (Object)null)
			{
				rect = art.rect;
				if (((Rect)(ref rect)).height > 1f)
				{
					rect = art.rect;
					float width = ((Rect)(ref rect)).width;
					rect = art.rect;
					float num8 = width / ((Rect)(ref rect)).height;
					if (num8 >= 0.45f && num8 <= 1.05f)
					{
						num7 = num8;
					}
				}
			}
			float num9 = num5;
			float num10 = num9 / num7;
			if (num10 > num6)
			{
				num10 = num6;
				num9 = num10 * num7;
			}
			num9 *= 0.98f;
			num10 *= 0.98f;
			float num11 = (faceAnchorMin.x + faceAnchorMax.x) * 0.5f;
			float num12 = (faceAnchorMin.y + faceAnchorMax.y) * 0.5f;
			((Transform)faceRect).localRotation = Quaternion.identity;
			((Transform)faceRect).localScale = Vector3.one;
			faceRect.pivot = new Vector2(0.5f, 0.5f);
			faceRect.anchorMin = new Vector2(num11, num12);
			faceRect.anchorMax = new Vector2(num11, num12);
			faceRect.sizeDelta = new Vector2(num9, num10);
			faceRect.anchoredPosition = Vector2.zero;
		}

		private static void DestroyFakeGradedCaseChrome(CardUI cardUi)
		{
			if (!((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null))
			{
				Transform transform = cardUi.m_GradedCardCaseGrp.transform;
				DestroyNamedChild(transform, "GradedCaseUnderlay0703");
				DestroyNamedChild(transform, "GradedCaseChrome0703");
				DestroyNamedChild(transform, "GradedCaseHeaderBar0703");
			}
		}

		private static void DestroyNamedChild(Transform parent, string childName)
		{
			Transform val = parent.Find(childName);
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		private static void ResetGradedSlabPlasticMeshes(CardUI cardUi)
		{
			HideOccludingGradedSlabMeshes(cardUi);
		}

		private static void ApplyGradedArtTo3dFaceMeshes(CardUI cardUi, Sprite cardArt)
		{
		}

		private static void DumpGradedSlabHierarchyOnce(CardUI cardUi)
		{
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			if (_loggedGradedSlabDump)
			{
				return;
			}
			_loggedGradedSlabDump = true;
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			Plugin.Log.LogWarning((object)"=== Graded slab hierarchy dump (once) ===");
			DumpImagesUnder("CardUI", ((Component)cardUi).transform);
			if ((Object)(object)val != (Object)null)
			{
				DumpImagesUnder("Card3d", ((Component)val).transform);
				DumpRenderersUnder("Card3d", ((Component)val).transform);
				ManualLogSource log = Plugin.Log;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(79, 6);
				defaultInterpolatedStringHandler.AppendLiteral("card3d flags: gradedGrp=");
				GameObject gradedCardGrp = val.m_GradedCardGrp;
				defaultInterpolatedStringHandler.AppendFormatted((gradedCardGrp != null) ? new bool?(gradedCardGrp.activeSelf) : ((bool?)null));
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("cullGrp=");
				GameObject gradedCardCullGrp = val.m_GradedCardCullGrp;
				defaultInterpolatedStringHandler.AppendFormatted((gradedCardCullGrp != null) ? new bool?(gradedCardCullGrp.activeSelf) : ((bool?)null));
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("slabTop=");
				GameObject slabTopLayerMesh = val.m_SlabTopLayerMesh;
				defaultInterpolatedStringHandler.AppendFormatted((slabTopLayerMesh != null) ? new bool?(slabTopLayerMesh.activeSelf) : ((bool?)null));
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("animGrp=");
				Transform cardUIAnimGrp = val.m_CardUIAnimGrp;
				defaultInterpolatedStringHandler.AppendFormatted((cardUIAnimGrp != null) ? new bool?(((Component)cardUIAnimGrp).gameObject.activeSelf) : ((bool?)null));
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("frontBlocker=");
				GameObject gradedCaseCullCardFrontMeshBlocker = val.m_GradedCaseCullCardFrontMeshBlocker;
				defaultInterpolatedStringHandler.AppendFormatted((gradedCaseCullCardFrontMeshBlocker != null) ? new bool?(gradedCaseCullCardFrontMeshBlocker.activeSelf) : ((bool?)null));
				defaultInterpolatedStringHandler.AppendLiteral(" ");
				defaultInterpolatedStringHandler.AppendLiteral("frontMeshPos=");
				GameObject cardFrontMeshPos = val.m_CardFrontMeshPos;
				defaultInterpolatedStringHandler.AppendFormatted((cardFrontMeshPos != null) ? new bool?(cardFrontMeshPos.activeSelf) : ((bool?)null));
				log.LogWarning((object)defaultInterpolatedStringHandler.ToStringAndClear());
			}
			else
			{
				Plugin.Log.LogWarning((object)"card3d=null");
			}
			if ((Object)(object)cardUi.m_CardFront != (Object)null)
			{
				Transform transform = cardUi.m_CardFront.transform;
				ManualLogSource log2 = Plugin.Log;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler2 = new DefaultInterpolatedStringHandler(37, 4);
				defaultInterpolatedStringHandler2.AppendLiteral("CardFront active=");
				defaultInterpolatedStringHandler2.AppendFormatted(cardUi.m_CardFront.activeSelf);
				defaultInterpolatedStringHandler2.AppendLiteral(" scale=");
				defaultInterpolatedStringHandler2.AppendFormatted<Vector3>(transform.localScale);
				defaultInterpolatedStringHandler2.AppendLiteral(" ");
				defaultInterpolatedStringHandler2.AppendLiteral("pos=");
				defaultInterpolatedStringHandler2.AppendFormatted<Vector3>(transform.localPosition);
				defaultInterpolatedStringHandler2.AppendLiteral(" sprite=");
				Image cardFrontImage = cardUi.m_CardFrontImage;
				object value;
				if (cardFrontImage == null)
				{
					value = null;
				}
				else
				{
					Sprite sprite = cardFrontImage.sprite;
					value = ((sprite != null) ? ((Object)sprite).name : null);
				}
				defaultInterpolatedStringHandler2.AppendFormatted((string?)value);
				log2.LogWarning((object)defaultInterpolatedStringHandler2.ToStringAndClear());
			}
		}

		private static void DumpImagesUnder(string label, Transform root)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			int num = 0;
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (num >= 40)
				{
					break;
				}
				Image val = componentsInChildren[i];
				if (!((Object)(object)val == (Object)null))
				{
					string value = (((Object)(object)val.sprite != (Object)null) ? ((Object)val.sprite).name : "null");
					RectTransform rectTransform = ((Graphic)val).rectTransform;
					Plugin.Log.LogWarning((object)$"{label} Image[{num}] path={GetTransformPath(((Component)val).transform)} sprite={value} enabled={((Behaviour)val).enabled} active={((Component)val).gameObject.activeInHierarchy} size={rectTransform.sizeDelta} scale={((Transform)rectTransform).localScale}");
					num++;
				}
			}
		}

		private static void DumpRenderersUnder(string label, Transform root)
		{
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			int num = 0;
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (num >= 40)
				{
					break;
				}
				Renderer val = componentsInChildren[i];
				if (!((Object)(object)val == (Object)null))
				{
					Material sharedMaterial = val.sharedMaterial;
					Texture val2 = ((!((Object)(object)sharedMaterial != (Object)null)) ? null : (sharedMaterial.HasProperty("_MainTex") ? sharedMaterial.GetTexture("_MainTex") : sharedMaterial.mainTexture));
					Plugin.Log.LogWarning((object)$"{label} Renderer[{num}] path={GetTransformPath(((Component)val).transform)} mat={((sharedMaterial != null) ? ((Object)sharedMaterial).name : null)} tex={((val2 != null) ? ((Object)val2).name : null)} enabled={val.enabled} active={((Component)val).gameObject.activeInHierarchy}");
					num++;
				}
			}
		}

		private static string GetTransformPath(Transform t)
		{
			string text = ((Object)t).name;
			Transform parent = t.parent;
			int num = 0;
			while ((Object)(object)parent != (Object)null && num < 6)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
				num++;
			}
			return text;
		}

		private static void BlankGraded3dSlabCardBackMaterials(CardUI cardUi)
		{
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if (!((Object)(object)val == (Object)null))
			{
				BlankCardBackScratchRenderersUnder(((Object)(object)val.m_GradedCardGrp != (Object)null) ? val.m_GradedCardGrp.transform : null);
				BlankCardBackScratchRenderersUnder(((Object)(object)val.m_GradedCardCullGrp != (Object)null) ? val.m_GradedCardCullGrp.transform : null);
				BlankCardBackScratchRenderersUnder(((Object)(object)val.m_SlabTopLayerMesh != (Object)null) ? val.m_SlabTopLayerMesh.transform : null);
				BlankCardBackScratchRenderersUnder(((Component)val).transform);
			}
		}

		private static void BlankCardBackScratchRenderersUnder(Transform? root)
		{
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Texture2D clearTexture = GradedScratchClearSprite.ClearTexture;
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = (((Object)(object)((Component)val).gameObject != (Object)null) ? ((Object)((Component)val).gameObject).name : string.Empty);
				Material[] materials = val.materials;
				bool flag = false;
				foreach (Material val2 in materials)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					string text2 = ((Object)val2).name ?? string.Empty;
					Texture val3 = (val2.HasProperty("_MainTex") ? val2.GetTexture("_MainTex") : val2.mainTexture);
					string text3 = (((Object)(object)val3 != (Object)null) ? (((Object)val3).name ?? string.Empty) : string.Empty);
					if (text.IndexOf("Slab_", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("TopLayer", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("BaseMesh", StringComparison.OrdinalIgnoreCase) < 0 && (text2.IndexOf("Scratch", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("GradeCard", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("CardBack", StringComparison.OrdinalIgnoreCase) >= 0 || text3.IndexOf("Scratch", StringComparison.OrdinalIgnoreCase) >= 0 || text3.IndexOf("GradeCard", StringComparison.OrdinalIgnoreCase) >= 0 || text3.IndexOf("CardBack", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Scratch", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("CardBack", StringComparison.OrdinalIgnoreCase) >= 0) && text.IndexOf("Front", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("Face", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("CardArt", StringComparison.OrdinalIgnoreCase) < 0)
					{
						if (val2.HasProperty("_MainTex"))
						{
							val2.SetTexture("_MainTex", (Texture)(object)clearTexture);
						}
						if (val2.HasProperty("_BaseMap"))
						{
							val2.SetTexture("_BaseMap", (Texture)(object)clearTexture);
						}
						val2.mainTexture = (Texture)(object)clearTexture;
						if (val2.HasProperty("_Color"))
						{
							val2.SetColor("_Color", Color.clear);
						}
						flag = true;
					}
				}
				if (flag)
				{
					val.materials = materials;
				}
				MaterialPropertyBlock val4 = new MaterialPropertyBlock();
				val.GetPropertyBlock(val4);
				if (val4.HasTexture("_MainTex"))
				{
					Texture texture = val4.GetTexture("_MainTex");
					string text4 = (((Object)(object)texture != (Object)null) ? (((Object)texture).name ?? string.Empty) : string.Empty);
					if (text4.IndexOf("CardBack", StringComparison.OrdinalIgnoreCase) >= 0 || text4.IndexOf("Scratch", StringComparison.OrdinalIgnoreCase) >= 0 || text4.IndexOf("GradeCard", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						val4.SetTexture("_MainTex", (Texture)(object)clearTexture);
						val.SetPropertyBlock(val4);
					}
				}
			}
		}

		private static void FitCardFrontIntoGradedSlabWindow(CardUI cardUi)
		{
			//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_0054: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cardUi.m_CardFront == (Object)null) && !((Object)(object)cardUi.m_GradedCardFrontScaling == (Object)null))
			{
				Transform transform = cardUi.m_CardFront.transform;
				Transform gradedCardFrontScaling = cardUi.m_GradedCardFrontScaling;
				cardUi.m_CardFront.SetActive(true);
				transform.localPosition = gradedCardFrontScaling.localPosition;
				transform.localScale = gradedCardFrontScaling.localScale;
				transform.localRotation = gradedCardFrontScaling.localRotation;
			}
		}

		private static void PaintGradedCardFrontArt(CardUI cardUi, Sprite cardArt)
		{
			HideCenterFrameArt(cardUi);
			HideDuplicateTextWhenOverlayShown(cardUi);
			HideDuplicateAlbumFoilHosts(cardUi);
			StripAlbumHoFoilMaterials(cardUi);
			SetImageEnabled(cardUi.m_BrightnessControl, enabled: false);
			SetImageEnabled(cardUi.m_CardBGImage, enabled: false);
			SetImageEnabled(cardUi.m_CardBorderImage, enabled: false);
			SetImageEnabled(cardUi.m_CardFullBGImage, enabled: false);
			SetImageEnabled(cardUi.m_CardFullTransparentLayerBGImage, enabled: false);
			SetImageEnabled(cardUi.m_RarityImage, enabled: false);
			SetImageEnabled(cardUi.m_FadeBarTopImage, enabled: false);
			SetImageEnabled(cardUi.m_FadeBarBtmImage, enabled: false);
			SetImageEnabled(cardUi.m_StatImage, enabled: false);
			ApplySpriteToCardFrontImage(cardUi.m_CardFrontImage, cardArt);
			ResetImageToDefaultUiMaterial(cardUi.m_CardFrontImage);
			SetImageEnabled(cardUi.m_CardFrontImageTopLayer, enabled: false);
			DisableGradedTextureMask(cardUi);
		}

		private static void DisableGradedTextureMask(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_GradedCardTextureImage != (Object)null && (Object)(object)((Component)cardUi.m_GradedCardTextureImage).transform.parent != (Object)null)
			{
				Transform parent = ((Component)cardUi.m_GradedCardTextureImage).transform.parent;
				if (((Object)parent).name.IndexOf("GradedCardTextureMask", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					((Component)parent).gameObject.SetActive(false);
				}
			}
			Transform val = (((Object)(object)cardUi.m_CardFront != (Object)null) ? cardUi.m_CardFront.transform : null);
			if (!((Object)(object)val == (Object)null))
			{
				Transform val2 = val.Find("GradedCardTextureMask");
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(false);
				}
			}
		}

		private static void ApplySpriteToCardFrontImage(Image? image, Sprite cardArt)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				image.sprite = cardArt;
				image.type = (Type)0;
				image.preserveAspect = false;
				((Graphic)image).color = Color.white;
				((Graphic)image).raycastTarget = false;
				((MaskableGraphic)image).maskable = true;
				((Graphic)image).material = null;
				((Behaviour)image).enabled = true;
				if ((Object)(object)((Component)image).gameObject != (Object)null)
				{
					((Component)image).gameObject.SetActive(true);
				}
			}
		}

		private static void DisableLegacyGradedCaseFace(CardUI cardUi)
		{
		}

		private static void DisableGradedHeaderTextureSlot(CardUI cardUi)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			Sprite val = GradedScratchClearSprite.Get();
			if ((Object)(object)cardUi.m_GradedCardTextureImage != (Object)null)
			{
				Image gradedCardTextureImage = cardUi.m_GradedCardTextureImage;
				if (!_loggedGradedTextureSlot)
				{
					_loggedGradedTextureSlot = true;
					ManualLogSource log = Plugin.Log;
					Sprite sprite = gradedCardTextureImage.sprite;
					log.LogInfo((object)("Hard-disabling graded header texture slot (was sprite=" + (((sprite != null) ? ((Object)sprite).name : null) ?? "null") + "). UI scratch + 3D slab label CardBack cleared separately."));
				}
				gradedCardTextureImage.sprite = val;
				gradedCardTextureImage.overrideSprite = val;
				((Graphic)gradedCardTextureImage).material = null;
				((Graphic)gradedCardTextureImage).color = Color.clear;
				((Behaviour)gradedCardTextureImage).enabled = false;
				if ((Object)(object)((Component)gradedCardTextureImage).gameObject != (Object)null)
				{
					((Component)gradedCardTextureImage).gameObject.SetActive(false);
				}
			}
			if ((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null)
			{
				return;
			}
			Transform transform = cardUi.m_GradedCardCaseGrp.transform;
			Image[] componentsInChildren = ((Component)transform).GetComponentsInChildren<Image>(true);
			foreach (Image val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string text = (((Object)(object)((Component)val2).gameObject != (Object)null) ? ((Object)((Component)val2).gameObject).name : string.Empty);
				switch (text)
				{
				case "GradedFace0703":
				case "GradedCaseChrome0703":
				case "GradedCaseHeaderBar0703":
					continue;
				}
				string text2 = (((Object)(object)val2.sprite != (Object)null) ? (((Object)val2.sprite).name ?? string.Empty) : string.Empty);
				if (text2.IndexOf("Scratch", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("GradeCard", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("CardBack", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("card_back", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Scratch", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("GradedCardTexture", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					val2.sprite = val;
					val2.overrideSprite = val;
					((Graphic)val2).material = null;
					((Graphic)val2).color = Color.clear;
					((Behaviour)val2).enabled = false;
					if ((Object)(object)((Component)val2).gameObject != (Object)null)
					{
						((Component)val2).gameObject.SetActive(false);
					}
				}
			}
			BlankCardBackScratchRenderersUnder(transform);
		}

		private static void EnsureGradeLabelTextsVisible(CardUI cardUi)
		{
			DisableGradeTmp(cardUi.m_GradeNumberText, null);
			DisableGradeTmp(cardUi.m_GradeDescriptionText, null);
			DisableGradeTmp(cardUi.m_GradeNameText, null);
			DisableGradeTmp(cardUi.m_GradeExpansionRarityText, null);
			DisableGradeTmp(cardUi.m_GradeSerialText, null);
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if ((Object)(object)val != (Object)null)
			{
				DisableGradeTmp(val.m_GradeNumberText, null);
				DisableGradeTmp(val.m_GradeDescriptionText, null);
				DisableGradeTmp(val.m_GradeNameText, null);
				DisableGradeTmp(val.m_GradeExpansionRarityText, null);
				DisableGradeTmp(val.m_GradeSerialText, null);
			}
			EnsureGradedCaseChrome(cardUi);
			ApplyDedicatedGradeHeaderLabels(cardUi);
		}

		private static void ApplyDedicatedGradeHeaderLabels(CardUI cardUi)
		{
			//IL_00b3: 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_00f0: 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_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_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_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null)
			{
				return;
			}
			CardData cardData = cardUi.GetCardData();
			if (cardData == null || cardData.cardGrade <= 0)
			{
				return;
			}
			Transform val = cardUi.m_GradedCardCaseGrp.transform.Find("GradedCaseHeaderBar0703");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if ((Object)(object)((Component)val).GetComponent<RectMask2D>() == (Object)null)
			{
				((Component)val).gameObject.AddComponent<RectMask2D>();
			}
			string text = ResolveGradedDisplayName(cardUi, cardData);
			string text2 = string.Empty;
			try
			{
				text2 = GameInstance.GetCardGradeString(cardData.cardGrade) ?? string.Empty;
			}
			catch
			{
			}
			string text3 = ((object)Unsafe.As<ECardExpansionType, ECardExpansionType>(ref cardData.expansionType)/*cast due to .constrained prefix*/).ToString();
			TMP_FontAsset font = ResolveGradeLabelFont(cardUi);
			ConfigureDedicatedGradeLabel(val, "GradeName0703", text, font, new Vector2(0.04f, 0.52f), new Vector2(0.6f, 0.92f), leftAligned: true, 20f, wordWrap: false);
			ConfigureDedicatedGradeLabel(val, "GradeNumber0703", cardData.cardGrade.ToString(), font, new Vector2(0.72f, 0.52f), new Vector2(0.96f, 0.92f), leftAligned: false, 24f, wordWrap: false);
			ConfigureDedicatedGradeLabel(val, "GradeDesc0703", text2, font, new Vector2(0.66f, 0.08f), new Vector2(0.96f, 0.48f), leftAligned: false, 13f, wordWrap: false);
			ConfigureDedicatedGradeLabel(val, "GradeExpansion0703", text3, font, new Vector2(0.04f, 0.08f), new Vector2(0.6f, 0.48f), leftAligned: true, 11f, wordWrap: true);
			if (!_loggedGradeTmpPaths)
			{
				_loggedGradeTmpPaths = true;
				Transform val2 = val.Find("GradeNumber0703");
				TextMeshProUGUI val3 = default(TextMeshProUGUI);
				if ((Object)(object)val2 != (Object)null && ((Component)val2).TryGetComponent<TextMeshProUGUI>(ref val3))
				{
					ManualLogSource log = Plugin.Log;
					DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(43, 4);
					defaultInterpolatedStringHandler.AppendLiteral("Grade TMP0703 text='");
					defaultInterpolatedStringHandler.AppendFormatted(((TMP_Text)val3).text);
					defaultInterpolatedStringHandler.AppendLiteral("' size=");
					Rect rect = ((TMP_Text)val3).rectTransform.rect;
					defaultInterpolatedStringHandler.AppendFormatted<Vector2>(((Rect)(ref rect)).size);
					defaultInterpolatedStringHandler.AppendLiteral(" ");
					defaultInterpolatedStringHandler.AppendLiteral("fontSize=");
					defaultInterpolatedStringHandler.AppendFormatted(((TMP_Text)val3).fontSize);
					defaultInterpolatedStringHandler.AppendLiteral(" path=");
					defaultInterpolatedStringHandler.AppendFormatted(GetTransformPath(((TMP_Text)val3).transform));
					log.LogWarning((object)defaultInterpolatedStringHandler.ToStringAndClear());
				}
			}
		}

		private static string ResolveGradedDisplayName(CardUI cardUi, CardData cardData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MonsterData monsterData = InventoryBase.GetMonsterData(cardData.monsterType);
				if (monsterData != null)
				{
					string text = monsterData.GetName() ?? string.Empty;
					if (!string.IsNullOrWhiteSpace(text))
					{
						return text;
					}
				}
			}
			catch
			{
			}
			TMP_Text monsterNameText = (TMP_Text)(object)cardUi.m_MonsterNameText;
			if (monsterNameText != null && !string.IsNullOrWhiteSpace(monsterNameText.text))
			{
				return monsterNameText.text;
			}
			return ((object)Unsafe.As<EMonsterType, EMonsterType>(ref cardData.monsterType)/*cast due to .constrained prefix*/).ToString();
		}

		private static TMP_FontAsset? ResolveGradeLabelFont(CardUI cardUi)
		{
			TextMeshProUGUI gradeNumberText = cardUi.m_GradeNumberText;
			if (gradeNumberText != null && (Object)(object)((TMP_Text)gradeNumberText).font != (Object)null)
			{
				return ((TMP_Text)gradeNumberText).font;
			}
			TextMeshProUGUI monsterNameText = cardUi.m_MonsterNameText;
			if (monsterNameText != null && (Object)(object)((TMP_Text)monsterNameText).font != (Object)null)
			{
				return ((TMP_Text)monsterNameText).font;
			}
			return null;
		}

		private static void ConfigureDedicatedGradeLabel(Transform headerRoot, string objectName, string text, TMP_FontAsset? font, Vector2 anchorMin, Vector2 anchorMax, bool leftAligned, float fontSize, bool wordWrap)
		{
			//IL_0018: 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_002e: 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_0048: 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_005e: 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_0074: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI orCreateDedicatedGradeLabel = GetOrCreateDedicatedGradeLabel(headerRoot, objectName, font);
			RectTransform rectTransform = ((TMP_Text)orCreateDedicatedGradeLabel).rectTransform;
			((Transform)rectTransform).SetParent(headerRoot, false);
			((Transform)rectTransform).localScale = Vector3.one;
			((Transform)rectTransform).localRotation = Quaternion.identity;
			rectTransform.anchorMin = anchorMin;
			rectTransform.anchorMax = anchorMax;
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			rectTransform.anchoredPosition = Vector2.zero;
			rectTransform.sizeDelta = Vector2.zero;
			((Transform)rectTransform).SetAsLastSibling();
			((TMP_Text)orCreateDedicatedGradeLabel).text = text ?? string.Empty;
			((TMP_Text)orCreateDedicatedGradeLabel).enableAutoSizing = false;
			((TMP_Text)orCreateDedicatedGradeLabel).fontSize = fontSize;
			((TMP_Text)orCreateDedicatedGradeLabel).enableWordWrapping = wordWrap;
			((TMP_Text)orCreateDedicatedGradeLabel).overflowMode = (TextOverflowModes)3;
			((TMP_Text)orCreateDedicatedGradeLabel).alignment = (TextAlignmentOptions)(leftAligned ? 4097 : 4100);
			((Graphic)orCreateDedicatedGradeLabel).color = Color.white;
			((TMP_Text)orCreateDedicatedGradeLabel).alpha = 1f;
			((TMP_Text)orCreateDedicatedGradeLabel).margin = new Vector4(4f, 2f, 4f, 2f);
			((MaskableGraphic)orCreateDedicatedGradeLabel).maskable = true;
			((Graphic)orCreateDedicatedGradeLabel).raycastTarget = false;
			((Behaviour)orCreateDedicatedGradeLabel).enabled = true;
			((Component)orCreateDedicatedGradeLabel).gameObject.SetActive(true);
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)orCreateDedicatedGradeLabel).font = font;
				PhoneFontMaterialSnapshot.CaptureIfNeeded();
				Material val = PhoneFontMaterialSnapshot.CreateHudLabelMaterial(font);
				val.renderQueue = 3100;
				((TMP_Text)orCreateDedicatedGradeLabel).fontMaterial = val;
			}
			try
			{
				((TMP_Text)orCreateDedicatedGradeLabel).ForceMeshUpdate(true, true);
			}
			catch
			{
			}
		}

		private static TextMeshProUGUI GetOrCreateDedicatedGradeLabel(Transform headerRoot, string objectName, TMP_FontAsset? font)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Transform val = headerRoot.Find(objectName);
			TextMeshProUGUI val2 = default(TextMeshProUGUI);
			if ((Object)(object)val != (Object)null && ((Component)val).TryGetComponent<TextMeshProUGUI>(ref val2))
			{
				if ((Object)(object)font != (Object)null && (Object)(object)((TMP_Text)val2).font == (Object)null)
				{
					((TMP_Text)val2).font = font;
				}
				return val2;
			}
			GameObject val3 = new GameObject(objectName);
			val3.transform.SetParent(headerRoot, false);
			TextMeshProUGUI val4 = val3.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)val4).font = font;
			}
			return val4;
		}

		private static void RefreshGradeLabelContent(CardUI cardUi)
		{
		}

		private static void SetTmpText(object? tmp, string text)
		{
			TMP_Text val = (TMP_Text)((tmp is TMP_Text) ? tmp : null);
			if (val != null)
			{
				val.text = text ?? string.Empty;
				val.ForceMeshUpdate(true, true);
			}
		}

		private static void LayoutGradeLabelsOnSlabHeader(CardUI cardUi)
		{
			ApplyDedicatedGradeHeaderLabels(cardUi);
		}

		private static void LayoutGradeTmpInCase(object? tmp, Transform caseRoot, Vector2 anchorMin, Vector2 anchorMax, bool leftAligned, float fontSizeMax, bool wordWrap)
		{
		}

		private static void DisableGradeTmp(object? candidate, object? keepIfSameAs)
		{
			Behaviour val = (Behaviour)((candidate is Behaviour) ? candidate : null);
			if (val == null)
			{
				return;
			}
			Behaviour val2 = (Behaviour)((keepIfSameAs is Behaviour) ? keepIfSameAs : null);
			if (val2 == null || val != val2)
			{
				val.enabled = false;
				if ((Object)(object)((Component)val).gameObject != (Object)null)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		private static void SetTmpEnabled(object? tmp, bool enabled)
		{
			Behaviour val = (Behaviour)((tmp is Behaviour) ? tmp : null);
			if (val != null)
			{
				val.enabled = enabled;
				if ((Object)(object)((Component)val).gameObject != (Object)null)
				{
					((Component)val).gameObject.SetActive(enabled);
				}
			}
		}

		private static void RepairGradedGradeTmp(object? tmp)
		{
		}

		public static void HideGradedCardBackFaces(CardUI cardUi)
		{
			SuppressFlatUiCardBack(cardUi);
			DisableGradedCaseBackAndBackBlocker(cardUi);
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if ((Object)(object)val?.m_CardBackMesh != (Object)null)
			{
				val.m_CardBackMesh.SetActive(false);
			}
			if ((Object)(object)cardUi.m_CardBackImage != (Object)null)
			{
				((Behaviour)cardUi.m_CardBackImage).enabled = false;
				if ((Object)(object)((Component)cardUi.m_CardBackImage).gameObject != (Object)null)
				{
					((Component)cardUi.m_CardBackImage).gameObject.SetActive(false);
				}
			}
			if ((Object)(object)cardUi.m_CardBack != (Object)null)
			{
				cardUi.m_CardBack.SetActive(false);
			}
			DisableCardBackSpritesUnderTransform(((Object)(object)cardUi.m_GradedCardCaseGrp != (Object)null) ? cardUi.m_GradedCardCaseGrp.transform : null);
			DisableCardBackSpritesUnderTransform(((Component)cardUi).transform);
		}

		private static void DisableCardBackSpritesUnderTransform(Transform? root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.sprite == (Object)null)
				{
					continue;
				}
				string text = ((Object)val.sprite).name ?? string.Empty;
				string text2 = (((Object)(object)((Component)val).gameObject != (Object)null) ? ((Object)((Component)val).gameObject).name : string.Empty);
				if (!(text2 == "GradedFace0703") && !(text2 == "TetramonOverlay0703") && (text.IndexOf("CardBack", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("card_back", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Card_Back", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("CardBack", StringComparison.OrdinalIgnoreCase) >= 0))
				{
					((Behaviour)val).enabled = false;
					if ((Object)(object)((Component)val).gameObject != (Object)null)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
		}

		private static void DisableGradedCaseBackAndBackBlocker(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_GradedCardCaseBackGrp != (Object)null)
			{
				cardUi.m_GradedCardCaseBackGrp.SetActive(false);
			}
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if ((Object)(object)val?.m_GradedCaseCullCardBackMeshBlocker != (Object)null)
			{
				val.m_GradedCaseCullCardBackMeshBlocker.SetActive(false);
			}
		}

		public static void AfterGradedCaseLayoutChanged(CardUI cardUi, bool albumSimplified = false)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			CardData val = ((cardUi != null) ? cardUi.GetCardData() : null);
			if (val != null && val.cardGrade > 0 && (int)val.expansionType != 0 && !((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null))
			{
				ApplyGradedNonTetramonFace(cardUi, val, albumSimplified);
			}
		}

		public static void AfterSimplifyCardDistanceCull(Card3dUIGroup card3d, bool isCull)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)card3d?.m_CardUI == (Object)null)
			{
				return;
			}
			CardData cardData = card3d.m_CardUI.GetCardData();
			if (cardData != null && cardData.cardGrade > 0 && (int)cardData.expansionType != 0)
			{
				RestoreGraded3dSlabFaceVisibility(card3d.m_CardUI);
				if (isCull)
				{
					AfterGradedCaseLayoutChanged(card3d.m_CardUI, albumSimplified: true);
				}
			}
		}

		public static void RepairGradedNonTetramonFace(CardUI cardUi, CardData cardData)
		{
			if ((Object)(object)cardUi == (Object)null || cardData == null || (Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null)
			{
				return;
			}
			HideDuplicateAlbumFoilHosts(cardUi);
			HideGradedCardBackFaces(cardUi);
			DisableGradedHeaderTextureSlot(cardUi);
			RestoreGraded3dSlabFaceVisibility(cardUi);
			HideOccludingGradedSlabMeshes(cardUi);
			BlankGraded3dSlabCardBackMaterials(cardUi);
			DisableOverlayImage(cardUi);
			EnsureGradedCaseFillsSlot(cardUi);
			EnsureGradeLabelTextsVisible(cardUi);
			bool fromBridge;
			Sprite val = ArtExpanderBridge.LoadCardArt(cardData) ?? ResolveCardArt(cardUi, cardData, out fromBridge);
			if ((Object)(object)val == (Object)null)
			{
				Transform val2 = cardUi.m_GradedCardCaseGrp.transform.Find("GradedFace0703");
				Image val3 = default(Image);
				if ((Object)(object)val2 != (Object)null && ((Component)val2).TryGetComponent<Image>(ref val3) && (Object)(object)val3.sprite != (Object)null)
				{
					val = val3.sprite;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				ApplyGradedCaseFaceArt(cardUi, val);
			}
			HideOversizedCardFrontBehindSlab(cardUi);
			HideOccludingGradedSlabMeshes(cardUi);
			HideGradedCardBackFaces(cardUi);
			DisableGradedHeaderTextureSlot(cardUi);
			EnsureGradeLabelTextsVisible(cardUi);
			cardUi.m_GradedCardCaseGrp.SetActive(true);
			cardUi.m_GradedCardCaseGrp.transform.SetAsLastSibling();
		}

		public static void ApplyGradedCardPresentationPublic(CardUI cardUi, CardData cardData)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (cardData != null && (int)cardData.expansionType != 0)
			{
				ApplyGradedNonTetramonFace(cardUi, cardData);
			}
			else
			{
				ApplyGradedCardPresentation(cardUi, cardData);
			}
		}

		private static void ApplyGradedCardPresentation(CardUI cardUi, CardData cardData)
		{
			DisableOverlayImage(cardUi);
			RestoreCenterFrameVisibility(cardUi);
			RestoreVanillaChromeVisibility(cardUi);
			RestoreDuplicateTextVisibility(cardUi);
			HideDuplicateAlbumFoilHosts(cardUi);
			StripAlbumHoFoilMaterials(cardUi);
			try
			{
				cardUi.m_Show2DGradedCase = true;
				cardUi.ShowGradedCardCase(true);
			}
			catch
			{
			}
			if ((Object)(object)cardUi.m_GradedCardCaseGrp != (Object)null)
			{
				cardUi.m_GradedCardCaseGrp.transform.SetAsLastSibling();
			}
			AlbumHoFoilRepairBehaviour.EnsureOn(cardUi);
		}

		public static void ApplyGradedHeldPresentation(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			CardData cardData = cardUi.GetCardData();
			if (cardData == null || cardData.cardGrade <= 0)
			{
				return;
			}
			bool flag = (int)cardData.expansionType > 0;
			if (flag)
			{
				ApplyGradedNonTetramonFace(cardUi, cardData);
			}
			else
			{
				ApplyGradedCardPresentation(cardUi, cardData);
			}
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			InteractableCard3d val = Card3dInteractableRegistry.FindForCardUi(cardUi);
			if ((Object)(object)val != (Object)null && val.IsDisplayedOnShelf())
			{
				if (flag)
				{
					ConfigureGradedNonTetramonShelfPresentation(cardUi, card3d);
				}
				else
				{
					ConfigureCard3dForFrontDisplay(cardUi);
				}
				return;
			}
			HideGradedCardBackFaces(cardUi);
			if (flag)
			{
				HideOversizedCardFrontBehindSlab(cardUi);
				RestoreGraded3dSlabFaceVisibility(cardUi);
				HideOccludingGradedSlabMeshes(cardUi);
				DisableGradedHeaderTextureSlot(cardUi);
			}
			else
			{
				SetCardFrontCanvasActive(cardUi, active: true);
			}
			if ((Object)(object)card3d?.m_CardBackMesh != (Object)null)
			{
				card3d.m_CardBackMesh.SetActive(false);
			}
		}

		private static void ConfigureGradedNonTetramonShelfPresentation(CardUI cardUi, Card3dUIGroup? card3d)
		{
			InteractableCard3d val = Card3dInteractableRegistry.FindForCardUi(cardUi);
			if ((Object)(object)val != (Object)null && val.IsDisplayedOnShelf())
			{
				InteractableCard3d0703Patches.AlignDisplayCardUiToSlot(val);
			}
			HideOversizedCardFrontBehindSlab(cardUi);
			PrepareShopDisplayCardBack(cardUi);
			if ((Object)(object)card3d != (Object)null)
			{
				ApplyShopDisplayBackMesh(cardUi, card3d, onDisplayShelf: true);
			}
			EnsureDisplayCardRenderPriority(cardUi);
			HideOversizedCardFrontBehindSlab(cardUi);
		}

		private static void ClearStaleOverlayChromeOnly(CardUI cardUi)
		{
			if (!((Object)(object)FindOverlayTransform(cardUi) == (Object)null))
			{
				DisableOverlayImage(cardUi);
				RestoreCenterFrameVisibility(cardUi);
				RestoreVanillaChromeVisibility(cardUi);
				RestoreDuplicateTextVisibility(cardUi);
			}
		}

		public static void EnsureAlbumArtAndFoilLayering(CardUI cardUi)
		{
			//IL_0024: 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)
			if ((Object)(object)cardUi == (Object)null)
			{
				return;
			}
			CardData cardData = cardUi.GetCardData();
			if (cardData != null && cardData.cardGrade > 0)
			{
				HideDuplicateAlbumFoilHosts(cardUi);
				if ((int)cardData.expansionType != 0)
				{
					RepairGradedNonTetramonFace(cardUi, cardData);
				}
				return;
			}
			Sprite val = null;
			Transform val2 = FindOverlayTransform(cardUi);
			Image val3 = default(Image);
			if (val2 != null && ((Component)val2).TryGetComponent<Image>(ref val3) && ((Behaviour)val3).enabled && (Object)(object)val3.sprite != (Object)null)
			{
				((Graphic)val3).material = null;
				((Graphic)val3).color = Color.white;
				val = val3.sprite;
			}
			if ((Object)(object)val == (Object)null)
			{
				HideDuplicateAlbumFoilHosts(cardUi);
				AlbumHoFoilRepairBehaviour.EnsureOn(cardUi);
				return;
			}
			ShowAlbumFoilHosts(cardUi);
			int num = BindAlbumFoilHostsToCardArt(cardUi, val);
			if (num <= 0)
			{
				HideDuplicateAlbumFoilHosts(cardUi);
			}
			else
			{
				BringFoilLayersAboveCardArt(cardUi);
				LogAlbumHoloBindOnce(cardUi, val, num);
			}
			AlbumHoFoilRepairBehaviour.EnsureOn(cardUi);
		}

		public static void ReassertWorldCardFoilPolicy(CardUI? cardUi)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cardUi == (Object)null)
			{
				return;
			}
			CardData cardData = cardUi.GetCardData();
			if (cardData != null && cardData.cardGrade > 0)
			{
				HideDuplicateAlbumFoilHosts(cardUi);
				if ((int)cardData.expansionType != 0)
				{
					RepairGradedNonTetramonFace(cardUi, cardData);
				}
				AlbumHoFoilRepairBehaviour.EnsureOn(cardUi);
			}
			else
			{
				Transform val = FindOverlayTransform(cardUi);
				Image val2 = default(Image);
				if (val != null && ((Component)val).TryGetComponent<Image>(ref val2) && ((Behaviour)val2).enabled && (Object)(object)val2.sprite != (Object)null)
				{
					EnsureAlbumArtAndFoilLayering(cardUi);
					return;
				}
				HideDuplicateAlbumFoilHosts(cardUi);
				AlbumHoFoilRepairBehaviour.EnsureOn(cardUi);
			}
		}

		private static void LogAlbumHoloBindOnce(CardUI cardUi, Sprite cardArt, int boundHosts)
		{
			//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_01e3: 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)
			if (_loggedAlbumHoloBind)
			{
				return;
			}
			_loggedAlbumHoloBind = true;
			string value = "(none)";
			string value2 = "(none)";
			if (cardUi.m_FoilShowList != null)
			{
				for (int i = 0; i < cardUi.m_FoilShowList.Count; i++)
				{
					Image val = cardUi.m_FoilShowList[i];
					if (!((Object)(object)val == (Object)null) && ((Behaviour)val).isActiveAndEnabled)
					{
						Material val2 = ((Graphic)val).materialForRendering ?? ((Graphic)val).material;
						if (IsHoFoilMaterial(val2))
						{
							value = (((Object)(object)val2.shader != (Object)null) ? ((Object)val2.shader).name : ((Object)val2).name);
							Texture val3 = (val2.HasProperty("_MainTex") ? val2.GetTexture("_MainTex") : val2.mainTexture);
							value2 = ((!((Object)(object)val3 != (Object)null)) ? "null" : (((object)val3 == Texture2D.whiteTexture || string.Equals(((Object)val3).name, "UnityWhite", StringComparison.OrdinalIgnoreCase)) ? (((Object)val3).name + " (WHITE — holo will not show art)") : $"{((Object)val3).name} ({val3.width}x{val3.height})"));
							break;
						}
					}
				}
			}
			ManualLogSource log = Plugin.Log;
			DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(62, 6);
			defaultInterpolatedStringHandler.AppendLiteral("Album HO bind: hosts=");
			defaultInterpolatedStringHandler.AppendFormatted(boundHosts);
			defaultInterpolatedStringHandler.AppendLiteral(", art=");
			defaultInterpolatedStringHandler.AppendFormatted(((Object)cardArt).name);
			defaultInterpolatedStringHandler.AppendLiteral(" (");
			Rect rect = cardArt.rect;
			defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).width);
			defaultInterpolatedStringHandler.AppendLiteral("x");
			rect = cardArt.rect;
			defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).height);
			defaultInterpolatedStringHandler.AppendLiteral("), ");
			defaultInterpolatedStringHandler.AppendLiteral("sampleShader=");
			defaultInterpolatedStringHandler.AppendFormatted(value);
			defaultInterpolatedStringHandler.AppendLiteral(", sampleMainTex=");
			defaultInterpolatedStringHandler.AppendFormatted(value2);
			log.LogInfo((object)defaultInterpolatedStringHandler.ToStringAndClear());
		}

		private static void ReapplyGradedCaseLayout(CardUI cardUi)
		{
			CardData cardData = cardUi.GetCardData();
			if (cardData != null && cardData.cardGrade > 0 && !((Object)(object)cardUi.m_GradedCardCaseGrp == (Object)null))
			{
				try
				{
					cardUi.m_Show2DGradedCase = true;
					cardUi.ShowGradedCardCase(true);
				}
				catch
				{
				}
				cardUi.m_GradedCardCaseGrp.transform.SetAsLastSibling();
			}
		}

		public static void EnsureAlbumReadableWithoutTetramonOverlay(CardUI cardUi)
		{
			EnsureReadableWithoutFullCardOverlay(cardUi);
		}

		public static void EnsureReadableWithoutFullCardOverlay(CardUI cardUi)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)cardUi == (Object)null))
			{
				HideDuplicateAlbumFoilHosts(cardUi);
				StripAlbumHoFoilMaterials(cardUi);
				RestoreCenterFrameVisibility(cardUi);
				if ((Object)(object)cardUi.m_CenterFrameImage != (Object)null)
				{
					((Graphic)cardUi.m_CenterFrameImage).material = null;
					((Behaviour)cardUi.m_CenterFrameImage).enabled = true;
					((Graphic)cardUi.m_CenterFrameImage).color = Color.white;
				}
				ResetImageToDefaultUiMaterial(cardUi.m_CardFrontImage);
				ResetImageToDefaultUiMaterial(cardUi.m_CardFrontImageTopLayer);
				ResetImageToDefaultUiMaterial(cardUi.m_CardBGImage);
				ResetImageToDefaultUiMaterial(cardUi.m_CardFullBGImage);
				ResetImageToDefaultUiMaterial(cardUi.m_CardBorderImage);
				ResetImageToDefaultUiMaterial(cardUi.m_CardFullTransparentLayerBGImage);
				AlbumHoFoilRepairBehaviour.EnsureOn(cardUi);
			}
		}

		private static void ShowAlbumFoilHosts(CardUI cardUi)
		{
			int num = EnableOnlyHoFoilImages(cardUi.m_FoilShowList) + EnableOnlyHoFoilImages(cardUi.m_FoilBlendedShowList);
			if ((Object)(object)cardUi.m_FoilGrp != (Object)null)
			{
				bool flag = false;
				Image[] componentsInChildren = cardUi.m_FoilGrp.GetComponentsInChildren<Image>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Image obj = componentsInChildren[i];
					if (!IsHoFoilMaterial((obj != null) ? ((Graphic)obj).material : null))
					{
						Image obj2 = componentsInChildren[i];
						if (!IsHoFoilMaterial((obj2 != null) ? ((Graphic)obj2).materialForRendering : null))
						{
							continue;
						}
					}
					flag = true;
					((Behaviour)componentsInChildren[i]).enabled = true;
					((Component)componentsInChildren[i]).gameObject.SetActive(true);
				}
				cardUi.m_FoilGrp.SetActive(flag || num > 0);
			}
			if (num > 0 || ((Object)(object)cardUi.m_FoilGrp != (Object)null && cardUi.m_FoilGrp.activeSelf))
			{
				try
				{
					cardUi.SetFoilCullListVisibility(true);
				}
				catch
				{
				}
			}
		}

		private static int EnableOnlyHoFoilImages(List<Image>? list)
		{
			if (list == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				Image val = list[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (!IsHoFoilMaterial(((Graphic)val).material) && !IsHoFoilMaterial(((Graphic)val).materialForRendering))
				{
					((Behaviour)val).enabled = false;
					continue;
				}
				((Behaviour)val).enabled = true;
				if ((Object)(object)((Component)val).gameObject != (Object)null)
				{
					((Component)val).gameObject.SetActive(true);
				}
				num++;
			}
			return num;
		}

		private static int BindAlbumFoilHostsToCardArt(CardUI cardUi, Sprite cardArt)
		{
			CardData cardData = cardUi.GetCardData();
			bool flag = cardData != null && cardData.cardGrade > 0 && CardUiDisplayContext.IsBinderAlbumCard(cardUi);
			Transform val = (((Object)(object)cardUi.m_CardFront != (Object)null) ? cardUi.m_CardFront.transform : null);
			int num = 0;
			num += BindFoilImageListToCardArt(cardUi.m_FoilShowList, cardArt, val, flag);
			num += BindFoilImageListToCardArt(cardUi.m_FoilBlendedShowList, cardArt, val, flag);
			if ((Object)(object)cardUi.m_FoilGrp == (Object)null)
			{
				return num;
			}
			if (flag && (Object)(object)val != (Object)null && !cardUi.m_FoilGrp.transform.IsChildOf(val))
			{
				return num;
			}
			Image[] componentsInChildren = cardUi.m_FoilGrp.GetComponentsInChildren<Image>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (BindFoilImageToCardArt(componentsInChildren[i], cardArt))
				{
					num++;
				}
			}
			return num;
		}

		private static int BindFoilImageListToCardArt(List<Image>? list, Sprite cardArt, Transform? cardFront = null, bool gradedAlbum = false)
		{
			if (list == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				Image val = list[i];
				if ((!gradedAlbum || !((Object)(object)cardFront != (Object)null) || !((Object)(object)val != (Object)null) || ((Component)val).transform.IsChildOf(cardFront)) && BindFoilImageToCardArt(val, cardArt))
				{
					num++;
				}
			}
			return num;
		}

		private static bool BindFoilImageToCardArt(Image? foilImage, Sprite cardArt)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)foilImage == (Object)null || (Object)(object)cardArt == (Object)null || (Object)(object)cardArt.texture == (Object)null)
			{
				return false;
			}
			Material mat = ((Graphic)foilImage).material;
			if (!IsHoFoilMaterial(mat))
			{
				mat = ((Graphic)foilImage).materialForRendering;
			}
			if (!IsHoFoilMaterial(mat))
			{
				return false;
			}
			foilImage.sprite = cardArt;
			foilImage.type = (Type)0;
			foilImage.preserveAspect = true;
			((Graphic)foilImage).color = Color.white;
			((Behaviour)foilImage).enabled = true;
			if ((Object)(object)((Component)foilImage).gameObject != (Object)null)
			{
				((Component)foilImage).gameObject.SetActive(true);
			}
			BindArtTextureToHoMaterial(mat, cardArt);
			((Graphic)foilImage).SetMaterialDirty();
			((Graphic)foilImage).SetVerticesDirty();
			return true;
		}

		private static void BindArtTextureToHoMaterial(Material mat, Sprite artSprite)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_00b6: 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)
			Texture texture = (Texture)(object)artSprite.texture;
			GetSpriteUv(artSprite, out var scale, out var offset);
			mat.mainTexture = texture;
			if (mat.HasProperty("_MainTex"))
			{
				mat.SetTexture("_MainTex", texture);
				mat.SetTextureScale("_MainTex", scale);
				mat.SetTextureOffset("_MainTex", offset);
			}
			if (mat.HasProperty("_BaseMap"))
			{
				mat.SetTexture("_BaseMap", texture);
				mat.SetTextureScale("_BaseMap", scale);
				mat.SetTextureOffset("_BaseMap", offset);
			}
			if (mat.HasProperty("_FoilTex"))
			{
				Texture texture2 = mat.GetTexture("_FoilTex");
				if ((Object)(object)texture2 == (Object)null || (object)texture2 == Texture2D.whiteTexture)
				{
					mat.SetTexture("_FoilTex", texture);
					mat.SetTextureScale("_FoilTex", scale);
					mat.SetTextureOffset("_FoilTex", offset);
				}
			}
		}

		private static void GetSpriteUv(Sprite sprite, out Vector2 scale, out Vector2 offset)
		{
			//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_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_0035: 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_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_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)
			Texture texture = (Texture)(object)sprite.texture;
			Rect textureRect = sprite.textureRect;
			if ((Object)(object)texture == (Object)null || texture.width <= 0 || texture.height <= 0)
			{
				scale = Vector2.one;
				offset = Vector2.zero;
			}
			else
			{
				scale = new Vector2(((Rect)(ref textureRect)).width / (float)texture.width, ((Rect)(ref textureRect)).height / (float)texture.height);
				offset = new Vector2(((Rect)(ref textureRect)).x / (float)texture.width, ((Rect)(ref textureRect)).y / (float)texture.height);
			}
		}

		private static void StripAlbumHoFoilMaterials(CardUI cardUi)
		{
			Image[] componentsInChildren = ((Component)cardUi).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || ((Object)(object)((Component)val).gameObject != (Object)null && string.Equals(((Object)((Component)val).gameObject).name, "TetramonOverlay0703", StringComparison.Ordinal)) || (!IsHoFoilMaterial(((Graphic)val).material) && !IsHoFoilMaterial(((Graphic)val).materialForRendering)))
				{
					continue;
				}
				((Graphic)val).material = null;
				string text = (((Object)(object)((Component)val).gameObject != (Object)null) ? ((Object)((Component)val).gameObject).name : string.Empty);
				if (text.IndexOf("Foil", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Mask_Blended", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Mask_Plain", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Glitter", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					((Behaviour)val).enabled = false;
					if ((Object)(object)((Component)val).gameObject != (Object)null)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
		}

		private static void ResetImageToDefaultUiMaterial(Image? image)
		{
			if (!((Object)(object)image == (Object)null))
			{
				((Graphic)image).material = null;
			}
		}

		private static bool IsHoFoilMaterial(Material? mat)
		{
			if ((Object)(object)((mat != null) ? mat.shader : null) == (Object)null)
			{
				return false;
			}
			string text = ((Object)mat.shader).name ?? string.Empty;
			string text2 = ((Object)mat).name ?? string.Empty;
			if (text.IndexOf("CardFoil", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("Holo", StringComparison.OrdinalIgnoreCase) < 0 && text2.IndexOf("CardFoil", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text2.IndexOf("Holo", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static void HideDuplicateAlbumFoilHosts(CardUI cardUi)
		{
			try
			{
				cardUi.SetFoilCullListVisibility(false);
			}
			catch
			{
			}
			SetFoilImageListActive(cardUi.m_FoilShowList, active: false);
			SetFoilImageListActive(cardUi.m_FoilBlendedShowList, active: false);
			if ((Object)(object)cardUi.m_FoilGrp != (Object)null)
			{
				cardUi.m_FoilGrp.SetActive(false);
			}
		}

		private static void SetFoilImageListActive(List<Image>? list, bool active)
		{
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				Image val = list[i];
				if (!((Object)(object)val == (Object)null))
				{
					((Behaviour)val).enabled = active;
					if ((Object)(object)((Component)val).gameObject != (Object)null)
					{
						((Component)val).gameObject.SetActive(active);
					}
				}
			}
		}

		public static void RepairAlbumHoFoilMainTex(CardUI cardUi)
		{
			//IL_0025: 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)
			if ((Object)(object)cardUi == (Object)null)
			{
				return;
			}
			CardData cardData = cardUi.GetCardData();
			if (cardData == null)
			{
				return;
			}
			if (cardData.cardGrade > 0)
			{
				HideDuplicateAlbumFoilHosts(cardUi);
				if ((int)cardData.expansionType != 0)
				{
					RepairGradedNonTetramonFace(cardUi, cardData);
				}
				return;
			}
			Transform val = FindOverlayTransform(cardUi);
			Image val2 = default(Image);
			if (val != null && ((Component)val).TryGetComponent<Image>(ref val2) && ((Behaviour)val2).enabled && (Object)(object)val2.sprite != (Object)null)
			{
				EnsureAlbumArtAndFoilLayering(cardUi);
				return;
			}
			if ((int)cardData.expansionType != 0)
			{
				Sprite val3 = ArtExpanderBridge.LoadCardArt(cardData);
				if ((Object)(object)val3 != (Object)null)
				{
					ApplyFullCardOverlay(cardUi, val3);
					EnsureAlbumArtAndFoilLayering(cardUi);
					return;
				}
			}
			EnsureReadableWithoutFullCardOverlay(cardUi);
		}

		private static void BringFoilLayersAboveCardArt(CardUI cardUi)
		{
			CardData cardData = cardUi.GetCardData();
			if (cardData != null && cardData.cardGrade > 0 && CardUiDisplayContext.IsBinderAlbumCard(cardUi) && (Object)(object)cardUi.m_CardFront != (Object)null)
			{
				BringFoilLayersAboveCardArtUnderParent(cardUi, cardUi.m_CardFront.transform);
				return;
			}
			if ((Object)(object)cardUi.m_FoilGrp != (Object)null)
			{
				cardUi.m_FoilGrp.transform.SetAsLastSibling();
			}
			BringFoilImageListToLastSibling(cardUi.m_FoilShowList);
			BringFoilImageListToLastSibling(cardUi.m_FoilBlendedShowList);
		}

		private static void BringFoilLayersAboveCardArtUnderParent(CardUI cardUi, Transform cardFront)
		{
			if ((Object)(object)cardUi.m_FoilGrp != (Object)null && cardUi.m_FoilGrp.transform.IsChildOf(cardFront))
			{
				cardUi.m_FoilGrp.transform.SetAsLastSibling();
			}
			BringFoilImageListToLastSiblingUnderParent(cardUi.m_FoilShowList, cardFront);
			BringFoilImageListToLastSiblingUnderParent(cardUi.m_FoilBlendedShowList, cardFront);
			Transform val = FindOverlayTransform(cardUi);
			if (val != null && val.IsChildOf(cardFront))
			{
				val.SetAsFirstSibling();
			}
		}

		private static void BringFoilImageListToLastSibling(List<Image>? list)
		{
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				Image val = list[i];
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.SetAsLastSibling();
				}
			}
		}

		private static void BringFoilImageListToLastSiblingUnderParent(List<Image>? list, Transform parent)
		{
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				Image val = list[i];
				if ((Object)(object)val != (Object)null && ((Component)val).transform.IsChildOf(parent))
				{
					((Component)val).transform.SetAsLastSibling();
				}
			}
		}

		public static void SetCardUI_ApplyTetramonOverlay(CardUI __instance, CardData cardData, bool forceFrontOverlay = false)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || cardData == null)
			{
				return;
			}
			if ((int)cardData.expansionType != 0)
			{
				ClearStaleOverlayAfterExpansionSwitch(__instance);
				return;
			}
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(__instance);
			if (!forceFrontOverlay && PackOpeningState.IsPackOpeningInProgress())
			{
				if ((Object)(object)val != (Object)null && PackOpeningState.ShouldShowFrontDuringPackFlip(val))
				{
					ApplyTetramonFrontOverlay(__instance, cardData);
				}
				else
				{
					ConfigurePackOpeningCardPresentation(__instance, val);
				}
			}
			else
			{
				ApplyTetramonCardBackFromCache(__instance);
				ApplyTetramonFrontOverlay(__instance, cardData);
			}
		}

		public static void ConfigurePackOpeningCardPresentation(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			if ((Object)(object)card3d != (Object)null && !PackOpeningState.IsCardFrontTowardCamera(card3d))
			{
				ApplyPackOpeningStackTopBack(cardUi, card3d);
			}
			else
			{
				ApplyPackOpeningFlipFrontPresentation(cardUi, card3d);
			}
		}

		private static void HidePackOpeningFrontFace(CardUI cardUi)
		{
			DisableOverlayImage(cardUi);
			HideCenterFrameArt(cardUi);
			HideVanillaChromeWhenOverlayShown(cardUi);
			HideDuplicateTextWhenOverlayShown(cardUi);
			SuppressFrontOverlayDuringPackBack(cardUi);
			SuppressPackOpeningFoilMask(cardUi);
		}

		private static void ApplyPackOpeningStackTopBack(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			HidePackOpeningFrontFace(cardUi);
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			SetPackCardUiAnimGroupVisible(card3d, visible: true);
			SetCardFrontCanvasActive(cardUi, active: false);
			PreparePackSingleCardBackImage(cardUi, faceCamera: true);
			HidePackOpeningBackMesh(card3d);
		}

		public static void ResetBackMeshDiagnostics()
		{
			_loggedBackMeshShow = false;
		}

		private static void ShowPackOpeningBackMesh(Card3dUIGroup? card3d)
		{
			//IL_002c: 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_01c8: 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)
			if ((Object)(object)card3d?.m_CardBackMesh == (Object)null)
			{
				return;
			}
			card3d.m_CardBackMesh.SetActive(true);
			card3d.m_CardBackMesh.transform.localScale = Vector3.one;
			SetCard3dBackMeshVisible(card3d, visible: true);
			if (!_loggedBackMeshShow)
			{
				_loggedBackMeshShow = true;
				Renderer component = card3d.m_CardBackMesh.GetComponent<Renderer>();
				string value = LayerMask.LayerToName(card3d.m_CardBackMesh.layer);
				string value2 = (((Object)(object)((component != null) ? component.material : null) != (Object)null) ? ((Object)component.material).name : "null");
				float value3 = (((Object)(object)((component != null) ? component.material : null) != (Object)null && component.material.HasProperty("_Color")) ? component.material.color.a : (-1f));
				Plugin.Log.LogWarning((object)$"BackMesh show: active={card3d.m_CardBackMesh.activeInHierarchy} rendererEnabled={((component != null) ? new bool?(component.enabled) : ((bool?)null))} isVisible={((component != null) ? new bool?(component.isVisible) : ((bool?)null))} layer={value} mat={value2} alpha={value3:F2} scale={card3d.m_CardBackMesh.transform.lossyScale}");
				Transform parent = card3d.m_CardBackMesh.transform.parent;
				int num = 0;
				while ((Object)(object)parent != (Object)null && num < 8)
				{
					Plugin.Log.LogWarning((object)$"BackMesh ancestor[{num}] name={((Object)parent).name} activeSelf={((Component)parent).gameObject.activeSelf} localScale={parent.localScale} localPos={parent.localPosition}");
					parent = parent.parent;
					num++;
				}
			}
		}

		private static void ApplyPackOpeningActiveFlipBack(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			ApplyPokemonBackFaceUi(cardUi, card3d);
		}

		private static void ApplyPokemonBackFaceUi(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			HidePackOpeningFrontFace(cardUi);
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			SetPackCardUiAnimGroupVisible(card3d, visible: true);
			SetCardFrontCanvasActive(cardUi, active: false);
			PreparePackSingleCardBackImage(cardUi);
			HidePackOpeningBackMesh(card3d);
		}

		public static void ApplyPackOpeningFlipFrontPresentation(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			SetPackCardUiAnimGroupVisible(card3d, visible: true);
			SetCardFrontCanvasActive(cardUi, active: true);
			SetCardFrontMirrored(cardUi, mirrored: false);
			DisableUiCardBackCover(cardUi);
			SetCardBackCanvasActive(cardUi, active: false);
			SetCardBackFlipped(cardUi, flipped: false);
			SuppressPackOpeningFoilMask(cardUi);
			HidePackOpeningBackMesh(card3d);
		}

		private static void ApplyPackOpeningHiddenInStack(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			DisableOverlayImage(cardUi);
			HideCenterFrameArt(cardUi);
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			SetPackCardUiAnimGroupVisible(card3d, visible: true);
			SetCardFrontCanvasActive(cardUi, active: false);
			DisableUiCardBackCover(cardUi);
			SetCardBackCanvasActive(cardUi, active: false);
			SuppressFrontOverlayDuringPackBack(cardUi);
			SuppressPackOpeningFoilMask(cardUi);
			HidePackOpeningBackMesh(card3d);
		}

		public static void ApplyPackOpeningFanRowPresentation(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			if ((Object)(object)card3d != (Object)null)
			{
				card3d.m_IgnoreCulling = true;
			}
			SetPackCardUiAnimGroupVisible(card3d, visible: true);
			SetCardFrontCanvasActive(cardUi, active: true);
			SetCardBackCanvasActive(cardUi, active: false);
			DisableUiCardBackCover(cardUi);
			HidePackOpeningBackMesh(card3d);
			ApplyFlatScreenCardPresentation(cardUi, card3d);
		}

		private static void PreparePackSingleCardBackImage(CardUI cardUi, bool faceCamera = false)
		{
			//IL_00ab: 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)
			if ((Object)(object)cardUi.m_CardBackImage == (Object)null)
			{
				return;
			}
			Sprite val = CardExtrasCacheAccess.TryGetPokemonUiBackSprite() ?? CardExtrasCacheAccess.TryGetUiCardBackSprite() ?? cardUi.m_CardBackImage.sprite;
			if ((Object)(object)val == (Object)null)
			{
				CardData cardData = cardUi.GetCardData();
				if (cardData != null)
				{
					val = CSingleton<InventoryBase>.Instance.m_MonsterData_SO.GetCardBackSprite(cardData.expansionType);
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				SetCardBackCanvasActive(cardUi, active: true);
				SetCardBackMirrored(cardUi, mirrored: false);
				SetCardBackFlipped(cardUi, faceCamera);
				((Behaviour)cardUi.m_CardBackImage).enabled = true;
				cardUi.m_CardBackImage.sprite = val;
				cardUi.m_CardBackImage.type = (Type)0;
				cardUi.m_CardBackImage.preserveAspect = true;
				((Graphic)cardUi.m_CardBackImage).color = Color.white;
				StretchImageToFill(((Graphic)cardUi.m_CardBackImage).rectTransform);
			}
		}

		private static void SetCardBackCanvasActive(CardUI cardUi, bool active)
		{
			if ((Object)(object)cardUi.m_CardBack != (Object)null)
			{
				cardUi.m_CardBack.SetActive(active);
			}
		}

		private static void SetPackCardUiAnimGroupVisible(Card3dUIGroup? card3d, bool visible)
		{
			if ((Object)(object)card3d?.m_CardUIAnimGrp != (Object)null)
			{
				((Component)card3d.m_CardUIAnimGrp).gameObject.SetActive(visible);
			}
		}

		public static void ForceDisableAllPackOpeningBackUi(CardOpeningSequence sequence)
		{
			if (sequence.m_Card3dUIList == null)
			{
				return;
			}
			for (int i = 0; i < sequence.m_Card3dUIList.Count; i++)
			{
				CardUI val = sequence.m_Card3dUIList[i]?.m_CardUI;
				if (!((Object)(object)val == (Object)null))
				{
					DisableUiCardBackCover(val);
					SetCardBackCanvasActive(val, active: false);
				}
			}
		}

		public static void ForceHideAllPackOpeningBackMeshes(CardOpeningSequence sequence)
		{
			if (sequence.m_Card3dUIList == null)
			{
				return;
			}
			for (int i = 0; i < sequence.m_Card3dUIList.Count; i++)
			{
				Card3dUIGroup val = sequence.m_Card3dUIList[i];
				if (!((Object)(object)val == (Object)null))
				{
					HidePackOpeningBackMesh(val);
				}
			}
		}

		private static void HidePackOpeningBackMesh(Card3dUIGroup? card3d)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)card3d?.m_CardBackMesh == (Object)null))
			{
				SetCard3dBackMeshVisible(card3d, visible: false);
				card3d.m_CardBackMesh.SetActive(false);
				card3d.m_CardBackMesh.transform.localScale = Vector3.zero;
			}
		}

		public static void ApplyPackOpeningBackOnly(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			ConfigurePackOpeningCardPresentation(cardUi, card3d);
		}

		public static void ConfigureCard3dBackPresentation(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			ApplyPackStackBackMeshSync(cardUi, card3d);
		}

		private static void ApplyPackStackBackMeshSync(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (card3d == null)
			{
				object? value = CardUiFieldAccess.GetValue(cardUi, "m_Card3dUIGroup");
				card3d = (Card3dUIGroup?)((value is Card3dUIGroup) ? value : null);
			}
			if (!((Object)(object)card3d?.m_CardBackMesh == (Object)null))
			{
				card3d.m_CardBackMesh.SetActive(true);
				SetCard3dBackMeshVisible(card3d, visible: true);
				card3d.m_CardBackMesh.transform.localScale = Vector3.one;
				SyncCard3dBackMeshFromUiBack(cardUi, card3d);
			}
		}

		private static void ApplyPackSingleCardBackMeshSync(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			if (!((Object)(object)card3d?.m_CardBackMesh == (Object)null))
			{
				card3d.m_CardBackMesh.SetActive(true);
				SetCard3dBackMeshVisible(card3d, visible: true);
				card3d.m_CardBackMesh.transform.localScale = Vector3.one;
				SyncCard3dBackMeshFromUiBack(cardUi, card3d, 1f, usePackStackBack: false);
			}
		}

		private static void ApplyTetramonFrontOverlay(CardUI __instance, CardData cardData)
		{
			SetCardFrontCanvasActive(__instance, active: true);
			Card3dUIGroup card3d = CardUiDisplayContext.ResolveCard3dGroup(__instance);
			bool flag = CardUiDisplayContext.IsBinderAlbumCard(__instance);
			if (flag)
			{
				ApplyFlatScreenCardPresentation(__instance, card3d);
			}
			else if (CardUiDisplayContext.ShouldUseRotatableWorldCardBack(__instance))
			{
				PrepareShopDisplayCardBack(__instance);
			}
			else
			{
				ApplyFlatScreenCardPresentation(__instance, card3d);
			}
			if (cardData.cardGrade > 0)
			{
				ApplyGradedCardPresentation(__instance, cardData);
				FinalizeCard3dPresentation(__instance);
				return;
			}
			bool fromBridge;
			Sprite val = ResolveCardArt(__instance, cardData, out fromBridge);
			object cardConfig = NewSwappingHandler.TryGetCardFromCache(cardData, false);
			if ((Object)(object)val != (Object)null && (fromBridge || LooksLikeFullCard(val)))
			{
				ApplyFullCardOverlay(__instance, val);
				if (flag)
				{
					EnsureAlbumArtAndFoilLayering(__instance);
				}
				FinalizeCard3dPresentation(__instance);
				return;
			}
			DisableOverlayImage(__instance);
			if ((Object)(object)val != (Object)null)
			{
				ApplyCenterArtLayout(__instance, val, cardConfig);
				if (flag)
				{
					EnsureAlbumArtAndFoilLayering(__instance);
				}
				FinalizeCard3dPresentation(__instance);
				return;
			}
			RestoreCenterFrameIcon(__instance, cardData);
			ApplyNoArtFallback(__instance, cardConfig, cardData);
			if (flag)
			{
				EnsureAlbumArtAndFoilLayering(__instance);
			}
			FinalizeCard3dPresentation(__instance);
		}

		public static void SyncPackOpeningBackMesh(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			if (card3d == null)
			{
				object? value = CardUiFieldAccess.GetValue(cardUi, "m_Card3dUIGroup");
				card3d = (Card3dUIGroup?)((value is Card3dUIGroup) ? value : null);
			}
			if (!((Object)(object)card3d == (Object)null) && cardUi.IsCard3dUIGroupSet())
			{
				ConfigurePackOpeningCardPresentation(cardUi, card3d);
			}
		}

		private static void FinalizeCard3dPresentation(CardUI cardUi)
		{
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if (CardUiDisplayContext.IsBinderAlbumCard(cardUi))
			{
				ApplyFlatScreenCardPresentation(cardUi, val);
			}
			else
			{
				if ((Object)(object)val == (Object)null && !cardUi.IsCard3dUIGroupSet())
				{
					return;
				}
				if (val == null)
				{
					object? value = CardUiFieldAccess.GetValue(cardUi, "m_Card3dUIGroup");
					val = (Card3dUIGroup)((value is Card3dUIGroup) ? value : null);
				}
				if (!CardUiDisplayContext.ShouldUseRotatableWorldCardBack(cardUi) && !PackOpeningState.IsPackOpeningInProgress() && !PackOpeningState.IsFanRowVisible())
				{
					ApplyFlatScreenCardPresentation(cardUi, val);
				}
				else if (PackOpeningState.IsPackOpeningInProgress())
				{
					if ((Object)(object)val != (Object)null && PackOpeningState.ShouldShowFrontDuringPackFlip(val))
					{
						ApplyPackOpeningFlipFrontPresentation(cardUi, val);
					}
					else if ((Object)(object)val != (Object)null && PackOpeningState.ShouldShowActiveCardFlipBack(val))
					{
						ApplyPackOpeningActiveFlipBack(cardUi, val);
					}
					else
					{
						ConfigurePackOpeningCardPresentation(cardUi, val);
					}
				}
				else if (PackOpeningState.IsFanRowVisible() && (Object)(object)val?.m_CardBackMesh != (Object)null)
				{
					ApplyPackOpeningFanRowPresentation(cardUi, val);
				}
				else
				{
					ConfigureCard3dForFrontDisplay(cardUi);
				}
			}
		}

		public static void ConfigureCard3dForFrontDisplay(CardUI cardUi)
		{
			Card3dUIGroup val = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			if (!((Object)(object)val == (Object)null))
			{
				InteractableCard3d val2 = Card3dInteractableRegistry.FindForCardUi(cardUi);
				bool flag = (Object)(object)val2 != (Object)null && val2.IsDisplayedOnShelf();
				if (flag)
				{
					InteractableCard3d0703Patches.AlignDisplayCardUiToSlot(val2);
				}
				SetCardFrontCanvasActive(cardUi, active: true);
				SetCardFrontMirrored(cardUi, mirrored: false);
				PrepareShopDisplayCardBack(cardUi);
				ApplyShopDisplayBackMesh(cardUi, val, flag);
				if (flag)
				{
					EnsureDisplayCardRenderPriority(cardUi);
				}
			}
		}

		private static void ApplyShopDisplayBackMesh(CardUI cardUi, Card3dUIGroup card3d, bool onDisplayShelf = false)
		{
			if (!((Object)(object)card3d.m_CardBackMesh == (Object)null))
			{
				if (onDisplayShelf)
				{
					SetCard3dBackMeshVisible(card3d, visible: false);
					card3d.m_CardBackMesh.SetActive(false);
				}
				else
				{
					SyncCard3dBackMeshFromUiBack(cardUi, card3d, 1f, usePackStackBack: false);
					card3d.m_CardBackMesh.SetActive(true);
					SetCard3dBackMeshVisible(card3d, visible: true);
				}
			}
		}

		private static void PrepareShopDisplayCardBack(CardUI cardUi)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cardUi.m_CardBackImage == (Object)null)
			{
				return;
			}
			Sprite val = ResolveShopDisplayBackSprite(cardUi);
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)cardUi.m_CardBack != (Object)null)
				{
					cardUi.m_CardBack.SetActive(true);
				}
				SetCardBackMirrored(cardUi, mirrored: false);
				SetCardBackFlipped(cardUi, flipped: false);
				((Behaviour)cardUi.m_CardBackImage).enabled = true;
				cardUi.m_CardBackImage.sprite = val;
				cardUi.m_CardBackImage.type = (Type)0;
				cardUi.m_CardBackImage.preserveAspect = false;
				((Graphic)cardUi.m_CardBackImage).color = Color.white;
				StretchShopDisplayBackImage(cardUi, ((Graphic)cardUi.m_CardBackImage).rectTransform);
			}
		}

		private static Sprite? ResolveShopDisplayBackSprite(CardUI cardUi)
		{
			//IL_000b: 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_0032: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//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_00e6: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			CardData cardData = cardUi.GetCardData();
			Rect rect;
			if (cardData != null && (int)cardData.expansionType != 0)
			{
				try
				{
					Sprite cardBackSprite = CSingleton<InventoryBase>.Instance.m_MonsterData_SO.GetCardBackSprite(cardData.expansionType);
					if ((Object)(object)cardBackSprite != (Object)null)
					{
						rect = cardBackSprite.rect;
						if (((Rect)(ref rect)).width > 1f)
						{
							rect = cardBackSprite.rect;
							if (((Rect)(ref rect)).height > 1f)
							{
								return cardBackSprite;
							}
						}
					}
				}
				catch
				{
				}
			}
			Sprite val = CardExtrasCacheAccess.TryGetPokemonUiBackSprite() ?? CardExtrasCacheAccess.TryGetUiCardBackSprite();
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Sprite val2 = (((Object)(object)cardUi.m_CardBackImage != (Object)null) ? cardUi.m_CardBackImage.sprite : null);
			if ((Object)(object)val2 != (Object)null)
			{
				rect = val2.rect;
				if (((Rect)(ref rect)).width > 1f)
				{
					rect = val2.rect;
					if (((Rect)(ref rect)).height > 1f)
					{
						return val2;
					}
				}
			}
			if (cardData != null)
			{
				return CSingleton<InventoryBase>.Instance.m_MonsterData_SO.GetCardBackSprite(cardData.expansionType);
			}
			return null;
		}

		public static void SyncShopBackMeshUvOnly(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			if (card3d == null)
			{
				object? value = CardUiFieldAccess.GetValue(cardUi, "m_Card3dUIGroup");
				card3d = (Card3dUIGroup?)((value is Card3dUIGroup) ? value : null);
			}
			if (!((Object)(object)card3d?.m_CardBackMesh == (Object)null))
			{
				SyncCard3dBackMeshFromUiBack(cardUi, card3d, 1f, usePackStackBack: false);
			}
		}

		public static void SyncTetramonCardBackAfterExpansionMod(CardUI cardUi, Card3dUIGroup card3d)
		{
			ConfigureCard3dForFrontDisplay(cardUi);
		}

		public static void SuppressTetramonHoverChromeBleed(CardUI cardUi)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			if (!((Object)(object)cardUi == (Object)null))
			{
				CardData cardData = cardUi.GetCardData();
				if (cardData != null && (int)cardData.expansionType <= 0 && CardUiDisplayContext.IsFlatAlbumOrBinderCard(cardUi) && HasActiveTetramonOverlay(cardUi))
				{
					SetImageEnabled(cardUi.m_CardBGImage, enabled: false);
					SetImageEnabled(cardUi.m_CardFrontImage, enabled: false);
					SetImageEnabled(cardUi.m_CardFrontImageTopLayer, enabled: false);
					SetImageEnabled(cardUi.m_CardBorderImage, enabled: false);
					SetImageEnabled(cardUi.m_CardFullBGImage, enabled: false);
					SetImageEnabled(cardUi.m_CardFullTransparentLayerBGImage, enabled: false);
					SetImageEnabled(cardUi.m_PlayEffectBGImage, enabled: false);
					SetImageEnabled(cardUi.m_BrightnessControl, enabled: true);
				}
			}
		}

		private static void EnsureDisplayCardRenderPriority(CardUI cardUi)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			Canvas componentInParent = ((Component)cardUi).GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode == 2)
			{
				componentInParent.overrideSorting = true;
				if (componentInParent.sortingOrder < 10)
				{
					componentInParent.sortingOrder = 10;
				}
			}
			BoostImageRenderQueue(cardUi.m_CardFrontImage);
			BoostImageRenderQueue(cardUi.m_BrightnessControl);
			BoostImageRenderQueue(cardUi.m_CardBackImage);
			Transform val = FindOverlayTransform(cardUi);
			Image image = default(Image);
			if (val != null && ((Component)val).TryGetComponent<Image>(ref image))
			{
				BoostImageRenderQueue(image);
			}
		}

		private static void BoostImageRenderQueue(Image? image)
		{
			if (!((Object)(object)image == (Object)null))
			{
				Material materialForRendering = ((Graphic)image).materialForRendering;
				if ((Object)(object)materialForRendering != (Object)null && materialForRendering.renderQueue < 3005)
				{
					materialForRendering.renderQueue = 3005;
				}
			}
		}

		private static bool HasActiveTetramonOverlay(CardUI cardUi)
		{
			Transform val = FindOverlayTransform(cardUi);
			Image val2 = default(Image);
			if (val != null && ((Component)val).TryGetComponent<Image>(ref val2))
			{
				return ((Behaviour)val2).enabled;
			}
			return false;
		}

		private static void SuppressFlatUiCardBack(CardUI cardUi)
		{
			DisableUiCardBackCover(cardUi);
			if ((Object)(object)cardUi.m_CardBack != (Object)null)
			{
				cardUi.m_CardBack.SetActive(false);
			}
		}

		public static void ApplyFlatScreenCardPresentation(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			SuppressFlatUiCardBack(cardUi);
			SetCardFrontCanvasActive(cardUi, active: true);
			SetCardFrontMirrored(cardUi, mirrored: false);
			if (card3d == null)
			{
				card3d = CardUiDisplayContext.ResolveCard3dGroup(cardUi);
			}
			if ((Object)(object)card3d?.m_CardBackMesh != (Object)null)
			{
				card3d.m_CardBackMesh.SetActive(false);
			}
		}

		private static void SetCardFrontCanvasActive(CardUI cardUi, bool active)
		{
			if ((Object)(object)cardUi.m_CardFront != (Object)null)
			{
				cardUi.m_CardFront.SetActive(active);
			}
		}

		private static void SetCardFrontMirrored(CardUI cardUi, bool mirrored)
		{
			SetTransformMirrored(((Object)(object)cardUi.m_CardFront != (Object)null) ? cardUi.m_CardFront.transform : null, mirrored);
		}

		private static void SetCardBackMirrored(CardUI cardUi, bool mirrored)
		{
			SetTransformMirrored(((Object)(object)cardUi.m_CardBack != (Object)null) ? cardUi.m_CardBack.transform : null, mirrored);
		}

		private static void SetCardBackFlipped(CardUI cardUi, bool flipped)
		{
			//IL_0034: 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_0039: 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_0040: 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)
			if (!((Object)(object)cardUi.m_CardBack == (Object)null))
			{
				Transform transform = cardUi.m_CardBack.transform;
				Quaternion val = (flipped ? Quaternion.Euler(0f, 180f, 0f) : Quaternion.identity);
				if (Quaternion.Angle(transform.localRotation, val) > 0.1f)
				{
					transform.localRotation = val;
				}
			}
		}

		private static void SetTransformMirrored(Transform? target, bool mirrored)
		{
			//IL_000b: 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_0011: 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_0036: 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)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				Vector3 localScale = target.localScale;
				float num = Mathf.Abs(localScale.x);
				float num2 = (mirrored ? (0f - num) : num);
				if (!Mathf.Approximately(localScale.x, num2))
				{
					target.localScale = new Vector3(num2, localScale.y, localScale.z);
				}
			}
		}

		public static void ApplyPackFlipBackMeshSync(CardUI cardUi, Card3dUIGroup? card3d = null)
		{
			ApplyPackStackBackMeshSync(cardUi, card3d);
		}

		public static void SyncTetramonPackBackAfterExpansionMod(CardUI cardUi, Card3dUIGroup card3d)
		{
			ConfigurePackOpeningCardPresentation(cardUi, card3d);
		}

		private static void EnsurePackUiCardBackCover(CardUI cardUi)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			object obj = CardExtrasCacheAccess.TryGetUiCardBackSprite();
			if (obj == null)
			{
				Image cardBackImage = cardUi.m_CardBackImage;
				obj = ((cardBackImage != null) ? cardBackImage.sprite : null);
			}
			Sprite val = (Sprite)obj;
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)cardUi.m_CardBack != (Object)null)
				{
					cardUi.m_CardBack.SetActive(true);
				}
				if (!((Object)(object)cardUi.m_CardBackImage == (Object)null))
				{
					((Behaviour)cardUi.m_CardBackImage).enabled = true;
					cardUi.m_CardBackImage.sprite = val;
					cardUi.m_CardBackImage.type = (Type)0;
					cardUi.m_CardBackImage.preserveAspect = false;
					((Graphic)cardUi.m_CardBackImage).color = Color.white;
					StretchImageToFill(((Graphic)cardUi.m_CardBackImage).rectTransform);
				}
			}
		}

		private static void SuppressPackOpeningFoilMask(CardUI cardUi)
		{
			object? value = CardUiFieldAccess.GetValue(cardUi, "m_CardFoilMaskImage");
			Image val = (Image)((value is Image) ? value : null);
			if (val != null)
			{
				((Behaviour)val).enabled = false;
			}
		}

		private static void SuppressFrontOverlayDuringPackBack(CardUI cardUi)
		{
			Transform val = FindOverlayTransform(cardUi);
			Image val2 = default(Image);
			if (val != null && ((Component)val).TryGetComponent<Image>(ref val2))
			{
				((Behaviour)val2).enabled = false;
			}
		}

		private static void DisableUiCardBackCover(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_CardBackImage != (Object)null)
			{
				((Behaviour)cardUi.m_CardBackImage).enabled = false;
			}
		}

		private static void SetCard3dBackMeshVisible(Card3dUIGroup card3d, bool visible)
		{
			if (!((Object)(object)card3d.m_CardBackMesh == (Object)null))
			{
				Renderer component = card3d.m_CardBackMesh.GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null)
				{
					component.enabled = visible;
				}
			}
		}

		private static void SyncCard3dBackMeshFromUiBack(CardUI cardUi, Card3dUIGroup card3d, float overscan = 1f, bool usePackStackBack = true)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			Sprite val;
			if (usePackStackBack)
			{
				object obj = CardExtrasCacheAccess.TryGetStackBackMeshSprite();
				if (obj == null)
				{
					Image cardBackImage = cardUi.m_CardBackImage;
					obj = ((cardBackImage != null) ? cardBackImage.sprite : null);
				}
				val = (Sprite)obj;
			}
			else
			{
				object obj2 = ResolveShopDisplayBackSprite(cardUi);
				if (obj2 == null)
				{
					Image cardBackImage2 = cardUi.m_CardBackImage;
					obj2 = ((cardBackImage2 != null) ? cardBackImage2.sprite : null);
				}
				val = (Sprite)obj2;
			}
			if (!((Object)(object)val == (Object)null) && !((Object)(object)card3d.m_CardBackMesh == (Object)null))
			{
				Renderer component = card3d.m_CardBackMesh.GetComponent<Renderer>();
				Material val2 = (((Object)(object)component != (Object)null) ? component.material : null);
				if (!((Object)(object)val2 == (Object)null))
				{
					ApplySpriteToMaterial(val2, val, overscan);
					card3d.m_CardBackMesh.transform.localScale = ((overscan > 1f) ? (Vector3.one * overscan) : Vector3.one);
				}
			}
		}

		private static void StretchImageToFill(RectTransform rect)
		{
			//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_0021: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
			((Transform)rect).localScale = Vector3.one;
		}

		private static void StretchShopDisplayBackImage(CardUI cardUi, RectTransform rect)
		{
			//IL_0031: 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_0051: 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)
			if ((Object)(object)cardUi.m_CardBack != (Object)null)
			{
				((Transform)rect).SetParent(cardUi.m_CardBack.transform, false);
			}
			StretchImageToFill(rect);
			rect.offsetMin = new Vector2(-14f, -14f);
			rect.offsetMax = new Vector2(14f, 14f);
			((Transform)rect).localRotation = Quaternion.identity;
			((Transform)rect).localScale = Vector3.one * 1.14f;
		}

		private static void ApplySpriteToMaterial(Material material, Sprite sprite, float overscan = 1f)
		{
			//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_0052: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			Texture texture = (Texture)(object)sprite.texture;
			Rect rect = sprite.rect;
			float num = 1f / (float)texture.width;
			float num2 = 1f / (float)texture.height;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(((Rect)(ref rect)).width * num / overscan, ((Rect)(ref rect)).height * num2 / overscan);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(((Rect)(ref rect)).x * num + val.x * (overscan - 1f) * 0.5f, ((Rect)(ref rect)).y * num2 + val.y * (overscan - 1f) * 0.5f);
			material.mainTexture = texture;
			material.mainTextureScale = val;
			material.mainTextureOffset = val2;
			if (material.HasProperty("_BaseMap"))
			{
				material.SetTexture("_BaseMap", texture);
				material.SetTextureScale("_BaseMap", val);
				material.SetTextureOffset("_BaseMap", val2);
			}
			if (material.HasProperty("_EmissionMap"))
			{
				material.SetTexture("_EmissionMap", texture);
				material.SetTextureScale("_EmissionMap", val);
				material.SetTextureOffset("_EmissionMap", val2);
			}
		}

		private static Sprite? ResolveCardArt(CardUI cardUi, CardData cardData, out bool fromBridge)
		{
			fromBridge = false;
			Sprite val = ArtExpanderBridge.LoadCardArt(cardData);
			if ((Object)(object)val != (Object)null)
			{
				fromBridge = true;
				return val;
			}
			if ((Object)(object)cardUi.m_CenterFrameImage == (Object)null || !((Behaviour)cardUi.m_CenterFrameImage).enabled)
			{
				return null;
			}
			Sprite sprite = cardUi.m_CenterFrameImage.sprite;
			if ((Object)(object)sprite != (Object)null && !IsVanillaIcon(sprite, cardData))
			{
				return sprite;
			}
			return null;
		}

		private static bool IsVanillaIcon(Sprite sprite, CardData cardData)
		{
			//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)
			Sprite icon = InventoryBase.GetMonsterData(cardData.monsterType).GetIcon(cardData.expansionType);
			if ((Object)(object)icon != (Object)null)
			{
				return sprite == icon;
			}
			return false;
		}

		private static bool LooksLikeFullCard(Sprite sprite)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Rect rect = sprite.rect;
			float width = ((Rect)(ref rect)).width;
			rect = sprite.rect;
			float height = ((Rect)(ref rect)).height;
			if (width <= 1f || height <= 1f)
			{
				return false;
			}
			if (height >= 420f && width >= 280f)
			{
				return true;
			}
			if (height > width * 1.1f && height >= 350f)
			{
				return true;
			}
			if (height >= 300f)
			{
				return height >= width * 0.85f;
			}
			return false;
		}

		private static void ApplyFullCardOverlay(CardUI cardUi, Sprite cardArt)
		{
			//IL_0030: 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_00f2: 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)
			EnsureCardShellVisible(cardUi);
			CleanupLegacyPackArtifacts(cardUi);
			Image orCreateOverlayImage = GetOrCreateOverlayImage(cardUi);
			orCreateOverlayImage.sprite = cardArt;
			orCreateOverlayImage.type = (Type)0;
			((Behaviour)orCreateOverlayImage).enabled = true;
			orCreateOverlayImage.preserveAspect = true;
			((Graphic)orCreateOverlayImage).color = Color.white;
			((Graphic)orCreateOverlayImage).raycastTarget = false;
			((MaskableGraphic)orCreateOverlayImage).maskable = true;
			StretchOverlayToCardFront(cardUi, ((Graphic)orCreateOverlayImage).rectTransform);
			RemoveFrontBlocker(cardUi);
			((Transform)((Graphic)orCreateOverlayImage).rectTransform).SetAsLastSibling();
			HideCenterFrameArt(cardUi);
			HideVanillaChromeWhenOverlayShown(cardUi);
			HideDuplicateTextWhenOverlayShown(cardUi);
			SetImageEnabled(cardUi.m_BrightnessControl, enabled: false);
			if (CardUiDisplayContext.IsBinderAlbumCard(cardUi))
			{
				EnsureAlbumArtAndFoilLayering(cardUi);
			}
			else
			{
				((Graphic)orCreateOverlayImage).material = null;
				EnsureAlbumArtAndFoilLayering(cardUi);
				ReapplyGradedCaseLayout(cardUi);
			}
			if (!LoggedFirstFullCard)
			{
				LoggedFirstFullCard = true;
				ManualLogSource log = Plugin.Log;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(48, 3);
				defaultInterpolatedStringHandler.AppendLiteral("Pokemon full-card art from cardart.assets (");
				defaultInterpolatedStringHandler.AppendFormatted(((Object)cardArt).name);
				defaultInterpolatedStringHandler.AppendLiteral(", ");
				Rect rect = cardArt.rect;
				defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).width);
				defaultInterpolatedStringHandler.AppendLiteral("x");
				rect = cardArt.rect;
				defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).height);
				defaultInterpolatedStringHandler.AppendLiteral(").");
				log.LogInfo((object)defaultInterpolatedStringHandler.ToStringAndClear());
			}
		}

		private static void ApplyCenterArtLayout(CardUI cardUi, Sprite centerArt, object? cardConfig)
		{
			//IL_0072: 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_00d7: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			DisableOverlayImage(cardUi);
			if ((Object)(object)cardUi.m_CenterFrameImageGrp != (Object)null)
			{
				cardUi.m_CenterFrameImageGrp.SetActive(true);
			}
			if ((Object)(object)cardUi.m_CenterFrameMaskGrp != (Object)null)
			{
				cardUi.m_CenterFrameMaskGrp.SetActive(true);
			}
			if ((Object)(object)cardUi.m_CenterFrameImage != (Object)null)
			{
				((Behaviour)cardUi.m_CenterFrameImage).enabled = true;
				cardUi.m_CenterFrameImage.sprite = centerArt;
				cardUi.m_CenterFrameImage.preserveAspect = true;
				((Graphic)cardUi.m_CenterFrameImage).color = Color.white;
			}
			ApplyCenterFrameTransform(cardUi, cardConfig);
			ApplyTextFromConfig(cardUi, cardConfig, forceReadableFallback: true);
			if (!LoggedFirstCenterArt)
			{
				LoggedFirstCenterArt = true;
				ManualLogSource log = Plugin.Log;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(45, 3);
				defaultInterpolatedStringHandler.AppendLiteral("Pokemon center art from cardart.assets (");
				defaultInterpolatedStringHandler.AppendFormatted(((Object)centerArt).name);
				defaultInterpolatedStringHandler.AppendLiteral(", ");
				Rect rect = centerArt.rect;
				defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).width);
				defaultInterpolatedStringHandler.AppendLiteral("x");
				rect = centerArt.rect;
				defaultInterpolatedStringHandler.AppendFormatted(((Rect)(ref rect)).height);
				defaultInterpolatedStringHandler.AppendLiteral(").");
				log.LogInfo((object)defaultInterpolatedStringHandler.ToStringAndClear());
			}
		}

		private static void ApplyCenterFrameTransform(CardUI cardUi, object? cardConfig)
		{
			//IL_0013: 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_005c: 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_006a: 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_0098: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetMonsterImageLayout(cardConfig, out var size, out var position))
			{
				ResetCenterFrameTransform(cardUi);
				return;
			}
			if (size.x <= 1f || size.y <= 1f)
			{
				ResetCenterFrameTransform(cardUi);
				return;
			}
			RectTransform val = (((Object)(object)cardUi.m_CenterFrameImage != (Object)null) ? ((Graphic)cardUi.m_CenterFrameImage).rectTransform : null);
			if (!((Object)(object)val == (Object)null))
			{
				val.sizeDelta = size;
				val.anchoredPosition = position;
				((Transform)val).localScale = Vector3.one;
				if ((Object)(object)cardUi.m_CenterFrameImageGrp != (Object)null)
				{
					Transform transform = cardUi.m_CenterFrameImageGrp.transform;
					transform.localScale = Vector3.one;
					transform.localPosition = Vector3.zero;
				}
				if ((Object)(object)cardUi.m_CenterFrameMaskGrp != (Object)null)
				{
					Transform transform2 = cardUi.m_CenterFrameMaskGrp.transform;
					transform2.localScale = Vector3.one;
					transform2.localPosition = Vector3.zero;
				}
			}
		}

		private static void ResetCenterFrameTransform(CardUI cardUi)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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)
			if ((Object)(object)cardUi.m_CenterFrameImage != (Object)null)
			{
				RectTransform rectTransform = ((Graphic)cardUi.m_CenterFrameImage).rectTransform;
				((Transform)rectTransform).localScale = Vector3.one;
				rectTransform.anchoredPosition = Vector2.zero;
			}
			if ((Object)(object)cardUi.m_CenterFrameImageGrp != (Object)null)
			{
				Transform transform = cardUi.m_CenterFrameImageGrp.transform;
				transform.localScale = Vector3.one;
				transform.localPosition = Vector3.zero;
			}
			if ((Object)(object)cardUi.m_CenterFrameMaskGrp != (Object)null)
			{
				Transform transform2 = cardUi.m_CenterFrameMaskGrp.transform;
				transform2.localScale = Vector3.one;
				transform2.localPosition = Vector3.zero;
			}
		}

		private static void StretchOverlayToCardFront(CardUI cardUi, RectTransform overlayRect)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			RectTransform cardFrontRect = GetCardFrontRect(cardUi);
			if (!((Object)(object)cardFrontRect == (Object)null))
			{
				Image cardBorderImage = cardUi.m_CardBorderImage;
				object obj = ((cardBorderImage != null) ? ((Graphic)cardBorderImage).rectTransform : null);
				if (obj == null)
				{
					Image cardFrontImage = cardUi.m_CardFrontImage;
					obj = ((cardFrontImage != null) ? ((Graphic)cardFrontImage).rectTransform : null);
				}
				RectTransform val = (RectTransform)obj;
				((Transform)overlayRect).SetParent((Transform)(object)cardFrontRect, false);
				((Transform)overlayRect).localRotation = Quaternion.identity;
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)cardFrontRect)
				{
					CopyRectTransformLayout(val, overlayRect);
				}
				else
				{
					StretchImageToFill(overlayRect);
				}
			}
		}

		private static void CopyRectTransformLayout(RectTransform source, RectTransform target)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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: 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)
			target.anchorMin = source.anchorMin;
			target.anchorMax = source.anchorMax;
			target.pivot = source.pivot;
			target.anchoredPosition = source.anchoredPosition;
			target.sizeDelta = source.sizeDelta;
			((Transform)target).localScale = Vector3.one;
		}

		private static RectTransform? GetCardFrontRect(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_CardFront != (Object)null)
			{
				Transform transform = cardUi.m_CardFront.transform;
				return (RectTransform?)(object)((transform is RectTransform) ? transform : null);
			}
			Transform transform2 = ((Component)cardUi).transform;
			return (RectTransform?)(object)((transform2 is RectTransform) ? transform2 : null);
		}

		private static void RemoveFrontBlocker(CardUI cardUi)
		{
			Transform val = GetCardFrontTransform(cardUi).Find("TetramonFrontBlocker0703");
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
		}

		private static Transform GetCardFrontTransform(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_CardFront != (Object)null)
			{
				return cardUi.m_CardFront.transform;
			}
			return ((Component)cardUi).transform;
		}

		private static void EnsureCardShellVisible(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_CardFront != (Object)null)
			{
				cardUi.m_CardFront.SetActive(true);
			}
			if (CardUiDisplayContext.ShouldUseRotatableWorldCardBack(cardUi) && (Object)(object)cardUi.m_CardBack != (Object)null)
			{
				cardUi.m_CardBack.SetActive(true);
			}
		}

		private static void CleanupLegacyPackArtifacts(CardUI cardUi)
		{
			Transform val = ((Component)cardUi).transform.Find("TetramonPackBackCover0703");
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		private static Transform? FindOverlayTransform(CardUI cardUi)
		{
			Transform val = GetCardFrontTransform(cardUi).Find("TetramonOverlay0703");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return ((Component)cardUi).transform.Find("TetramonOverlay0703");
		}

		private static Image GetOrCreateOverlayImage(CardUI cardUi)
		{
			//IL_001b: 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)
			Transform val = FindOverlayTransform(cardUi);
			Image result = default(Image);
			if (val != null && ((Component)val).TryGetComponent<Image>(ref result))
			{
				return result;
			}
			GameObject val2 = new GameObject("TetramonOverlay0703");
			RectTransform cardFrontRect = GetCardFrontRect(cardUi);
			val2.transform.SetParent((Transform)(((Object)(object)cardFrontRect != (Object)null) ? ((object)cardFrontRect) : ((object)((Component)cardUi).transform)), false);
			Image obj = val2.AddComponent<Image>();
			((MaskableGraphic)obj).maskable = true;
			StretchImageToFill(((Graphic)obj).rectTransform);
			return obj;
		}

		private static void DisableOverlayImage(CardUI cardUi)
		{
			Transform val = FindOverlayTransform(cardUi);
			Image val2 = default(Image);
			if (val != null && ((Component)val).TryGetComponent<Image>(ref val2))
			{
				((Behaviour)val2).enabled = false;
			}
			RemoveFrontBlocker(cardUi);
		}

		private static void RestoreCenterFrameVisibility(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_CenterFrameImageGrp != (Object)null)
			{
				cardUi.m_CenterFrameImageGrp.SetActive(true);
			}
			if ((Object)(object)cardUi.m_CenterFrameMaskGrp != (Object)null)
			{
				cardUi.m_CenterFrameMaskGrp.SetActive(true);
			}
			if ((Object)(object)cardUi.m_CenterFrameImage != (Object)null)
			{
				((Behaviour)cardUi.m_CenterFrameImage).enabled = true;
			}
		}

		private static void RestoreVanillaChromeVisibility(CardUI cardUi)
		{
			SetImageEnabled(cardUi.m_CardFrontImage, enabled: true);
			SetImageEnabled(cardUi.m_CardFrontImageTopLayer, enabled: true);
			SetImageEnabled(cardUi.m_CardBGImage, enabled: true);
			SetImageEnabled(cardUi.m_CardBorderImage, enabled: true);
			SetImageEnabled(cardUi.m_CardFullBGImage, enabled: true);
			Image cardBGImage = cardUi.m_CardBGImage;
			SetGameObjectActive((cardBGImage != null) ? ((Component)cardBGImage).gameObject : null, active: true);
			Image cardFullBGImage = cardUi.m_CardFullBGImage;
			SetGameObjectActive((cardFullBGImage != null) ? ((Component)cardFullBGImage).gameObject : null, active: true);
			SetImageEnabled(cardUi.m_CardFullTransparentLayerBGImage, enabled: true);
			SetImageEnabled(cardUi.m_RarityImage, enabled: true);
			SetImageEnabled(cardUi.m_FadeBarTopImage, enabled: true);
			SetImageEnabled(cardUi.m_FadeBarBtmImage, enabled: true);
			SetImageEnabled(cardUi.m_StatImage, enabled: true);
			SetImageEnabled(cardUi.m_EvoBGImage, enabled: true);
			SetImageEnabled(cardUi.m_DescriptionBGImage, enabled: true);
			SetImageEnabled(cardUi.m_PlayEffectBGImage, enabled: true);
			SetImageEnabled(cardUi.m_BrightnessControl, enabled: true);
			Image fadeBarTopImage = cardUi.m_FadeBarTopImage;
			SetGameObjectActive((fadeBarTopImage != null) ? ((Component)fadeBarTopImage).gameObject : null, active: true);
			Image fadeBarBtmImage = cardUi.m_FadeBarBtmImage;
			SetGameObjectActive((fadeBarBtmImage != null) ? ((Component)fadeBarBtmImage).gameObject : null, active: true);
			Image descriptionBGImage = cardUi.m_DescriptionBGImage;
			SetGameObjectActive((descriptionBGImage != null) ? ((Component)descriptionBGImage).gameObject : null, active: true);
			Image statImage = cardUi.m_StatImage;
			SetGameObjectActive((statImage != null) ? ((Component)statImage).gameObject : null, active: true);
			Image playEffectBGImage = cardUi.m_PlayEffectBGImage;
			SetGameObjectActive((playEffectBGImage != null) ? ((Component)playEffectBGImage).gameObject : null, active: true);
			Image evoBGImage = cardUi.m_EvoBGImage;
			SetGameObjectActive((evoBGImage != null) ? ((Component)evoBGImage).gameObject : null, active: true);
			object? value = CardUiFieldAccess.GetValue(cardUi, "m_StatGrp");
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if (val != null)
			{
				val.SetActive(true);
			}
			object? value2 = CardUiFieldAccess.GetValue(cardUi, "m_DescriptionGrp");
			GameObject val2 = (GameObject)((value2 is GameObject) ? value2 : null);
			if (val2 != null)
			{
				val2.SetActive(true);
			}
			object? value3 = CardUiFieldAccess.GetValue(cardUi, "m_EvoGrp");
			GameObject val3 = (GameObject)((value3 is GameObject) ? value3 : null);
			if (val3 != null)
			{
				val3.SetActive(true);
			}
			object? value4 = CardUiFieldAccess.GetValue(cardUi, "m_EvoBasicGrp");
			GameObject val4 = (GameObject)((value4 is GameObject) ? value4 : null);
			if (val4 != null)
			{
				val4.SetActive(true);
			}
			if ((Object)(object)cardUi.m_CardBorderMask != (Object)null)
			{
				((Behaviour)cardUi.m_CardBorderMask).enabled = true;
			}
			object? value5 = CardUiFieldAccess.GetValue(cardUi, "m_EvoAndArtistNameGrp");
			GameObject val5 = (GameObject)((value5 is GameObject) ? value5 : null);
			if (val5 != null)
			{
				val5.SetActive(true);
			}
		}

		private static void RestoreDuplicateTextVisibility(CardUI cardUi)
		{
			string[] cardTextFieldNames = CardTextFieldNames;
			foreach (string fieldName in cardTextFieldNames)
			{
				SetBehaviourEnabled(GetCardUiFieldValue(cardUi, fieldName), enabled: true);
			}
		}

		private static void HideCenterFrameArt(CardUI cardUi)
		{
			if ((Object)(object)cardUi.m_CenterFrameImage != (Object)null)
			{
				((Behaviour)cardUi.m_CenterFrameImage).enabled = false;
			}
			if ((Object)(object)cardUi.m_CenterFrameImageGrp != (Object)null)
			{
				cardUi.m_CenterFrameImageGrp.SetActive(false);
			}
			if ((Object)(object)cardUi.m_CenterFrameMaskGrp != (Object)null)
			{
				cardUi.m_CenterFrameMaskGrp.SetActive(false);
			}
		}

		private static void RestoreCenterFrameIcon(CardUI cardUi, CardData cardData)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			DisableOverlayImage(cardUi);
			if ((Object)(object)cardUi.m_CenterFrameImageGrp != (Object)null)
			{
				cardUi.m_CenterFrameImageGrp.SetActive(true);
			}
			if ((Object)(object)cardUi.m_CenterFrameMaskGrp != (Object)null)
			{
				cardUi.m_CenterFrameMaskGrp.SetActive(true);
			}
			if (!((Object)(object)cardUi.m_CenterFrameImage == (Object)null))
			{
				((Behaviour)cardUi.m_CenterFrameImage).enabled = true;
				Sprite icon = InventoryBase.GetMonsterData(cardData.monsterType).GetIcon(cardData.expansionType);
				if ((Object)(object)icon != (Object)null)
				{
					cardUi.m_CenterFrameImage.sprite = icon;
					cardUi.m_CenterFrameImage.preserveAspect = true;
				}
				ResetCenterFrameTransform(cardUi);
			}
		}

		private static void ApplyNoArtFallback(CardUI cardUi, object? cardConfig, CardData cardData)
		{
			//IL_003f: 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)
			ApplyTextFromConfig(cardUi, cardConfig, forceReadableFallback: true);
			SetImageEnabled(cardUi.m_StatImage, enabled: false);
			if (!LoggedMissingArt)
			{
				LoggedMissingArt = true;
				Plugin.Log.LogWarning((object)($"No cardart.assets entry for '{cardData.monsterType}' border '{cardData.borderType}'. " + "Showing icon + config text."));
			}
		}

		private static void ApplyTextFromConfig(CardUI cardUi, object? cardConfig, bool forceReadableFallback)
		{
			if (cardConfig == null)
			{
				SetBehaviourEnabled(GetCardUiFieldValue(cardUi, "m_MonsterNameText"), enabled: true);
				SetBehaviourEnabled(GetCardUiFieldValue(cardUi, "m_DescriptionText"), enabled: true);
				return;
			}
			Type type = cardConfig.GetType();
			(string, string, string, bool)[] configTextBindings = ConfigTextBindings;
			bool flag = default(bool);
			for (int i = 0; i < configTextBindings.Length; i++)
			{
				(string, string, string, bool) tuple = configTextBindings[i];
				string item = tuple.Item1;
				string item2 = tuple.Item2;
				string item3 = tuple.Item3;
				bool item4 = tuple.Item4;
				object cardUiFieldValue = GetCardUiFieldValue(cardUi, item3);
				PropertyInfo property = type.GetProperty(item);
				PropertyInfo? property2 = type.GetProperty(item2);
				if (property != null && cardUiFieldValue != null)
				{
					SetComponentText(cardUiFieldValue, property.GetValue(cardConfig)?.ToString());
				}
				object obj = property2?.GetValue(cardConfig);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				bool enabled = (byte)((uint)num & (flag ? 1u : 0u)) != 0;
				if (forceReadableFallback && item4)
				{
					enabled = true;
				}
				SetBehaviourEnabled(cardUiFieldValue, enabled);
			}
		}

		private static void SetComponentText(object component, string? value)
		{
			if (component != null && !string.IsNullOrEmpty(value))
			{
				component.GetType().GetProperty("text")?.SetValue(component, value);
			}
		}

		private static void HideVanillaChromeWhenOverlayShown(CardUI cardUi)
		{
			SetImageEnabled(cardUi.m_CardFrontImage, enabled: false);
			SetImageEnabled(cardUi.m_CardFrontImageTopLayer, enabled: false);
			SetImageEnabled(cardUi.m_CardBGImage, enabled: false);
			SetImageEnabled(cardUi.m_CardBorderImage, enabled: false);
			SetImageEnabled(cardUi.m_CardFullBGImage, enabled: false);
			Image cardBGImage = cardUi.m_CardBGImage;
			SetGameObjectActive((cardBGImage != null) ? ((Component)cardBGImage).gameObject : null, active: false);
			Image cardFullBGImage = cardUi.m_CardFullBGImage;
			SetGameObjectActive((cardFullBGImage != null) ? ((Component)cardFullBGImage).gameObject : null, active: false);
			SetImageEnabled(cardUi.m_CardFullTransparentLayerBGImage, enabled: false);
			SetImageEnabled(cardUi.m_RarityImage, enabled: false);
			SetImageEnabled(cardUi.m_FadeBarTopImage, enabled: false);
			SetImageEnabled(cardUi.m_FadeBarBtmImage, enabled: false);
			SetImageEnabled(cardUi.m_StatImage, enabled: false);
			SetImageEnabled(cardUi.m_EvoBGImage, enabled: false);
			SetImageEnabled(cardUi.m_DescriptionBGImage, enabled: false);
			SetImageEnabled(cardUi.m_PlayEffectBGImage, enabled: false);
			SetImageEnabled(cardUi.m_BrightnessControl, enabled: false);
			Image fadeBarTopImage = cardUi.m_FadeBarTopImage;
			SetGameObjectActive((fadeBarTopImage != null) ? ((Component)fadeBarTopImage).gameObject : null, active: false);
			Image fadeBarBtmImage = cardUi.m_FadeBarBtmImage;
			SetGameObjectActive((fadeBarBtmImage != null) ? ((Component)fadeBarBtmImage).gameObject : null, active: false);
			Image descriptionBGImage = cardUi.m_DescriptionBGImage;
			SetGameObjectActive((descriptionBGImage != null) ? ((Component)descriptionBGImage).gameObject : null, active: false);
			Image statImage = cardUi.m_StatImage;
			SetGameObjectActive((statImage != null) ? ((Component)statImage).gameObject : null, active: false);
			Image playEffectBGImage = cardUi.m_PlayEffectBGImage;
			SetGameObjectActive((playEffectBGImage != null) ? ((Component)playEffectBGImage).gameObject : null, active: false);
			Image evoBGImage = cardUi.m_EvoBGImage;
			SetGameObjectActive((evoBGImage != null) ? ((Component)evoBGImage).gameObject : null, active: false);
			object? value = CardUiFieldAccess.GetValue(cardUi, "m_StatGrp");
			GameObject val = (GameObject)((value is GameObject) ? value : null);
			if (val != null)
			{
				val.SetActive(false);
			}
			object? value2 = CardUiFieldAccess.GetValue(cardUi, "m_DescriptionGrp");
			GameObject val2 = (GameObject)((value2 is GameObject) ? value2 : null);
			if (val2 != null)
			{
				val2.SetActive(false);
			}
			object? value3 = CardUiFieldAccess.GetValue(cardUi, "m_EvoGrp");
			GameObject val3 = (GameObject)((value3 is GameObject) ? value3 : null);
			if (val3 != null)
			{
				val3.SetActive(false);
			}
			object? value4 = CardUiFieldAccess.GetValue(cardUi, "m_EvoBasicGrp");
			GameObject val4 = (GameObject)((value4 is GameObject) ? value4 : null);
			if (val4 != null)
			{
				val4.SetActive(false);
			}
			if ((Object)(object)cardUi.m_CardBorderMask != (Object)null)
			{
				((Behaviour)cardUi.m_CardBorderMask).enabled = false;
			}
			object? value5 = CardUiFieldAccess.GetValue(cardUi, "m_EvoAndArtistNameGrp");
			GameObject val5 = (GameObject)((value5 is GameObject) ? value5 : null);
			if (val5 != null)
			{
				val5.SetActive(false);
			}
		}

		private static void HideDuplicateTextWhenOverlayShown(CardUI cardUi)
		{
			string[] cardTextFieldNames = CardTextFieldNames;
			foreach (string fieldName in cardTextFieldNames)
			{
				SetBehaviourEnabled(GetCardUiFieldValue(cardUi, fieldName));
			}
		}

		private static object? GetCardUiFieldValue(CardUI cardUi, string fieldName)
		{
			return CardUiFieldAccess.GetValue(cardUi, fieldName);
		}

		private static void SetGameObjectActive(GameObject? gameObject, bool active)
		{
			if ((Object)(object)gameObject != (Object)null)
			{
				gameObject.SetActive(active);
			}
		}

		private static void SetImageEnabled(Image? image, bool enabled)
		{
			if ((Object)(object)image != (Object)null)
			{
				((Behaviour)image).enabled = enabled;
			}
		}

		private static void SetBehaviourEnabled(object? component, bool enabled = false)
		{
			Behaviour val = (Behaviour)((component is Behaviour) ? component : null);
			if (val != null)
			{
				val.enabled = enabled;
			}
		}

		private static bool TryGetMonsterImageLayout(object? cardConfig, out Vector2 size, out Vector2 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_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_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_0079: 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)
			size = Vector2.zero;
			position = Vector2.zero;
			if (cardConfig == null)
			{
				return false;
			}
			Type type = cardConfig.GetType();
			if (type.GetProperty("MonsterImageSize")?.GetValue(cardConfig) is Vector2 val)
			{
				size = val;
			}
			if (type.GetProperty("MonsterImagePosition")?.GetValue(cardConfig) is Vector2 val2)
			{
				position = val2;
			}
			if (!(size != Vector2.zero))
			{
				return position != Vector2.zero;
			}
			return true;
		}
	}
	internal static class TextureReplacerMaterialGuardPatches
	{
		public static void ApplyPatches(Harmony harmony)
		{
			harmony.PatchAll(typeof(TextureReplacerMaterialGuardPatches));
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Resources), "FindObjectsOfTypeAll", new Type[] { typeof(Type) })]
		public static void FindObjectsOfTypeAll_Postfix(Type type, ref Object[] __result)
		{
			if (TextureReplacerPhoneUiGuardPatches.DoReplaceDepth <= 0 || type != typeof(Material) || __result == null || __result.Length == 0)
			{
				return;
			}
			int num = __result.Length;
			List<Object> list = new List<Object>(num);
			Object[] array = __result;
			foreach (Object val in array)
			{
				Material val2 = (Material)(object)((val is Material) ? val : null);
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					if (ShouldProtectMaterialDuringDoReplace(val2))
					{
						continue;
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogDebug((object)("DoReplace material filter skipped one entry: " + ex.Message));
					continue;
				}
				list.Add(val);
			}
			__result = list.ToArray();
			Plugin.Log.LogInfo((object)$"DoReplace skipped {num - list.Count} TMP/font material(s); processing {list.Count}.");
		}

		internal static bool ShouldProtectMaterialDuringDoReplace(Material material)
		{
			Shader shader = material.shader;
			if ((Object)(object)shader == (Object)null)
			{
				return false;
			}
			if (IsTmpShader(((Object)shader).name))
			{
				return true;
			}
			string text = ((Object)material).name ?? string.Empty;
			if (text.IndexOf("Fredoka", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("LiberationSans", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("SDF", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool IsTmpShader(string shaderName)
		{
			if (shaderName.IndexOf("TextMeshPro", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return shaderName.IndexOf("TMP", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}
	}
	internal static class TextureReplacerPhoneUiGuardPatches
	{
		private static readonly string[] ProtectedFontTextureTokens = new string[4] { "FredokaOne", "LiberationSans", "SDF Atlas", "SDF border" };

		[ThreadStatic]
		private static int doReplaceDepth;

		public static int DoReplaceDepth => doReplaceDepth;

		public static void EnterDoReplaceScope()
		{
			doReplaceDepth++;
		}

		public static void ExitDoReplaceScope()
		{
			if (doReplaceDepth > 0)
			{
				doReplaceDepth--;
			}
		}

		public static bool GetCachedTexture_Prefix(string name, ref Texture2D __result)
		{
			if (IsProtectedFontTextureName(name))
			{
				__result = null;
				return false;
			}
			return true;
		}

		public static bool GetCachedTexture_Static_Prefix(string name, ref Texture2D __result)
		{
			if (IsProtectedFontTextureName(name))
			{
				__result = null;
				return false;
			}
			return true;
		}

		public static bool ForceWhiteIfNotGrayOrWhite_Prefix(Material m)
		{
			if ((Object)(object)((m != null) ? m.shader : null) == (Object)null)
			{
				return true;
			}
			string name = ((Object)m.shader).name;
			if (name.IndexOf("TextMeshPro", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("TMP", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			return true;
		}

		public static bool UpdateTitleTexts_Prefix()
		{
			Type type = ResolveTextureReplacerPluginType();
			if (type == null)
			{
				return true;
			}
			return !string.IsNullOrEmpty(AccessTools.Field(type, "phone_scannername")?.GetValue(null) as string);
		}

		public static void ReplaceItemDataInList_Prefix(List<ItemData> spriteList, ref Dictionary<int, string>? __state)
		{
			if (spriteList != null && spriteList.Count != 0)
			{
				__state = new Dictionary<int, string>(spriteList.Count);
				for (int i = 0; i < spriteList.Count; i++)
				{
					__state[i] = spriteList[i].name ?? string.Empty;
				}
			}
		}

		public static void ReplaceItemDataInList_Postfix(List<ItemData> spriteList, Dictionary<int, string>? __state)
		{
			if (spriteList == null || __state == null || __state.Count == 0)
			{
				return;
			}
			for (int i = 0; i < spriteList.Count; i++)
			{
				if (__state.TryGetValue(i, out var value) && !string.IsNullOrEmpty(value))
				{
					string text = spriteList[i].name ?? string.Empty;
					if (!string.Equals(text, value, StringComparison.Ordinal) && string.IsNullOrEmpty(LocalizationManager.GetTranslation(text, true, 0, true, false, (GameObject)null, (string)null, true)))
					{
						spriteList[i].name = value;
					}
				}
			}
		}

		public static void FixPhone_Postfix()
		{
			try
			{
				PhoneCanvasRepair.EnsurePhoneCanvasesReady(PhoneManagerAccess.FindPhoneManager()?.m_PhoneGrp);
				PhoneUiLateRepairBehaviour.RequestDeferredMaterialSweep();
				PhoneUi0703Patches.SchedulePhoneHomeRepair();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Phone UI repair after TextureReplacer.FixPhone failed: " + ex.Message));
			}
		}

		public static void DoReplace_Prefix()
		{
			PhoneFontMaterialSnapshot.CaptureIfNeeded();
			EnterDoReplaceScope();
		}

		public static void DoReplace_Finalizer()
		{
			ExitDoReplaceScope();
			PhoneUiLateRepairBehaviour.RequestDeferredMaterialSweep();
		}

		internal static Type? ResolveTextureReplacerPluginType()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					if (!string.Equals(assembly.GetName().Name, "TextureReplacer", StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					return assembly.GetType("TextureReplacer.BepInExPlugin");
				}
				catch
				{
				}
			}
			return AccessTools.TypeByName("TextureReplacer.BepInExPlugin");
		}

		internal static bool IsProtectedFontTextureName(string? name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			string[] protectedFontTextureTokens = ProtectedFontTextureTokens;
			foreach (string value in protectedFontTextureTokens)
			{
				if (name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}
	}
}