using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CollectionWeaver.Core;
using EnhancedPrefabLoader.API;
using EnhancedPrefabLoader.API.Assets;
using EnhancedPrefabLoader.API.Behaviors;
using EnhancedPrefabLoader.API.Events;
using EnhancedPrefabLoader.API.Extensions;
using EnhancedPrefabLoader.API.InternalBridges;
using EnhancedPrefabLoader.API.Models;
using EnhancedPrefabLoader.API.Registry;
using EnhancedPrefabLoader.API.Services;
using EnhancedPrefabLoader.API.UI;
using EnhancedPrefabLoader.Core;
using EnhancedPrefabLoader.Core.Assets;
using EnhancedPrefabLoader.Core.Cards;
using EnhancedPrefabLoader.Core.Cards.ExpGenerators;
using EnhancedPrefabLoader.Core.Cards.PriceGenerators;
using EnhancedPrefabLoader.Core.Components;
using EnhancedPrefabLoader.Core.Events;
using EnhancedPrefabLoader.Core.Extensions;
using EnhancedPrefabLoader.Core.ExternalBridges;
using EnhancedPrefabLoader.Core.LoadingPipeline;
using EnhancedPrefabLoader.Core.LoadingPipeline.Processors;
using EnhancedPrefabLoader.Core.LoadingPipeline.Validators;
using EnhancedPrefabLoader.Core.Models.Runtime;
using EnhancedPrefabLoader.Core.Models.SaveData;
using EnhancedPrefabLoader.Core.Packs.PackGenerators;
using EnhancedPrefabLoader.Core.Properties;
using EnhancedPrefabLoader.Core.Registry;
using EnhancedPrefabLoader.Core.Saves;
using EnhancedPrefabLoader.Core.Services;
using EnhancedPrefabLoader.Core.Services.Internal;
using EnhancedPrefabLoader.Core.Shops;
using EnhancedPrefabLoader.Core.Trading;
using EnhancedPrefabLoader.Core.Uninstall;
using EnhancedPrefabLoader.Core.Utils;
using EnhancedPrefabLoader.Shared.Enums;
using EnhancedPrefabLoader.Shared.Extensions;
using EnhancedPrefabLoader.Shared.Helpers;
using EnhancedPrefabLoader.Shared.Models;
using HarmonyLib;
using I2.Loc;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("EnhancedPrefabLoader")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("6.0.1.0")]
[assembly: AssemblyInformationalVersion("6.0.1+cd7431ddc1ec5aac5b27bb4a89a6104e570aad10")]
[assembly: AssemblyProduct("Enhanced Prefab Loader")]
[assembly: AssemblyTitle("EnhancedPrefabLoader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("6.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Count;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Count;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Count;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyList(List<T> items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return _items.Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		_items.CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return _items.IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
public sealed class ConfigurationManagerAttributes
{
	public delegate void CustomHotkeyDrawerFunc(ConfigEntryBase setting, ref bool isCurrentlyAcceptingInput);

	public bool? ShowRangeAsPercent;

	public Action<ConfigEntryBase> CustomDrawer;

	public CustomHotkeyDrawerFunc CustomHotkeyDrawer;

	public bool? Browsable;

	public string Category;

	public object DefaultValue;

	public bool? HideDefaultButton;

	public bool? HideSettingName;

	public string Description;

	public string DispName;

	public int? Order;

	public bool? ReadOnly;

	public bool? IsAdvanced;

	public Func<object, string> ObjToStr;

	public Func<string, object> StrToObj;
}
namespace EnhancedPrefabLoader
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("EnhancedPrefabLoader", "Enhanced Prefab Loader", "6.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("EnhancedPrefabLoader");

		private readonly BundleMaintenanceService maintenanceService = new BundleMaintenanceService();

		internal static Plugin Instance { get; private set; }

		public Plugin()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Instance = this;
		}

		private void Awake()
		{
			EplRuntimeData.Config.Initialize(((BaseUnityPlugin)this).Config);
			ModLogger.Initialize(((BaseUnityPlugin)this).Logger);
			Epl.RegisterApi((IEplApi)(object)new EplApi());
			InterceptorRegistry.RegisterFromAssembly(Assembly.GetExecutingAssembly());
			StreamingAssetsBridge.AssetLoadBridge = (IAssetLoadBridge)(object)EplRuntimeData.Services.StreamingAssetService;
			StreamingAssetsBridge.AssetRefTracker = (IAssetRefTracker)(object)EplRuntimeData.Services.StreamingAssetService;
			EplRuntimeData.Events.OnInventoryBaseAwake += delegate
			{
				EplRuntimeData.Services.ShopInventoryManager.PopulateAllShopInventories();
			};
			SceneManager.sceneLoaded += OnSceneLoad;
			harmony.PatchAll();
			ModLogger.Info("Plugin Enhanced Prefab Loader v:6.0.1 by GhostNarwhal is loaded!", "Awake", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Plugin.cs");
		}

		private void Update()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.IsBundleLoadingComplete)
			{
				return;
			}
			KeyboardShortcut value = EplRuntimeData.Config.PriceResetHotkey.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown())
			{
				return;
			}
			ModLogger.Info("Force price reset triggered for all bundles", "Update", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Plugin.cs");
			foreach (string key in EplRuntimeData.Assets.BundleRegistry.BundleInfo.Keys)
			{
				maintenanceService.ResetPricesFor(key);
			}
			ModLogger.Info("Price reset complete", "Update", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Plugin.cs");
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
			ModLogger.Info("Plugin Enhanced Prefab Loader is unloaded!", "OnDestroy", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Plugin.cs");
		}

		private void OnSceneLoad(Scene scene, LoadSceneMode _)
		{
			if (((Scene)(ref scene)).name == "Title")
			{
				EplRuntimeData.Services.SaveDataManager.ResetAllSaveData();
				EplRuntimeData.Services.ShopService.ResetUIState();
				EplRuntimeData.Services.WorkerPackOpenerScreenService.IsLoaded = false;
				EplRuntimeData.Services.CardExpansionSelectService.IsLoaded = false;
				EplRuntimeData.Services.CardRaritySelectService.IsLoaded = false;
				EplRuntimeData.Services.CollectionBinderService.IsLoaded = false;
				return;
			}
			EplRuntimeData.Services.ShopService.CreateAndRegisterCustomShops();
			EplRuntimeData.Services.StreamingAssetService.StartCleanupCoroutine();
			if (!(((Scene)(ref scene)).name == "Start"))
			{
				return;
			}
			CardFanRandomizer[] array = Resources.FindObjectsOfTypeAll<CardFanRandomizer>();
			foreach (CardFanRandomizer val in array)
			{
				string text = ((Object)((Component)val).transform).name;
				for (Transform parent = ((Component)val).transform.parent; parent != null; parent = parent.parent)
				{
					text = ((Object)parent).name + "/" + text;
				}
				ModLogger.Info($"CardFanRandomizer on: {text} (active: {((Component)val).gameObject.activeInHierarchy})", "OnSceneLoad", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Plugin.cs");
			}
		}
	}
}
namespace EnhancedPrefabLoader.Shared.Services
{
	public class BundleDiscoveryService
	{
		public List<string> DiscoverBundles(string basePath)
		{
			return Directory.EnumerateDirectories(basePath, "*_prefabloader", new EnumerationOptions
			{
				RecurseSubdirectories = true,
				MatchCasing = MatchCasing.CaseInsensitive
			}).ToList().SelectMany((string d) => Directory.GetFiles(d, "*.json", SearchOption.AllDirectories))
				.ToList();
		}
	}
}
namespace EnhancedPrefabLoader.Shared.Models
{
	public class BundleDescriptor
	{
		public string BundleId { get; set; } = string.Empty;


		public string Name { get; set; } = string.Empty;


		public List<string> Assemblies { get; set; } = new List<string>();


		public List<CustomShopInfo> CustomShops { get; set; } = new List<CustomShopInfo>();


		public List<ItemInfo> Items { get; set; } = new List<ItemInfo>();


		public List<PrefabInfo> Prefabs { get; set; } = new List<PrefabInfo>();


		public List<CardExpansionInfo> CardExpansions { get; set; } = new List<CardExpansionInfo>();


		public List<PrefabInfo> Furniture => Prefabs.Where((PrefabInfo p) => p.AddItemToFurnitureShop).ToList();

		public List<PrefabInfo> Deco => Prefabs.Where((PrefabInfo p) => p.IsDecoObject || p.IsDecoFloorTexture || p.IsDecoCeilingTexture || p.IsDecoWallTexture).ToList();

		public HashSet<string> PrefabNames
		{
			get
			{
				HashSet<string> hashSet = new HashSet<string>();
				foreach (string item in (from p in Prefabs?.Where((PrefabInfo p) => !string.IsNullOrWhiteSpace(p.PrefabName))
					select p.PrefabName) ?? Array.Empty<string>())
				{
					hashSet.Add(item);
				}
				return hashSet;
			}
		}

		public HashSet<string> MeshNames
		{
			get
			{
				HashSet<string> hashSet = new HashSet<string>();
				foreach (string item in (from i in Items?.Where((ItemInfo i) => !string.IsNullOrWhiteSpace(i.Mesh))
					select i.Mesh) ?? Array.Empty<string>())
				{
					hashSet.Add(item);
				}
				return hashSet;
			}
		}

		public HashSet<string> MaterialNames
		{
			get
			{
				HashSet<string> hashSet = new HashSet<string>();
				foreach (string item in (from i in Items?.Where((ItemInfo i) => !string.IsNullOrWhiteSpace(i.Material))
					select i.Material) ?? Array.Empty<string>())
				{
					hashSet.Add(item);
				}
				return hashSet;
			}
		}
	}
	public class CardExpansionInfo
	{
		public string Name { get; set; } = string.Empty;


		public string MenuCategory { get; set; } = string.Empty;


		public string CardExpansion { get; set; } = string.Empty;


		[JsonProperty("CardbackSprite")]
		public string Cardback { get; set; } = string.Empty;


		public string FoilMask { get; set; } = string.Empty;


		public bool HasRandomFoils { get; set; }

		public float FoilChance { get; set; }

		public List<string> Rarities { get; set; } = new List<string>();


		public List<CardInfo> Cards { get; set; } = new List<CardInfo>();


		public string CardPriceStrategy { get; set; } = string.Empty;


		public float DefaultBorderMultiplierBase { get; set; } = 3.15f;


		public float DefaultFoilMultiplier { get; set; } = 2.9f;


		public float RarityDrivenFloor { get; set; } = 4f;


		public float RarityDrivenStepSize { get; set; } = 1026f;


		public float RarityDrivenBorderMultiplierBase { get; set; } = 1.15f;


		public float RarityDrivenFoilMultiplier { get; set; } = 1.4f;


		public int TradeUnlockLevel { get; set; }

		public List<string> PlayCardMaterials { get; set; } = new List<string>();


		public bool IsValid { get; set; } = true;

	}
	public class CardExpansionMetadata
	{
		public string ExpansionName { get; set; } = string.Empty;


		public int CardCount { get; set; }
	}
	public class CardInfo
	{
		public string Name { get; set; } = string.Empty;


		public string ElementType { get; set; } = string.Empty;


		public string Rarity { get; set; } = string.Empty;


		public int CardNumber { get; set; }

		public string Sprite { get; set; } = string.Empty;


		public string BorderType { get; set; } = string.Empty;


		public bool IsFoil { get; set; }

		public string FoilMask { get; set; } = string.Empty;


		public string Cardback { get; set; } = string.Empty;

	}
	[Serializable]
	public struct ColorData
	{
		public float R { get; set; }

		public float G { get; set; }

		public float B { get; set; }

		public float A { get; set; }
	}
	public class CustomShopInfo
	{
		public string PhoneAppId { get; set; } = string.Empty;


		public string AppDisplayName { get; set; } = string.Empty;


		public string AppIcon { get; set; } = string.Empty;


		public string AppInnerBGImage { get; set; } = string.Empty;


		public string AppOuterBGImage { get; set; } = string.Empty;


		public string SiteLogo { get; set; } = string.Empty;


		public string SiteHeader { get; set; } = string.Empty;


		public string SiteBackground { get; set; } = string.Empty;


		public bool IsValid { get; internal set; } = true;

	}
	public class ItemInfo
	{
		public string Name { get; set; } = string.Empty;


		public string ItemCategory { get; set; } = string.Empty;


		public string SpriteName { get; set; } = string.Empty;


		public float BaseCost { get; set; }

		public bool AddItemAsAccessory { get; set; }

		public bool AddItemAsFigurine { get; set; }

		public bool AddItemAsBoardGame { get; set; }

		public string PhoneAppId { get; set; } = string.Empty;


		public string ItemType { get; set; } = string.Empty;


		public bool UsesBaseGameMesh { get; set; }

		public string MeshToUse { get; set; } = string.Empty;


		public string Mesh { get; set; } = string.Empty;


		public string MeshSecondary { get; set; } = string.Empty;


		public string Material { get; set; } = string.Empty;


		public string MaterialSecondary { get; set; } = string.Empty;


		public List<string> MaterialList { get; set; } = new List<string>();


		[JsonProperty("IsBigBox")]
		public bool HasBigBox { get; set; }

		public bool HasSmallBox { get; set; }

		[JsonProperty("HideTillUnlocked")]
		public bool BigBoxHideTillUnlocked { get; set; }

		public bool SmallBoxHideTillUnlocked { get; set; }

		[JsonProperty("LicensePrice")]
		public float BigBoxLicensePrice { get; set; }

		public float SmallBoxLicensePrice { get; set; }

		[JsonProperty("LicenseLevelRequirement")]
		public int BigBoxLicenseLevelRequirement { get; set; }

		public int SmallBoxLicenseLevelRequirement { get; set; }

		[JsonProperty("IgnoreDoubleImage")]
		public bool BigBoxIgnoreDoubleImage { get; set; }

		public bool SmallBoxIgnoreDoubleImage { get; set; }

		public float MinMarketPricePercent { get; set; }

		public float MaxMarketPricePercent { get; set; }

		public string FollowItemPrice { get; set; } = string.Empty;


		public bool AutoSetBoxPrice { get; set; }

		public bool IsTallItem { get; set; }

		public float InBoxOffsetY { get; set; }

		public float InBoxOffsetScale { get; set; }

		public Vector3Data ItemDeminsion { get; set; }

		public Vector3Data CollidorPosOffset { get; set; }

		public Vector3Data ColliderScale { get; set; }

		public List<string> PriceAffectedBy { get; set; } = new List<string>();


		public bool IsSprayCan { get; set; }

		public bool IsCardPack { get; set; }

		public bool IsCardBox { get; set; }

		public bool IsBulkBox { get; set; }

		public int MinValue { get; set; }

		public string CardExpansion { get; set; } = string.Empty;


		public bool CanHaveDuplicates { get; set; }

		public bool CanHaveGodPacks { get; set; }

		public string PackGenerationStrategy { get; set; } = string.Empty;


		public Dictionary<string, float> NormalWeights { get; set; } = new Dictionary<string, float>();


		public Dictionary<string, float> GodWeights { get; set; } = new Dictionary<string, float>();


		public Dictionary<string, Dictionary<string, float>> SlotWeights { get; set; } = new Dictionary<string, Dictionary<string, float>>();


		[Obsolete("Use NormalWeights, GodWeights, and SlotWeights instead. This field exists for backwards compatibility with older descriptors.")]
		public List<RarityWeightInfo> GenerationWeights { get; set; } = new List<RarityWeightInfo>();


		public string SpawnsPackType { get; set; } = string.Empty;


		public string PackType { get; set; } = string.Empty;


		public float GodPackPercentage { get; set; }

		public bool IsValid { get; set; } = true;

	}
	public class ModManifest
	{
		public string ModId { get; set; } = string.Empty;


		public string Name { get; set; } = string.Empty;


		public string Directory { get; set; } = string.Empty;


		public string BundlePath { get; set; } = string.Empty;


		public string JsonPath { get; set; } = string.Empty;


		public bool IsValid { get; set; } = true;


		public bool IsLoaded { get; set; } = true;


		public List<string> Errors { get; set; } = new List<string>();


		public int ItemCount { get; set; }

		public int FurnitureCount { get; set; }

		public int CustomShopCount { get; set; }

		public int DecoCount { get; set; }

		public List<CardExpansionMetadata> CardExpansions { get; set; } = new List<CardExpansionMetadata>();

	}
	public class PrefabInfo
	{
		public string Name { get; set; } = string.Empty;


		public string PrefabName { get; set; } = string.Empty;


		public string SpriteName { get; set; } = string.Empty;


		public float Price { get; set; }

		public int LevelRequirement { get; set; }

		public bool AddItemToFurnitureShop { get; set; }

		public string Description { get; set; } = string.Empty;


		public string ObjectType { get; set; }

		public List<VideoClipInfo> VideoClips { get; set; } = new List<VideoClipInfo>();


		public float DecoBonus { get; set; }

		public bool IsDecoWallTexture { get; set; }

		public bool IsDecoFloorTexture { get; set; }

		public bool IsDecoCeilingTexture { get; set; }

		public bool IsDecoObject { get; set; }

		public string DecoObject { get; set; } = string.Empty;


		public string DecoType { get; set; } = string.Empty;


		public string Texture { get; set; } = string.Empty;


		public string RoughnessMap { get; set; } = string.Empty;


		public string NormalMap { get; set; } = string.Empty;


		public float Smoothness { get; set; }

		public ColorData Color { get; set; }

		public bool IsValid { get; set; } = true;

	}
	public class RarityWeightInfo
	{
		public string Rarity { get; set; } = string.Empty;


		[Obsolete("Use SlotWeights instead. This field exists for backwards compatibility with older descriptors.")]
		public string GuaranteedSlots { get; set; } = string.Empty;


		public float NormalWeight { get; set; }

		public float GodPackWeight { get; set; }
	}
	[Serializable]
	public struct Vector3Data
	{
		public float X { get; set; }

		public float Y { get; set; }

		public float Z { get; set; }
	}
	public class VideoClipInfo
	{
		public string Name { get; set; } = string.Empty;


		public string VideoPlayerName { get; set; } = string.Empty;

	}
}
namespace EnhancedPrefabLoader.Shared.Helpers
{
	public static class FileHelper
	{
		public static List<string> GetAllJsonFilesIn(string basePath, string folderPattern)
		{
			return Directory.EnumerateDirectories(basePath, folderPattern, new EnumerationOptions
			{
				RecurseSubdirectories = true,
				MatchCasing = MatchCasing.CaseInsensitive
			}).SelectMany((string d) => Directory.GetFiles(d, "*.json", SearchOption.AllDirectories)).ToList();
		}
	}
	public static class ModIdGenerator
	{
		public static string GenerateFromDirectory(string directory)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(Path.GetDirectoryName(directory));
			string fullName = directoryInfo.FullName;
			string name = directoryInfo.Name;
			using SHA1 sHA = SHA1.Create();
			string text = BitConverter.ToString(sHA.ComputeHash(Encoding.UTF8.GetBytes(fullName.ToLowerInvariant()))).Replace("-", "").Substring(0, 8);
			return name + "_" + text;
		}
	}
}
namespace EnhancedPrefabLoader.Shared.Extensions
{
	public static class DictionaryExtensions
	{
		public static TValue GetOrDefault<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key)
		{
			if (!dict.TryGetValue(key, out TValue value))
			{
				return default(TValue);
			}
			return value;
		}

		public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key, Func<TKey, TValue> factory)
		{
			if (!dict.TryGetValue(key, out TValue value))
			{
				value = (dict[key] = factory(key));
			}
			return value;
		}

		public static void MergeAdd<TKey>(this Dictionary<TKey, int> dict, IEnumerable<(TKey key, int amount)> items)
		{
			foreach (var item3 in items)
			{
				TKey item = item3.key;
				int item2 = item3.amount;
				dict[item] = dict.GetOrAdd(item, (TKey _) => 0) + item2;
			}
		}

		public static void AddRange<TKey, TValue>(this Dictionary<TKey, TValue> dict, IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			foreach (KeyValuePair<TKey, TValue> item in items)
			{
				dict[item.Key] = item.Value;
			}
		}
	}
	public static class ListExtensions
	{
		public static List<T> Shuffle<T>(this List<T> list) where T : class
		{
			for (int num = list.Count - 1; num > 0; num--)
			{
				int num2 = Random.Range(0, num + 1);
				int index = num;
				int index2 = num2;
				T value = list[num2];
				T value2 = list[num];
				list[index] = value;
				list[index2] = value2;
			}
			return list;
		}

		public static List<T> SwapAndRemove<T>(this List<T> list, int index)
		{
			int num = list.Count - 1;
			if (index != num)
			{
				int index2 = num;
				T value = list[num];
				T value2 = list[index];
				list[index] = value;
				list[index2] = value2;
			}
			list.RemoveAt(num);
			return list;
		}
	}
}
namespace EnhancedPrefabLoader.Shared.Enums
{
	[Flags]
	public enum ItemFlags : byte
	{
		None = 0,
		BoardGame = 1,
		Accessory = 2,
		Figurine = 4,
		TCG = 8
	}
}
namespace EnhancedPrefabLoader.Core
{
	internal class BundleManager
	{
		internal class BundleHandle
		{
			[CompilerGenerated]
			private sealed class <WaitForLoadAsync>d__12 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public BundleHandle <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					BundleHandle bundleHandle = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (bundleHandle.IsLoaded)
						{
							return false;
						}
						if (bundleHandle.isLoading)
						{
							break;
						}
						bundleHandle.isLoading = true;
						if (bundleHandle.loadRequest != null)
						{
							<>2__current = bundleHandle.loadRequest;
							<>1__state = 1;
							return true;
						}
						goto IL_00a2;
					case 1:
						<>1__state = -1;
						bundleHandle.assetBundle = bundleHandle.loadRequest.assetBundle;
						bundleHandle.loadRequest = null;
						bundleHandle.IsLoaded = bundleHandle.assetBundle != null;
						bundleHandle.HasError = bundleHandle.assetBundle == null;
						goto IL_00a2;
					case 2:
						{
							<>1__state = -1;
							break;
						}
						IL_00a2:
						bundleHandle.isLoading = false;
						break;
					}
					if (bundleHandle.isLoading)
					{
						ModLogger.Debug("Waiting for another coroutine to finish loading bundle.", "WaitForLoadAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\BundleManager.cs");
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					return false;
				}

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

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

			private AssetBundle? assetBundle;

			private AssetBundleCreateRequest? loadRequest;

			private bool isLoading;

			public bool HasError { get; private set; }

			public bool IsLoaded { get; private set; }

			public static BundleHandle Create(string bundlePath)
			{
				string bundleName = Path.GetFileNameWithoutExtension(bundlePath);
				AssetBundle val = AssetBundle.GetAllLoadedAssetBundles().FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle b) => ((Object)b).name == bundleName));
				if (val != null)
				{
					ModLogger.Debug("Bundle '" + bundleName + "' already loaded externally, reusing.", "Create", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\BundleManager.cs");
					return new BundleHandle
					{
						assetBundle = val,
						IsLoaded = true
					};
				}
				return new BundleHandle
				{
					loadRequest = AssetBundle.LoadFromFileAsync(bundlePath)
				};
			}

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

			internal AssetBundleRequest? LoadAssetAsync<T>(string assetName) where T : Object
			{
				if (!string.IsNullOrEmpty(assetName))
				{
					AssetBundle? obj = assetBundle;
					if (obj == null)
					{
						return null;
					}
					return obj.LoadAssetAsync<T>(assetName);
				}
				return null;
			}

			internal AssetBundleRequest? LoadAssetAsync(string assetName, Type type)
			{
				if (!string.IsNullOrEmpty(assetName))
				{
					AssetBundle? obj = assetBundle;
					if (obj == null)
					{
						return null;
					}
					return obj.LoadAssetAsync(assetName, type);
				}
				return null;
			}

			internal AssetBundleRequest? LoadAllAsync<T>() where T : Object
			{
				AssetBundle? obj = assetBundle;
				if (obj == null)
				{
					return null;
				}
				return obj.LoadAllAssetsAsync<T>();
			}
		}

		private readonly Dictionary<string, BundleHandle> bundleHandles = new Dictionary<string, BundleHandle>();

		internal BundleHandle GetOrOpen(string bundlePath)
		{
			if (bundleHandles.TryGetValue(bundlePath, out BundleHandle value))
			{
				if (!value.HasError)
				{
					return value;
				}
				bundleHandles.Remove(bundlePath);
			}
			value = BundleHandle.Create(bundlePath);
			bundleHandles[bundlePath] = value;
			return value;
		}
	}
	internal class EplApi : IEplApi
	{
		public bool IsBundleLoadingComplete => EplRuntimeData.IsBundleLoadingComplete;

		public IBundleRegistry BundleRegistry => (IBundleRegistry)(object)EplRuntimeData.Assets.BundleRegistry;

		public IEplAssets Assets => (IEplAssets)(object)EplRuntimeData.Assets;

		public IEplServices Services => (IEplServices)(object)EplRuntimeData.Services;

		public IEplEvents Events => (IEplEvents)(object)EplRuntimeData.Events;
	}
	internal class EplCaches
	{
		internal Dictionary<string, Material> CardBackMaterials { get; } = new Dictionary<string, Material>();


		internal Material? OriginalCardBackMaterial { get; set; }

		internal Dictionary<InteractablePlayTable, List<Material>> PlayTableExpansionCache { get; } = new Dictionary<InteractablePlayTable, List<Material>>();

	}
	internal class EplConfig
	{
		internal bool ExcludeBaseGameCardsFromTrade { get; private set; }

		internal bool SparkleFoilEnabled { get; private set; }

		internal bool UseCustomExpForBase { get; private set; }

		internal bool DisableBaseGamePlayCards { get; private set; }

		internal ConfigEntry<KeyboardShortcut> PriceResetHotkey { get; private set; }

		internal ConfigEntry<LogLevel> MinimumLogLevelEntry { get; private set; }

		internal ConfigEntry<float> CollectionBinderSpacingXEntry { get; private set; }

		internal ConfigEntry<float> CollectionBinderSpacingYEntry { get; private set; }

		internal ConfigEntry<Vector2> CollectionBinderButtonSizeEntry { get; private set; }

		internal ConfigEntry<float> CardExpansionSelectSpacingXEntry { get; private set; }

		internal ConfigEntry<float> CardExpansionSelectSpacingYEntry { get; private set; }

		internal ConfigEntry<Vector2> CardExpansionSelectButtonSizeEntry { get; private set; }

		internal ConfigEntry<float> RaritySelectSpacingXEntry { get; private set; }

		internal ConfigEntry<float> RaritySelectSpacingYEntry { get; private set; }

		internal ConfigEntry<Vector2> RaritySelectButtonSizeEntry { get; private set; }

		internal void Initialize(ConfigFile config)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<bool> excludeBaseGame = config.Bind<bool>("Trading", "ExcludeBaseGameCardsFromTrade", false, "When enabled, base-game expansions (Tetramon, Destiny, Ghost) will not appear in customer card trade/sell selection.");
			ExcludeBaseGameCardsFromTrade = excludeBaseGame.Value;
			excludeBaseGame.SettingChanged += delegate
			{
				ExcludeBaseGameCardsFromTrade = excludeBaseGame.Value;
			};
			ConfigEntry<bool> sparkleFoil = config.Bind<bool>("CardUI", "Sparkle Foil Enabled", true, "When enabled, foil cards display the sparkle glitter effect.");
			SparkleFoilEnabled = sparkleFoil.Value;
			sparkleFoil.SettingChanged += delegate
			{
				SparkleFoilEnabled = sparkleFoil.Value;
			};
			CollectionBinderSpacingXEntry = config.Bind<float>("CollectionBinderUI", "ExpansionSpacingX", 30f, (ConfigDescription)null);
			CollectionBinderSpacingYEntry = config.Bind<float>("CollectionBinderUI", "ExpansionSpacingY", -45f, (ConfigDescription)null);
			CollectionBinderButtonSizeEntry = config.Bind<Vector2>("CollectionBinderUI", "ExpansionButtonSize", new Vector2(325f, 184.5f), (ConfigDescription)null);
			CardExpansionSelectSpacingXEntry = config.Bind<float>("UI", "ExpansionSpacingX", 30f, (ConfigDescription)null);
			CardExpansionSelectSpacingYEntry = config.Bind<float>("UI", "ExpansionSpacingY", -45f, (ConfigDescription)null);
			CardExpansionSelectButtonSizeEntry = config.Bind<Vector2>("UI", "ExpansionButtonSize", new Vector2(325f, 184.5f), (ConfigDescription)null);
			RaritySelectSpacingXEntry = config.Bind<float>("UI", "RaritySpacingX", 30f, (ConfigDescription)null);
			RaritySelectSpacingYEntry = config.Bind<float>("UI", "RaritySpacingY", -45f, (ConfigDescription)null);
			RaritySelectButtonSizeEntry = config.Bind<Vector2>("UI", "RarityButtonSize", new Vector2(325f, 184.5f), (ConfigDescription)null);
			ConfigEntry<bool> useCustomExp = config.Bind<bool>("GamePlay", "UseCustomExpForBase", false, "When enabled, base-game card expansions will use the EPL experience formula instead of the vanilla formula.");
			UseCustomExpForBase = useCustomExp.Value;
			useCustomExp.SettingChanged += delegate
			{
				UseCustomExpForBase = useCustomExp.Value;
			};
			PriceResetHotkey = config.Bind<KeyboardShortcut>("Hotkeys", "Force Price Reset", new KeyboardShortcut((KeyCode)114, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Press to reset all item and card prices for every loaded bundle.");
			MinimumLogLevelEntry = config.Bind<LogLevel>("Logging", "Minimum log level to log", LogLevel.None, (ConfigDescription)null);
			ConfigEntry<bool> disableBaseCards = config.Bind<bool>("PlayTable", "DisableBaseGamePlayCards", false, "When enabled, base game card textures will not appear on play tables. If no mod expansion textures are available, this setting is ignored.");
			DisableBaseGamePlayCards = disableBaseCards.Value;
			disableBaseCards.SettingChanged += delegate
			{
				DisableBaseGamePlayCards = disableBaseCards.Value;
			};
		}
	}
	internal static class EplRuntimeData
	{
		internal static bool IsBundleLoadingComplete { get; set; }

		internal static BundleAssetTracker BundleAssetTracker { get; set; } = new BundleAssetTracker();


		internal static List<Assembly> Assemblies { get; private set; } = new List<Assembly>();


		internal static EplCaches Caches { get; private set; } = new EplCaches();


		internal static EplConfig Config { get; private set; } = new EplConfig();


		internal static EplEvents Events { get; private set; } = new EplEvents();


		internal static EplAssets Assets { get; private set; } = new EplAssets(new BundleRegistry(BundleAssetTracker));


		internal static EplServices Services { get; private set; } = new EplServices(new SaveDataService(BundleAssetTracker));

	}
	public enum LogLevel
	{
		Debug,
		Info,
		Warning,
		Error,
		None
	}
	public static class ModLogger
	{
		private static ManualLogSource logger;

		private static LogLevel logLevel;

		public static void Initialize(ManualLogSource logger)
		{
			ModLogger.logger = logger;
			logLevel = EplRuntimeData.Config.MinimumLogLevelEntry.Value;
			EplRuntimeData.Config.MinimumLogLevelEntry.SettingChanged += delegate
			{
				logLevel = EplRuntimeData.Config.MinimumLogLevelEntry.Value;
			};
		}

		public static void Debug(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Debug)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogDebug((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}

		public static void Info(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Info)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogInfo((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}

		public static void Warning(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Warning)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogWarning((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}

		public static void Error(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Error)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogError((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "EnhancedPrefabLoader";

		public const string PLUGIN_NAME = "Enhanced Prefab Loader";

		public const string PLUGIN_VERSION = "6.0.1";
	}
}
namespace EnhancedPrefabLoader.Core.Utils
{
	public static class EplConstants
	{
		public const string EplDirectoryDescriptor = "*_prefabloader";
	}
	internal static class ItemTypeResolver
	{
		private static EItemType[]? sortedModKeys;

		internal static EItemType Resolve(int index)
		{
			if (index >= 129)
			{
				if (index < 200000)
				{
					return GetSortedModKeys()[index - 129];
				}
				return (EItemType)index;
			}
			return (EItemType)index;
		}

		internal static EItemType[] GetSortedModKeys()
		{
			return sortedModKeys ?? (sortedModKeys = EplRuntimeData.Assets.ItemLibrary.ItemData.Keys.OrderBy((EItemType k) => (int)k).ToArray());
		}

		internal static void InvalidateCache()
		{
			sortedModKeys = null;
		}
	}
	public static class RandomUtils
	{
		public static T Weighted<T>(Dictionary<T, float> weights)
		{
			float num = 0f;
			foreach (KeyValuePair<T, float> weight in weights)
			{
				num += weight.Value;
			}
			float num2 = Random.value * num;
			foreach (KeyValuePair<T, float> weight2 in weights)
			{
				num2 -= weight2.Value;
				if (num2 <= 0f)
				{
					return weight2.Key;
				}
			}
			return weights.Last().Key;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Uninstall
{
	internal class CardRemovalStrategy : IAssetRemovalStrategy
	{
		[CompilerGenerated]
		private HashSet<ECardExpansionType> <cardExpansions>P;

		private Dictionary<CardData, int> removedCards;

		public CardRemovalStrategy(HashSet<ECardExpansionType> cardExpansions)
		{
			<cardExpansions>P = cardExpansions;
			removedCards = new Dictionary<CardData, int>();
			base..ctor();
		}

		public RemovalResult RemoveAssets()
		{
			removedCards = new Dictionary<CardData, int>();
			RemoveFromCardShelves();
			RemoveFromBinder();
			RemoveFromBulkDonationBoxes();
			RemoveFromCardStorageShelves();
			RemoveFromCardPackageBoxes();
			return RemovalResult.Success(removedCards.Values.Sum(), removedCards.Sum<KeyValuePair<CardData, int>>((KeyValuePair<CardData, int> kvp) => CPlayerData.GetCardMarketPrice(kvp.Key) * (float)kvp.Value));
		}

		private void RemoveFromCardShelves()
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			foreach (InteractableCardCompartment item in CSingleton<ShelfManager>.Instance.m_CardShelfList.SelectMany((CardShelf cs) => cs.m_CardCompartmentList))
			{
				if (item.m_StoredCardList.Count == 0)
				{
					continue;
				}
				CardData cardData = item.m_StoredCardList[0].m_Card3dUI.m_CardUI.m_CardData;
				if (!<cardExpansions>P.Contains(cardData.expansionType))
				{
					continue;
				}
				foreach (InteractableCardPriceTag interactablePriceTag in item.m_InteractablePriceTagList)
				{
					interactablePriceTag.SetPriceChecked(false);
				}
				item.m_StoredCardList[0].SetIsDisplayedOnShelf(false);
				item.m_StoredCardList[0].SetTargetRotation(Quaternion.identity);
				item.m_StoredCardList.RemoveAt(0);
				item.SetPriceTagCardData((CardData)null);
				item.SetPriceTagVisibility(false);
				if (item.m_CardShelf?.m_ElectronicCardListener != null)
				{
					item.m_CardShelf.m_ElectronicCardListener.UpdateCardUI((CardData)null);
				}
				removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + 1;
			}
		}

		private void RemoveFromBinder()
		{
			//IL_00a3: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			foreach (CardData item in CPlayerData.m_GradedCardInventoryList.Where((CompactCardDataAmount c) => <cardExpansions>P.Contains(c.expansionType)).Select((Func<CompactCardDataAmount, CardData>)CPlayerData.GetGradedCardData).ToList())
			{
				CPlayerData.RemoveGradedCard(item, false);
				removedCards[item] = removedCards.GetValueOrDefault(item) + 1;
			}
			CardExpansionLibrary cardExpansionLibrary = EplRuntimeData.Assets.CardExpansionLibrary;
			foreach (ECardExpansionType item2 in <cardExpansions>P)
			{
				if (!cardExpansionLibrary.CardExpansionData.TryGetValue(item2, out ModCardExpansionData value))
				{
					continue;
				}
				foreach (KeyValuePair<EMonsterType, ModCardData> card in value.Cards)
				{
					card.Deconstruct(out var _, out var value2);
					CardData val = value2;
					int cardAmount = CPlayerData.GetCardAmount(val);
					if (cardAmount > 0)
					{
						CPlayerData.ReduceCard(val, cardAmount);
						removedCards[val] = removedCards.GetValueOrDefault(val) + cardAmount;
					}
				}
			}
		}

		private void RemoveFromBulkDonationBoxes()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			foreach (List<CompactCardDataAmount> item in CSingleton<ShelfManager>.Instance.m_BulkDonationBoxList.Select((InteractableBulkDonationBox b) => b.m_CompactCardDataAmountList))
			{
				foreach (CompactCardDataAmount item2 in item.Where((CompactCardDataAmount c) => <cardExpansions>P.Contains(c.expansionType)))
				{
					CardData cardData = CPlayerData.GetCardData(item2.cardSaveIndex, item2.expansionType, item2.isDestiny);
					removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + item2.amount;
				}
				item.RemoveAll((CompactCardDataAmount c) => <cardExpansions>P.Contains(c.expansionType));
			}
		}

		private void RemoveFromCardStorageShelves()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			foreach (List<CompactCardDataAmount> item in CSingleton<ShelfManager>.Instance.m_CardStorageShelfList.Select((InteractableCardStorageShelf b) => b.m_CompactCardDataAmountList))
			{
				foreach (CompactCardDataAmount item2 in item.Where((CompactCardDataAmount c) => <cardExpansions>P.Contains(c.expansionType)))
				{
					CardData cardData = CPlayerData.GetCardData(item2.cardSaveIndex, item2.expansionType, item2.isDestiny);
					removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + item2.amount;
				}
				item.RemoveAll((CompactCardDataAmount c) => <cardExpansions>P.Contains(c.expansionType));
			}
		}

		private void RemoveFromCardPackageBoxes()
		{
			List<InteractablePackagingBox_Card> list = new List<InteractablePackagingBox_Card>();
			foreach (InteractablePackagingBox_Card spawnedPackageBox in CSingleton<ShelfManager>.Instance.m_SpawnedPackageBoxCardList)
			{
				spawnedPackageBox.m_StoredCardList.RemoveAll(delegate(InteractableCard3d i)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					CardData cardData = i.m_Card3dUI.m_CardUI.m_CardData;
					if (<cardExpansions>P.Contains(cardData.expansionType))
					{
						removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + 1;
						spawnedPackageBox.m_StoredCardDataList.Remove(cardData);
						((InteractableObject)i).OnDestroyed();
						return true;
					}
					return false;
				});
				if (spawnedPackageBox.m_StoredCardList.Count == 0)
				{
					list.Add(spawnedPackageBox);
				}
			}
			foreach (InteractablePackagingBox_Card item in list)
			{
				CSingleton<ShelfManager>.Instance.m_SpawnedPackageBoxCardList.Remove(item);
				((InteractableObject)item).OnDestroyed();
			}
		}
	}
	internal class DecoRemovalStrategy : IAssetRemovalStrategy
	{
		[CompilerGenerated]
		private HashSet<EDecoObject> <decoTypes>P;

		[CompilerGenerated]
		private string <bundleId>P;

		public DecoRemovalStrategy(HashSet<EDecoObject> decoTypes, string bundleId)
		{
			<decoTypes>P = decoTypes;
			<bundleId>P = bundleId;
			base..ctor();
		}

		public RemovalResult RemoveAssets()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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)
			float totalValue = 0f;
			int totalDecoCount = 0;
			foreach (EDecoObject item in <decoTypes>P)
			{
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EDecoObject, DecoSaveData>(item, out DecoSaveData data))
				{
					totalDecoCount += data.ItemCount;
					totalValue += InventoryBase.GetItemDecoPurchaseData(item).price * (float)data.ItemCount;
					data.Reset();
				}
			}
			ResetTextureSaveData((DecoFlags)3, EplRuntimeData.Assets.DecoLibrary.firstInsertedCeilingTexture, CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_CeilingDecoDataList, ref totalDecoCount, ref totalValue);
			ResetTextureSaveData((DecoFlags)1, EplRuntimeData.Assets.DecoLibrary.firstInsertedFloorTexture, CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FloorDecoDataList, ref totalDecoCount, ref totalValue);
			ResetTextureSaveData((DecoFlags)2, EplRuntimeData.Assets.DecoLibrary.firstInsertedWallTexture, CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_WallDecoDataList, ref totalDecoCount, ref totalValue);
			return RemovalResult.Success(totalDecoCount, totalValue);
		}

		private void ResetTextureSaveData(DecoFlags category, int? firstInsertedIndex, List<ShopDecoData> decoDataList, ref int totalDecoCount, ref float totalValue)
		{
			if (!firstInsertedIndex.HasValue)
			{
				return;
			}
			string category2 = ((object)(DecoFlags)(ref category)).ToString();
			BundleAssetTracker bundleAssetTracker = EplRuntimeData.BundleAssetTracker;
			SaveDataService saveDataManager = EplRuntimeData.Services.SaveDataManager;
			for (int i = firstInsertedIndex.Value; i < decoDataList.Count; i++)
			{
				string name = decoDataList[i].name;
				if (!(bundleAssetTracker.GetBundleIdFor(category2, name) != <bundleId>P) && saveDataManager.TryGetSaveData<DecoSaveData>(category2, name, out DecoSaveData data))
				{
					totalDecoCount += data.ItemCount;
					totalValue += decoDataList[i].price * (float)data.ItemCount;
					data.Reset();
				}
			}
		}
	}
	internal interface IAssetRemovalStrategy
	{
		RemovalResult RemoveAssets();
	}
	internal class InteractableObjectRemovalStrategy : IAssetRemovalStrategy
	{
		[CompilerGenerated]
		private HashSet<EObjectType> <furnitures>P;

		[CompilerGenerated]
		private HashSet<EDecoObject> <decos>P;

		private readonly Dictionary<EItemType, int> itemsToRestock;

		public InteractableObjectRemovalStrategy(HashSet<EObjectType> furnitures, HashSet<EDecoObject> decos)
		{
			<furnitures>P = furnitures;
			<decos>P = decos;
			itemsToRestock = new Dictionary<EItemType, int>();
			base..ctor();
		}

		public RemovalResult RemoveAssets()
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			itemsToRestock.Clear();
			int num = 0;
			float num2 = 0f;
			List<InteractableObject> list = (from Transform t in (IEnumerable)CSingleton<ShelfManager>.Instance.m_ShelfParentGrp
				select ((Component)t).GetComponent<InteractableObject>() into i
				where i != null && (<furnitures>P.Contains(i.m_ObjectType) || <decos>P.Contains(i.m_DecoObjectType))
				select i).ToList();
			FurnitureLibrary furnitureLibrary = EplRuntimeData.Assets.FurnitureLibrary;
			foreach (InteractableObject item in list)
			{
				InteractableDecoration val = (InteractableDecoration)(object)((item is InteractableDecoration) ? item : null);
				if (val == null)
				{
					InteractableBulkDonationBox val2 = (InteractableBulkDonationBox)(object)((item is InteractableBulkDonationBox) ? item : null);
					if (val2 == null)
					{
						InteractableCardStorageShelf val3 = (InteractableCardStorageShelf)(object)((item is InteractableCardStorageShelf) ? item : null);
						if (val3 == null)
						{
							CardShelf val4 = (CardShelf)(object)((item is CardShelf) ? item : null);
							if (val4 == null)
							{
								InteractableWorkbench val5 = (InteractableWorkbench)(object)((item is InteractableWorkbench) ? item : null);
								if (val5 == null)
								{
									Shelf val6 = (Shelf)(object)((item is Shelf) ? item : null);
									if (val6 == null)
									{
										WarehouseShelf val7 = (WarehouseShelf)(object)((item is WarehouseShelf) ? item : null);
										if (val7 != null)
										{
											EmptyWarehouseShelf(val7);
											num2 += furnitureLibrary.FurnitureData[((InteractableObject)val7).m_ObjectType].BaseFurniturePurchaseData.price;
										}
										else
										{
											num2 += furnitureLibrary.FurnitureData[item.m_ObjectType].BaseFurniturePurchaseData.price;
										}
									}
									else
									{
										EmptyShelf(val6);
										num2 += furnitureLibrary.FurnitureData[((InteractableObject)val6).m_ObjectType].BaseFurniturePurchaseData.price;
									}
								}
								else
								{
									EmptyWorkbench(val5);
									num2 += furnitureLibrary.FurnitureData[((InteractableObject)val5).m_ObjectType].BaseFurniturePurchaseData.price;
								}
							}
							else
							{
								EmptyCardShelf(val4);
								num2 += furnitureLibrary.FurnitureData[((InteractableObject)val4).m_ObjectType].BaseFurniturePurchaseData.price;
							}
						}
						else
						{
							EmptyCardStorageShelf(val3);
							num2 += furnitureLibrary.FurnitureData[((InteractableObject)val3).m_ObjectType].BaseFurniturePurchaseData.price;
						}
					}
					else
					{
						EmptyBulkDonationBox(val2);
						num2 += furnitureLibrary.FurnitureData[((InteractableObject)val2).m_ObjectType].BaseFurniturePurchaseData.price;
					}
				}
				else
				{
					num2 += InventoryBase.GetItemDecoPurchaseData(((InteractableObject)val).m_DecoObjectType).price;
				}
				if (item.m_IsBoxedUp)
				{
					((InteractableObject)item.m_InteractablePackagingBox_Shelf).OnDestroyed();
				}
				else
				{
					item.OnDestroyed();
				}
				num++;
			}
			RestockItems();
			return RemovalResult.Success(num, num2);
		}

		private void EmptyWarehouseShelf(WarehouseShelf warehouseShelf)
		{
			//IL_0064: 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)
			foreach (ShelfCompartment item in from p in warehouseShelf.m_StorageCompartmentList.SelectMany((InteractableStorageCompartment s) => s.m_ShelfCompartment.m_InteractablePackagingBoxList)
				select p.m_ItemCompartment)
			{
				itemsToRestock[item.m_ItemType] = itemsToRestock.GetValueOrDefault(item.m_ItemType) + item.m_StoredItemList.Count;
			}
		}

		private void EmptyShelf(Shelf shelf)
		{
			//IL_001d: 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)
			foreach (ShelfCompartment itemCompartment in ((InteractableObject)shelf).m_ItemCompartmentList)
			{
				itemsToRestock[itemCompartment.m_ItemType] = itemsToRestock.GetValueOrDefault(itemCompartment.m_ItemType) + itemCompartment.m_StoredItemList.Count;
			}
		}

		private void EmptyWorkbench(InteractableWorkbench interactableWorkbench)
		{
			//IL_001d: 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)
			foreach (Item storedItem in interactableWorkbench.m_StoredItemList)
			{
				itemsToRestock[storedItem.m_ItemType] = itemsToRestock.GetValueOrDefault(storedItem.m_ItemType) + 1;
			}
		}

		private static void EmptyCardShelf(CardShelf cardShelf)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			foreach (InteractableCardCompartment item in cardShelf.m_CardCompartmentList.Where((InteractableCardCompartment c) => c.m_StoredCardList.Count > 0))
			{
				foreach (InteractableCardPriceTag interactablePriceTag in item.m_InteractablePriceTagList)
				{
					interactablePriceTag.SetPriceChecked(false);
				}
				CardData cardData = item.m_StoredCardList[0].m_Card3dUI.m_CardUI.m_CardData;
				item.m_StoredCardList[0].SetIsDisplayedOnShelf(false);
				item.m_StoredCardList[0].SetTargetRotation(Quaternion.identity);
				item.m_StoredCardList.RemoveAt(0);
				item.SetPriceTagCardData((CardData)null);
				item.SetPriceTagVisibility(false);
				if (item.m_CardShelf?.m_ElectronicCardListener != null)
				{
					item.m_CardShelf.m_ElectronicCardListener.UpdateCardUI((CardData)null);
				}
				CPlayerData.AddCard(cardData, 1);
			}
		}

		private static void EmptyCardStorageShelf(InteractableCardStorageShelf interactableCardStorageShelf)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			foreach (CompactCardDataAmount compactCardDataAmount in interactableCardStorageShelf.m_CompactCardDataAmountList)
			{
				CPlayerData.AddCard(CPlayerData.GetCardData(compactCardDataAmount.cardSaveIndex, compactCardDataAmount.expansionType, compactCardDataAmount.isDestiny), compactCardDataAmount.amount);
			}
			interactableCardStorageShelf.m_CompactCardDataAmountList.Clear();
		}

		private static void EmptyBulkDonationBox(InteractableBulkDonationBox interactableBulkDonationBox)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			foreach (CompactCardDataAmount compactCardDataAmount in interactableBulkDonationBox.m_CompactCardDataAmountList)
			{
				CPlayerData.AddCard(CPlayerData.GetCardData(compactCardDataAmount.cardSaveIndex, compactCardDataAmount.expansionType, compactCardDataAmount.isDestiny), compactCardDataAmount.amount);
			}
			interactableBulkDonationBox.m_CompactCardDataAmountList.Clear();
		}

		private void RestockItems()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<EItemType, int> item in itemsToRestock)
			{
				item.Deconstruct(out var key, out var value);
				EItemType val = key;
				int num;
				int num2 = (num = value);
				int maxItemCountInBox = RestockManager.GetMaxItemCountInBox(val, true);
				int num3 = Mathf.CeilToInt((float)num2 / (float)maxItemCountInBox);
				for (int i = 0; i < num3; i++)
				{
					int num4 = ((num >= maxItemCountInBox) ? maxItemCountInBox : num);
					RestockManager.SpawnPackageBoxItem(val, num4, true);
					num -= num4;
				}
			}
		}
	}
	internal class ItemRemovalStrategy : IAssetRemovalStrategy
	{
		[CompilerGenerated]
		private HashSet<EItemType> <items>P;

		private List<Item> removedItems;

		public ItemRemovalStrategy(HashSet<EItemType> items)
		{
			<items>P = items;
			removedItems = new List<Item>();
			base..ctor();
		}

		public RemovalResult RemoveAssets()
		{
			removedItems = new List<Item>();
			RemoveFromShelves();
			RemoveFromPackagingBoxes();
			float totalValue = removedItems.Select((Item i) => RestockManager.GetItemMarketPrice(i.m_ItemType)).Sum();
			foreach (Item removedItem in removedItems)
			{
				CSingleton<ItemSpawnManager>.Instance.m_ItemList.Remove(removedItem);
				Object.Destroy((Object)(object)removedItem);
			}
			return RemovalResult.Success(removedItems.Count, totalValue);
		}

		private void RemoveFromPackagingBoxes()
		{
			//IL_0024: 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)
			foreach (InteractablePackagingBox_Item item in RestockManager.GetItemPackagingBoxList().ToList())
			{
				if (!<items>P.Contains(item.m_ItemType) && !<items>P.Contains(item.m_ItemCompartment.m_ItemType))
				{
					continue;
				}
				if (item.m_IsStored)
				{
					item.m_BoxStoredCompartment.RemoveBox(item);
					if (item.m_BoxStoredCompartment.m_ItemAmount == 0)
					{
						item.m_BoxStoredCompartment.RemoveLabel(false);
					}
				}
				removedItems.AddRange(item.m_ItemCompartment.m_StoredItemList);
				EmptyItemCompartment(item.m_ItemCompartment);
				((InteractableObject)item).OnDestroyed();
			}
		}

		private void RemoveFromShelves()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			foreach (ShelfCompartment item in CSingleton<ShelfManager>.Instance.m_ShelfList.SelectMany((Shelf s) => ((InteractableObject)s).m_ItemCompartmentList))
			{
				if (<items>P.Contains(item.m_ItemType) && item.m_ItemAmount != 0)
				{
					removedItems.AddRange(item.m_StoredItemList);
					EmptyItemCompartment(item);
				}
			}
		}

		private static void EmptyItemCompartment(ShelfCompartment itemCompartment)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			itemCompartment.m_StoredItemList.Clear();
			itemCompartment.m_ItemAmount = 0;
			itemCompartment.m_ItemType = (EItemType)(-1);
			itemCompartment.RemoveLabel(false);
		}
	}
	internal class RemovalResult
	{
		internal bool IsSuccess { get; private set; }

		internal int AssetsRemoved { get; private set; }

		internal float TotalValue { get; private set; }

		internal string ErrorMessage { get; private set; } = string.Empty;


		private RemovalResult()
		{
		}

		internal static RemovalResult Success(int assetsRemoved, float totalValue)
		{
			return new RemovalResult
			{
				IsSuccess = true,
				AssetsRemoved = assetsRemoved,
				TotalValue = totalValue
			};
		}

		internal static RemovalResult Failure(string msg)
		{
			return new RemovalResult
			{
				IsSuccess = false,
				ErrorMessage = msg
			};
		}

		internal static RemovalResult Empty()
		{
			return new RemovalResult
			{
				IsSuccess = true
			};
		}

		internal void Merge(RemovalResult other)
		{
			IsSuccess = IsSuccess && other.IsSuccess;
			AssetsRemoved += other.AssetsRemoved;
			TotalValue += other.TotalValue;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Trading
{
	public class CardTradeManager
	{
		private readonly CardSelectionService cardSelectionService = new CardSelectionService();

		private readonly CardTradePricingService cardTradePricingService = new CardTradePricingService();

		private readonly CardTradeUIManager cardTradeUIManager = new CardTradeUIManager();

		public void SetCustomer(CustomerTradeCardScreen screen, Customer customer, CustomerTradeData customerTradeData)
		{
			CSingleton<CustomerManager>.Instance.m_IsPlayerTrading = true;
			screen.m_CurrentCustomer = customer;
			screen.m_HasAccepted = false;
			screen.m_IsTrading = customerTradeData?.m_IsTrading ?? (Random.Range(0, 100) < Math.Min(40, CPlayerData.m_ShopLevel));
			screen.m_CardData_L = (CardData)((customerTradeData != null) ? ((object)customerTradeData.m_CardData_L) : ((object)cardSelectionService.SelectRandomCard()));
			if (screen.m_IsTrading)
			{
				SetupTradeMode(screen, customerTradeData);
			}
			else
			{
				SetupSellMode(screen, customerTradeData);
			}
			cardTradeUIManager.UpdateUI(screen);
		}

		private void SetupTradeMode(CustomerTradeCardScreen screen, CustomerTradeData customerTradeData)
		{
			screen.m_CardData_R = (CardData)((customerTradeData != null) ? ((object)customerTradeData.m_CardData_R) : ((object)cardSelectionService.SelectPlayerCard(screen.m_CardData_L, customerTradeData)));
			if (screen.m_CardData_R == null)
			{
				screen.m_IsTrading = false;
				SetupSellMode(screen, customerTradeData);
			}
		}

		private void SetupSellMode(CustomerTradeCardScreen screen, CustomerTradeData customerTradeData)
		{
			cardTradePricingService.CalculateAskingPrice(screen, screen.m_CardData_L, customerTradeData);
			if (customerTradeData != null)
			{
				screen.m_PriceSet = customerTradeData.m_PriceSet;
				screen.m_LastPriceSet = customerTradeData.m_LastPriceSet;
			}
			else
			{
				screen.OnInputTextUpdated("0");
			}
		}
	}
	public class CardTradePricingService
	{
		private static readonly (float threshold, float minBonus, float maxBonus)[] PriceTiers = new(float, float, float)[9]
		{
			(10f, 0f, 0.03f),
			(20f, 0f, 0.04f),
			(100f, 0.01f, 0.05f),
			(300f, 0.01f, 0.06f),
			(500f, 0.01f, 0.08f),
			(1000f, 0.01f, 0.1f),
			(2000f, 0.02f, 0.11f),
			(5000f, 0.03f, 0.12f),
			(8000f, 0.03f, 0.12f)
		};

		public void CalculateAskingPrice(CustomerTradeCardScreen screen, CardData customerCard, CustomerTradeData customerTradeData)
		{
			screen.m_SellCardMarketPrice = CPlayerData.GetCardMarketPrice(customerCard);
			if (customerTradeData != null)
			{
				screen.m_SellCardAskPrice = customerTradeData.m_SellCardAskPrice;
				screen.m_MaxDeclineCount = customerTradeData.m_MaxDeclineCount;
				screen.m_DeclineCount = customerTradeData.m_DeclineCount;
			}
			else
			{
				screen.m_SellCardAskPrice = CalculateInitialAskingPrice(screen.m_SellCardMarketPrice);
				screen.m_MaxDeclineCount = Random.Range(0, 5);
				screen.m_DeclineCount = 0;
			}
		}

		private float CalculateInitialAskingPrice(float marketPrice)
		{
			float num = Random.Range(0.7f, 1.2f);
			(float, float, float)[] priceTiers = PriceTiers;
			for (int i = 0; i < priceTiers.Length; i++)
			{
				(float, float, float) tuple = priceTiers[i];
				if (marketPrice > tuple.Item1)
				{
					num += Random.Range(tuple.Item2, tuple.Item3);
				}
			}
			return num * marketPrice;
		}
	}
	public class CardTradeUIManager
	{
		public void UpdateUI(CustomerTradeCardScreen screen)
		{
			SetTradingScreenText(screen);
			UpdateScreenGrpVisibility(screen);
			SetPriceTexts(screen);
			UpdateCardDisplays(screen);
			UpdateButtonVisibility(screen);
		}

		private void SetTradingScreenText(CustomerTradeCardScreen screen)
		{
			List<string> list = (screen.m_IsTrading ? screen.m_CustomerTradeCardTextList : screen.m_CustomerSellCardTextList);
			((TMP_Text)screen.m_CustomerTopText).text = LocalizationManager.GetTranslation("CustomerTrade/" + list[Random.Range(0, list.Count)], true, 0, true, false, (GameObject)null, (string)null, true);
			screen.m_CustomerTopTextAnim.Rewind();
			screen.m_CustomerTopTextAnim.Play();
		}

		private void UpdateScreenGrpVisibility(CustomerTradeCardScreen screen)
		{
			screen.m_CustomerTradingText.SetActive(screen.m_IsTrading);
			screen.m_CustomerSellingText.SetActive(!screen.m_IsTrading);
			screen.m_TradeGrp_R.SetActive(screen.m_IsTrading);
			screen.m_SellGrp_R.SetActive(!screen.m_IsTrading);
		}

		private void SetPriceTexts(CustomerTradeCardScreen screen)
		{
			string translation = LocalizationManager.GetTranslation("Market Price", true, 0, true, false, (GameObject)null, (string)null, true);
			string priceString = GameInstance.GetPriceString(CPlayerData.GetCardMarketPrice(screen.m_CardData_L), false, true, false, "F2");
			string translation2 = LocalizationManager.GetTranslation("Ask Price", true, 0, true, false, (GameObject)null, (string)null, true);
			string priceString2 = GameInstance.GetPriceString(screen.m_SellCardAskPrice, false, true, false, "F2");
			if (screen.m_IsTrading)
			{
				((TMP_Text)screen.m_MarketPrice_L).text = translation + " : " + priceString;
				return;
			}
			((TMP_Text)screen.m_MarketPrice_L).text = translation2 + " : " + priceString2 + "\n" + translation + " : " + priceString;
			screen.m_CardUI_Buying.SetCardUI(screen.m_CardData_L);
		}

		private void UpdateButtonVisibility(CustomerTradeCardScreen screen)
		{
			screen.m_AcceptBtn.SetActive(true);
			screen.m_CancelBtn.SetActive(true);
			screen.m_LetMeThinkBtn.SetActive(true);
			screen.m_DoneBtn.SetActive(false);
		}

		private void UpdateCardDisplays(CustomerTradeCardScreen screen)
		{
			screen.m_IsNewUI.SetActive(CPlayerData.GetCardAmount(screen.m_CardData_L) == 0);
			screen.m_CardUI_L.SetCardUI(screen.m_CardData_L);
			screen.m_CardUI_Album_L.SetCardUI(screen.m_CardData_L);
			((TMP_Text)screen.m_AlbumCardCount_L).text = GetCardCountText(screen.m_CardData_L);
			if (screen.m_IsTrading && screen.m_CardData_R != null)
			{
				screen.m_CardUI_R.SetCardUI(screen.m_CardData_R);
				screen.m_CardUI_Album.SetCardUI(screen.m_CardData_R);
				((TMP_Text)screen.m_AlbumCardCount).text = GetCardCountText(screen.m_CardData_R);
				float cardMarketPrice = CPlayerData.GetCardMarketPrice(screen.m_CardData_R);
				string translation = LocalizationManager.GetTranslation("Market Price", true, 0, true, false, (GameObject)null, (string)null, true);
				((TMP_Text)screen.m_MarketPrice_R).text = translation + " : " + GameInstance.GetPriceString(cardMarketPrice, false, true, false, "F2");
			}
		}

		private string GetCardCountText(CardData card)
		{
			if (card.cardGrade <= 0)
			{
				return "X" + CPlayerData.GetCardAmount(card);
			}
			if (!CPlayerData.HasGradedCardInAlbum(card))
			{
				return "X0";
			}
			return "X1";
		}
	}
}
namespace EnhancedPrefabLoader.Core.TODO
{
	public static class Globals
	{
		public static class CardUI
		{
			public static readonly HashSet<string> TransformsToCache = new HashSet<string>
			{
				"MonsterMask", "CenterFrameMask", "Image", "CardBG", "DescriptionText", "PlayEffectText", "PlayEffectBG", "EvoText", "EvoPreviousStageIcon", "EvoNameText",
				"EvoBasicIcon", "EvoBorder", "CompanyText", "ArtistText", "StatGrp", "EvoBG", "StatText_1", "StatText_2", "StatText_3", "StatText_4",
				"NameTextGrp", "NumberTextGrp", "FirstEditionTextGrp", "CardBorder", "FoilGrp", "GlowMask", "CameraFoilShine (1)", "CameraFoilShine_Glitter", "RarityImage", "RarityText",
				"FirstEditionText", "NumberText", "NameText", "EvoBasicText", "CardFront"
			};

			public const string CardMask = "CardMask";
		}

		public static class Config
		{
			public static class UI
			{
				public static class CollectionBinder
				{
					public const string Category = "CollectionBinderUI";
				}

				public const string Category = "UI";

				public const string ExpansionSpacingX = "ExpansionSpacingX";

				public const string ExpansionSpacingY = "ExpansionSpacingY";

				public const string ExpansionButtonSize = "ExpansionButtonSize";

				public const string RarityButtonSize = "RarityButtonSize";

				public const string RaritySpacingX = "RaritySpacingX";

				public const string RaritySpacingY = "RaritySpacingY";
			}

			public static class GamePlay
			{
				public const string Category = "GamePlay";

				public const string UseCustomExpForBase = "UseCustomExpForBase";
			}
		}

		public static class CacheKeys
		{
			public const string ModID = "ModID";

			public const string ModdedCardUI = "ModdedCardUI";

			public const string CardBacks = "CardBacks";

			public const string OriginalCardBack = "OriginalCardBack";

			public const string TransformStateCache = "TransformStateCache";
		}

		public static class DirectoryPatterns
		{
			public static readonly string SaveDirectory = Application.persistentDataPath + "/PrefabLoader";

			public const string PrefabLoader = "*_prefabloader";

			public const string FilePrefix = "file:///";
		}

		public static class Materials
		{
			public const string ColorProperty = "_Color";

			public static readonly Color DefaultColor = new Color(0.885f, 0.885f, 0.885f, 1f);
		}
	}
}
namespace EnhancedPrefabLoader.Core.Shops
{
	internal class CustomShopScreen : RestockItemScreen, ICustomShopScreen
	{
		private TextMeshProUGUI? pageUrl;

		private Image? pageLogo;

		private Image? pageHeader;

		private Image? pageBackground;

		private Color originalHeaderColor;

		private Color originalBackgroundColor;

		private string displayName = string.Empty;

		private readonly List<string> pageUrls = new List<string>(3) { "cards", "accessories", "figurines" };

		private List<List<RestockData>> pageItems = new List<List<RestockData>>();

		private int currentPageIndex;

		public override void Awake()
		{
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Expected O, but got Unknown
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Expected O, but got Unknown
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Expected O, but got Unknown
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Expected O, but got Unknown
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Expected O, but got Unknown
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Expected O, but got Unknown
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Expected O, but got Unknown
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Expected O, but got Unknown
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Expected O, but got Unknown
			((UIScreenBase)this).m_ScreenGroup = ((Component)((Component)this).transform.Find("ScreenGrp")).gameObject;
			ref RectTransform animGrp = ref ((GenericSliderScreen)this).m_AnimGrp;
			Transform obj = ((UIScreenBase)this).m_ScreenGroup.transform.Find("AnimGrp");
			animGrp = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			((GenericSliderScreen)this).m_VerticalLayoutGrp = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteContent_Grp/ScrollerGrp");
			((GenericSliderScreen)this).m_VerticalLayout = ((Component)((GenericSliderScreen)this).m_VerticalLayoutGrp).GetComponent<VerticalLayoutGroup>();
			((GenericSliderScreen)this).m_SliderGrp = ((Component)((GenericSliderScreen)this).m_VerticalLayoutGrp).gameObject;
			((GenericSliderScreen)this).m_ScrollEndComparer = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("ScrollEndComparer")).gameObject;
			((GenericSliderScreen)this).m_ScrollEndPos = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("ScrollEnd")).gameObject;
			Transform obj2 = ((Component)this).transform.parent.Find("RestockItemAddToCartScreen");
			base.m_RestockItemAddToCartScreen = ((obj2 != null) ? ((Component)obj2).GetComponent<RestockItemAddToCartScreen>() : null);
			Transform obj3 = ((Component)this).transform.parent.Find("RestockItemCheckoutScreen");
			base.m_RestockItemCheckoutScreen = ((obj3 != null) ? ((Component)obj3).GetComponent<RestockItemCheckoutScreen>() : null);
			base.m_SortUIScreen = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("SortingUIScreen")).GetComponent<UIScreenBase>();
			base.m_RestockItemPanelUIList = new List<RestockItemPanelUI>();
			base.m_PageButtonHighlightList = new List<GameObject>(4)
			{
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/PackBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject,
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/AccessoriesBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject,
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/FigurineBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject,
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/AllBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject
			};
			base.m_SortBtnList = (from Transform t in (IEnumerable)((Component)base.m_SortUIScreen).transform.Find("Screen_Grp/AnimGrp/Mask/UIGroup")
				select ((Component)t).GetComponent<ControllerButton>()).ToList();
			Transform val = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar");
			Transform obj4 = val.Find("TotalPriceBG/TotalPrice");
			base.m_TotalCostText = ((obj4 != null) ? ((Component)obj4).GetComponent<TextMeshProUGUI>() : null);
			base.m_CartNotification = ((Component)val.Find("NotificationGrp")).gameObject;
			Transform obj5 = base.m_CartNotification.transform.Find("NotificationText");
			base.m_TotalCartItemCountText = ((obj5 != null) ? ((Component)obj5).GetComponent<TextMeshProUGUI>() : null);
			Button component = ((Component)val.Find("CheckoutBtn/BtnRaycast")).GetComponent<Button>();
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener(new UnityAction(base.OnPressCheckoutButton));
			Button component2 = ((Component)val.Find("PackBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				OnScreenSelection(0);
			});
			Button component3 = ((Component)val.Find("AccessoriesBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component3.onClick = new ButtonClickedEvent();
			((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
			{
				OnScreenSelection(1);
			});
			Button component4 = ((Component)val.Find("FigurineBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component4.onClick = new ButtonClickedEvent();
			((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
			{
				OnScreenSelection(2);
			});
			Button component5 = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("TopWebBar/AddressBar/CloseBtn")).GetComponent<Button>();
			component5.onClick = new ButtonClickedEvent();
			((UnityEvent)component5.onClick).AddListener(new UnityAction(((UIScreenBase)this).CloseScreen));
			Button component6 = ((Component)val.Find("SortBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component6.onClick = new ButtonClickedEvent();
			((UnityEvent)component6.onClick).AddListener(new UnityAction(base.OpenSortScreen));
			Button component7 = ((Component)((Component)base.m_SortUIScreen).transform.Find("Screen_Grp/AnimGrp/CloseButton/ButtonArea")).GetComponent<Button>();
			component7.onClick = new ButtonClickedEvent();
			((UnityEvent)component7.onClick).AddListener(new UnityAction(base.CloseSortScreen));
			foreach (var item in ((IEnumerable)((Component)base.m_SortUIScreen).transform.Find("Screen_Grp/AnimGrp/Mask/UIGroup")).Cast<Transform>().Select((Transform t, int index) => (((Component)t.Find("AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>(), index)))
			{
				var (val2, index2) = item;
				val2.onClick = new ButtonClickedEvent();
				((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
				{
					OnPressSortButton(index2);
				});
			}
			for (int i = 1; i < ((GenericSliderScreen)this).m_VerticalLayoutGrp.childCount; i++)
			{
				Object.Destroy((Object)(object)((Component)((GenericSliderScreen)this).m_VerticalLayoutGrp.GetChild(i)).gameObject);
			}
			base.m_RestockItemPanelUIList.AddRange(from Transform t in (IEnumerable)((GenericSliderScreen)this).m_VerticalLayoutGrp.GetChild(0)
				select ((Component)t).GetComponent<RestockItemPanelUI>());
			((GenericSliderScreen)this).m_ScrollEndPosOffsetYAmount = 0f;
			((GenericSliderScreen)this).m_MaximizePosY = -100f;
			((GenericSliderScreen)this).m_ScrollSpeedMultiplier = 1f;
			((GenericSliderScreen)this).m_GamepadJoystickSpeedMultiplier = 1f;
			((GenericSliderScreen)this).m_MaxPosXClamp = 100000f;
			((GenericSliderScreen)this).m_EvalSliderMaxOnOpen = true;
			((GenericSliderScreen)this).m_ResetScrollPosOnOpen = true;
			((UIScreenBase)this).m_CloseIfScreenOpened = true;
			((RestockItemScreen)this).Awake();
		}

		internal void SwapTo(CustomShopData shopData)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_0104: 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)
			displayName = shopData.AppDisplayName;
			pageItems = new List<List<RestockData>>(3) { shopData.TCG, shopData.Accessories, shopData.Figurines };
			currentPageIndex = 0;
			Transform val = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar");
			if (val != null)
			{
				if (pageLogo == null)
				{
					Transform obj = val.Find("Logo");
					pageLogo = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
				}
				Image? obj2 = pageLogo;
				if (obj2 != null)
				{
					StreamingAssetExtensions.SetSpriteAsync(obj2, shopData.SiteLogo);
				}
				if (pageHeader == null)
				{
					pageHeader = ((Component)val).GetComponent<Image>();
					if ((Object)(object)pageHeader != (Object)null)
					{
						originalHeaderColor = ((Graphic)pageHeader).color;
					}
				}
				Image? obj3 = pageHeader;
				if (obj3 != null)
				{
					StreamingAssetExtensions.SetSpriteAsync(obj3, shopData.SiteHeader);
				}
				if ((Object)(object)pageHeader != (Object)null)
				{
					((Graphic)pageHeader).color = ((shopData.SiteHeader != null) ? Color.white : originalHeaderColor);
				}
			}
			if (pageBackground == null)
			{
				Transform obj4 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("BG");
				pageBackground = ((obj4 != null) ? ((Component)obj4).GetComponent<Image>() : null);
				if ((Object)(object)pageBackground != (Object)null)
				{
					originalBackgroundColor = ((Graphic)pageBackground).color;
				}
			}
			Image? obj5 = pageBackground;
			if (obj5 != null)
			{
				StreamingAssetExtensions.SetSpriteAsync(obj5, shopData.SiteBackground);
			}
			if ((Object)(object)pageBackground != (Object)null)
			{
				((Graphic)pageBackground).color = ((shopData.SiteBackground != null) ? Color.white : originalBackgroundColor);
			}
			if (pageUrl == null)
			{
				Transform obj6 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("TopWebBar/AddressBar/AddressBarWhite/Text");
				pageUrl = ((obj6 != null) ? ((Component)obj6).GetComponent<TextMeshProUGUI>() : null);
			}
			TextMeshProUGUI? obj7 = pageUrl;
			if (obj7 != null)
			{
				((TMP_Text)obj7).text = "www." + displayName.ToLower().Replace(" ", "-") + ".com/shop/" + pageUrls[0];
			}
			((RestockItemScreen)this).EvaluateRestockItemPanelUI(0);
			((GenericSliderScreen)this).m_PosX = 0f;
			((GenericSliderScreen)this).m_LerpPosX = 0f;
		}

		public override void EvaluateRestockItemPanelUI(int _)
		{
			if (pageItems.Count == 0)
			{
				return;
			}
			List<int> sortedItems = GetSortedItems();
			for (int i = 0; i < base.m_RestockItemPanelUIList.Count; i++)
			{
				if (i < sortedItems.Count)
				{
					base.m_RestockItemPanelUIList[i].Init((RestockItemScreen)(object)this, sortedItems[i]);
					((UIElementBase)base.m_RestockItemPanelUIList[i]).SetActive(true);
					((GenericSliderScreen)this).m_ScrollEndPosParent = ((Component)base.m_RestockItemPanelUIList[i]).gameObject;
				}
				else
				{
					((UIElementBase)base.m_RestockItemPanelUIList[i]).SetActive(false);
				}
			}
		}

		internal void InitializeControllerExtension()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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_01c0: Unknown result type (might be due to invalid IL or missing references)
			ControllerScreenUIExtension component = ((Component)this).GetComponent<ControllerScreenUIExtension>();
			if (component == null)
			{
				ModLogger.Warning("Unable to find the Controller script on custom shop. Likely broken due to a base game update.", "InitializeControllerExtension", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Shops\\CustomShopScreen.cs");
				return;
			}
			component.m_ControllerBtnColumnList.Clear();
			component.m_CtrlBtnXChangeMethodList.Clear();
			List<ControllerBtnList> controllerBtnColumnList = component.m_ControllerBtnColumnList;
			ControllerBtnList item = default(ControllerBtnList);
			List<ControllerButton> list = new List<ControllerButton>(1);
			Transform obj = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("TopWebBar");
			list.Add((obj != null) ? ((Component)obj).GetComponent<ControllerButton>() : null);
			item.rowList = list;
			controllerBtnColumnList.Add(item);
			component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			List<ControllerBtnList> controllerBtnColumnList2 = component.m_ControllerBtnColumnList;
			item = default(ControllerBtnList);
			List<ControllerButton> list2 = new List<ControllerButton>(5);
			Transform obj2 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/SortBtn");
			list2.Add((obj2 != null) ? ((Component)obj2).GetComponent<ControllerButton>() : null);
			Transform obj3 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/PackBtn");
			list2.Add((obj3 != null) ? ((Component)obj3).GetComponent<ControllerButton>() : null);
			Transform obj4 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/AccessoriesBtn");
			list2.Add((obj4 != null) ? ((Component)obj4).GetComponent<ControllerButton>() : null);
			Transform obj5 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/FigurineBtn");
			list2.Add((obj5 != null) ? ((Component)obj5).GetComponent<ControllerButton>() : null);
			Transform obj6 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/CheckoutBtn");
			list2.Add((obj6 != null) ? ((Component)obj6).GetComponent<ControllerButton>() : null);
			item.rowList = list2;
			controllerBtnColumnList2.Add(item);
			component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			for (int i = 0; i < base.m_RestockItemPanelUIList.Count; i += 4)
			{
				item = default(ControllerBtnList);
				item.rowList = new List<ControllerButton>();
				ControllerBtnList val = item;
				int num = Mathf.Min(4, base.m_RestockItemPanelUIList.Count - i);
				for (int j = 0; j < num; j++)
				{
					val.rowList.Add(((Component)base.m_RestockItemPanelUIList[i + j]).GetComponent<ControllerButton>());
				}
				component.m_ControllerBtnColumnList.Add(val);
				component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			}
		}

		private void OnScreenSelection(int pageIndex)
		{
			if (pageIndex != currentPageIndex)
			{
				currentPageIndex = pageIndex;
				TextMeshProUGUI? obj = pageUrl;
				if (obj != null)
				{
					((TMP_Text)obj).text = "www." + displayName.ToLower().Replace(" ", "-") + ".com/shop/" + pageUrls[pageIndex];
				}
				((RestockItemScreen)this).EvaluateRestockItemPanelUI(pageIndex);
				((MonoBehaviour)this).StartCoroutine(((GenericSliderScreen)this).EvaluateActiveRestockUIScroller());
				((GenericSliderScreen)this).m_PosX = 0f;
				((GenericSliderScreen)this).m_LerpPosX = 0f;
			}
		}

		private void OnPressSortButton(int index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CPlayerData.m_RestockSortingType = (ERestockSortingType)index;
			((RestockItemScreen)this).EvaluateRestockItemPanelUI(index);
			((MonoBehaviour)this).StartCoroutine(((GenericSliderScreen)this).EvaluateActiveRestockUIScroller());
			((GenericSliderScreen)this).m_PosX = 0f;
			((GenericSliderScreen)this).m_LerpPosX = 0f;
			((RestockItemScreen)this).CloseSortScreen();
		}

		private List<int> GetSortedItems()
		{
			//IL_0070: 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_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_008e: Expected I4, but got Unknown
			int baseItemsCount = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList.Count;
			List<RestockData> currentPageItems = pageItems[currentPageIndex];
			IEnumerable<(ModRestockData, int)> source = from x in EplRuntimeData.Assets.ItemLibrary.RestockEntries.Select((ModRestockData entry, int index) => (entry, index + baseItemsCount))
				where currentPageItems.Contains(x.entry.RestockData)
				select x;
			ERestockSortingType restockSortingType = CPlayerData.m_RestockSortingType;
			return (restockSortingType - 1) switch
			{
				1 => (from x in source
					orderby x.entry.RestockData.licenseShopLevelRequired descending, x.entry.RestockData.name
					select x.index).ToList(), 
				0 => (from x in source
					orderby x.entry.RestockData.licenseShopLevelRequired, x.entry.RestockData.name
					select x.index).ToList(), 
				3 => (from x in source
					orderby GetItemCost(x.entry, x.index) descending, x.entry.RestockData.name
					select x.index).ToList(), 
				2 => (from x in source
					orderby GetItemCost(x.entry, x.index), x.entry.RestockData.name
					select x.index).ToList(), 
				_ => (from x in source
					orderby x.entry.RestockData.licenseShopLevelRequired, x.entry.RestockData.name
					select x.index).ToList(), 
			};
		}

		private float GetItemCost(ModRestockData entry, int index)
		{
			//IL_001a: 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)
			if (!CPlayerData.GetIsItemLicenseUnlocked(index))
			{
				return entry.RestockData.licensePrice;
			}
			return CPlayerData.GetItemCost(entry.RestockData.itemType) * (float)RestockManager.GetMaxItemCountInBox(entry.RestockData.itemType, entry.RestockData.isBigBox);
		}
	}
	internal class ShopInventoryManager
	{
		private bool IsFurnitureLoaded { get; set; }

		private bool IsItemsLoaded { get; set; }

		private bool IsDecoLoaded { get; set; }

		internal List<EItemType> CustomShopTcgItems { get; } = new List<EItemType>();


		internal List<EItemType> CustomShopAccessoryItems { get; } = new List<EItemType>();


		internal List<EItemType> CustomShopFigurineItems { get; } = new List<EItemType>();


		internal List<EItemType> CustomShopBoardGameItems { get; } = new List<EItemType>();


		internal void PopulateAllShopInventories()
		{
			AddFurnitureToInventory();
			AddItemsToInventory();
			AddDecoToInventory();
		}

		private void AddFurnitureToInventory()
		{
			if (IsFurnitureLoaded)
			{
				return;
			}
			if (EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.Count == 0)
			{
				ModLogger.Debug("No furniture to add to shop", "AddFurnitureToInventory", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
				IsFurnitureLoaded = true;
				return;
			}
			foreach (ModFurniturePurchaseData value in EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.Values)
			{
				for (int i = 0; i < CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FurniturePurchaseDataList.Count; i++)
				{
					if (CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FurniturePurchaseDataList[i].levelRequirement > value.BaseFurniturePurchaseData.levelRequirement)
					{
						CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FurniturePurchaseDataList.Insert(i, value.BaseFurniturePurchaseData);
						CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_ObjectDataList.Insert(i, value.BaseObjectData);
						break;
					}
				}
			}
			IsFurnitureLoaded = true;
		}

		internal void AddItemsToInventory()
		{
			//IL_0133: 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_015c: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (IsItemsLoaded)
			{
				return;
			}
			if (EplRuntimeData.Assets.ItemLibrary.ItemData.Count == 0)
			{
				ModLogger.Debug("No items to add to shop", "AddItemsToInventory", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
				IsItemsLoaded = true;
				return;
			}
			foreach (ModRestockData restockEntry in EplRuntimeData.Assets.ItemLibrary.RestockEntries)
			{
				if (!string.IsNullOrWhiteSpace(restockEntry.PhoneAppId) && EplRuntimeData.Assets.ShopLibrary.CustomShops.ContainsKey(restockEntry.PhoneAppId))
				{
					if ((restockEntry.ItemFlags & ItemFlags.Accessory) != 0)
					{
						CustomShopAccessoryItems.Add(restockEntry.RestockData.itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.BoardGame) != 0)
					{
						CustomShopBoardGameItems.Add(restockEntry.RestockData.itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.Figurine) != 0)
					{
						CustomShopFigurineItems.Add(restockEntry.RestockData.itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.TCG) != 0)
					{
						CustomShopTcgItems.Add(restockEntry.RestockData.itemType);
					}
				}
				else
				{
					if ((restockEntry.ItemFlags & ItemFlags.Accessory) != 0)
					{
						CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownAccessoryItemType.Add(restockEntry.RestockData.itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.BoardGame) != 0)
					{
						CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownBoardGameItemType.Add(restockEntry.RestockData.itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.Figurine) != 0)
					{
						CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownFigurineItemType.Add(restockEntry.RestockData.itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.TCG) != 0)
					{
						CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ShownItemType.Add(restockEntry.RestockData.itemType);
					}
				}
			}
			IsItemsLoaded = true;
		}

		private void AddDecoToInventory()
		{
			//IL_00a6: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Invalid comparison between Unknown and I4
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Invalid comparison between Unknown and I4
			//IL_00b0: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			if (IsDecoLoaded)
			{
				return;
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count == 0)
			{
				ModLogger.Debug("No deco objects to add to shop", "AddDecoToInventory", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (KeyValuePair<EDecoObject, ModDecoData> decoObjectDatum in EplRuntimeData.Assets.DecoLibrary.DecoObjectData)
				{
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_DecoPurchaseDataList.Add(decoObjectDatum.Value.BasePurchaseData);
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_DecoDataList.Add(decoObjectDatum.Value.BaseDecoData);
					EDecoType decoType = decoObjectDatum.Value.BaseDecoData.decoType;
					if ((int)decoType != 1 && (int)decoType != 0)
					{
						CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_OtherDecoList.Add(decoObjectDatum.Key);
					}
					if ((int)decoObjectDatum.Value.BaseDecoData.decoType == 1)
					{
						CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_PosterDecoList.Add(decoObjectDatum.Key);
					}
				}
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData.Count == 0)
			{
				ModLogger.Debug("No wall textures to add to shop", "AddDecoToInventory", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (ModShopDecoData decoWallTextureDatum in EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData)
				{
					DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
					int valueOrDefault = decoLibrary.firstInsertedWallTexture.GetValueOrDefault();
					if (!decoLibrary.firstInsertedWallTexture.HasValue)
					{
						valueOrDefault = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_WallDecoDataList.Count;
						decoLibrary.firstInsertedWallTexture = valueOrDefault;
					}
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_WallDecoDataList.Add(decoWallTextureDatum.ShopDecoData);
				}
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData.Count == 0)
			{
				ModLogger.Debug("No floor textures to add to shop", "AddDecoToInventory", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (ModShopDecoData decoFloorTextureDatum in EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData)
				{
					DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
					int valueOrDefault = decoLibrary.firstInsertedFloorTexture.GetValueOrDefault();
					if (!decoLibrary.firstInsertedFloorTexture.HasValue)
					{
						valueOrDefault = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FloorDecoDataList.Count;
						decoLibrary.firstInsertedFloorTexture = valueOrDefault;
					}
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FloorDecoDataList.Add(decoFloorTextureDatum.ShopDecoData);
				}
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData.Count == 0)
			{
				ModLogger.Debug("No ceiling textures to add to shop", "AddDecoToInventory", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (ModShopDecoData decoCeilingTextureDatum in EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData)
				{
					DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
					int valueOrDefault = decoLibrary.firstInsertedCeilingTexture.GetValueOrDefault();
					if (!decoLibrary.firstInsertedCeilingTexture.HasValue)
					{
						valueOrDefault = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_CeilingDecoDataList.Count;
						decoLibrary.firstInsertedCeilingTexture = valueOrDefault;
					}
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_CeilingDecoDataList.Add(decoCeilingTextureDatum.ShopDecoData);
				}
			}
			IsDecoLoaded = true;
		}

		internal List<EItemType> GetCustomShopItemsForCheckPricePage(int pageIndex)
		{
			switch (pageIndex)
			{
			case 0:
				return CustomShopTcgItems;
			case 1:
				return CustomShopAccessoryItems;
			case 2:
				return CustomShopFigurineItems;
			case 4:
				return CustomShopBoardGameItems.Where((EItemType t) => (int)t != -1).ToList();
			case 3:
			{
				List<EItemType> list = new List<EItemType>();
				list.AddRange(CustomShopTcgItems);
				list.AddRange(CustomShopAccessoryItems);
				list.AddRange(CustomShopFigurineItems);
				list.AddRange(CustomShopBoardGameItems.Where((EItemType t) => (int)t != -1));
				return list;
			}
			default:
				return new List<EItemType>();
			}
		}

		internal int GetBaseGameItemCountForCheckPricePage(int pageIndex)
		{
			StockItemData_ScriptableObject stockItemData_SO = CSingleton<InventoryBase>.Instance.m_StockItemData_SO;
			return pageIndex switch
			{
				0 => stockItemData_SO.m_ShownItemType.Count, 
				1 => stockItemData_SO.m_ShownAccessoryItemType.Count, 
				2 => stockItemData_SO.m_ShownFigurineItemType.Count, 
				4 => stockItemData_SO.m_ShownBoardGameItemType.Count((EItemType t) => (int)t != -1), 
				3 => stockItemData_SO.m_ShownItemType.Count + stockItemData_SO.m_ShownAccessoryItemType.Count + stockItemData_SO.m_ShownFigurineItemType.Count + stockItemData_SO.m_ShownBoardGameItemType.Count((EItemType t) => (int)t != -1), 
				_ => 0, 
			};
		}
	}
}
namespace EnhancedPrefabLoader.Core.Services
{
	internal class CardExpansionService : ICardExpansionService
	{
		public void SetCardPriceGenerator(ECardExpansionType expansionType, ICardPriceGenerator generator)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{expansionType} is not a registered card expansion.");
			}
			value.CardPriceGenerator = generator;
		}

		public void SetCardExpGenerator(ECardExpansionType expansionType, ICardExpGenerator generator)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{expansionType} is not a registered card expansion.");
			}
			value.CardExpGenerator = generator;
		}

		public float GenerateCardMarketPrice(ECardExpansionType cardExpansionType, EMonsterType monsterType, bool isFoil)
		{
			//IL_000f: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_006f: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardExpansionType} is not a registered card expansion.");
			}
			if (!value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				throw new ArgumentException($"{monsterType} is not a registered card in expansion {cardExpansionType}.");
			}
			return value.CardPriceGenerator.GenerateCardMarketPrice(cardExpansionType, monsterType, value2.BorderType, value2.MonsterData.Rarity, value.Rarities, isFoil);
		}

		public float GenerateCardMarketPrice(CardData cardData)
		{
			//IL_0010: 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_0024: 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_0081: 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_0092: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardData.expansionType} is not a registered card expansion.");
			}
			if (!value.Cards.TryGetValue(cardData.monsterType, out ModCardData value2))
			{
				throw new ArgumentException($"{cardData.monsterType} is not a registered card in expansion {cardData.expansionType}.");
			}
			return value.CardPriceGenerator.GenerateCardMarketPrice(cardData.expansionType, cardData.monsterType, value2.BorderType, value2.MonsterData.Rarity, value.Rarities, cardData.isFoil);
		}

		public float GenerateCardExp(CardData cardData)
		{
			//IL_0010: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardData.expansionType} is not a registered card expansion.");
			}
			return value.CardExpGenerator.CalculateExp(cardData);
		}
	}
	internal class CardUIService : ICardUIService
	{
		private readonly ConditionalWeakTable<CardUI, ModdedCardUI> moddedCardUIs = new ConditionalWeakTable<CardUI, ModdedCardUI>();

		private readonly Sprite? cardMask;

		internal CardUIService()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = Resources.CardMask;
			if (array != null && array.Length != 0)
			{
				Texture2D val = new Texture2D(2, 2);
				ImageConversion.LoadImage(val, array);
				((Object)val).name = "CardMask";
				cardMask = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
		}

		internal void SetDirty(CardUI cardUI)
		{
			if (moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI value))
			{
				value.IsDirty = true;
			}
		}

		internal void SetModdedCardUI(CardUI cardUI)
		{
			if (!moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI _))
			{
				ModdedCardUI moddedCardUI = ((Component)cardUI).gameObject.AddComponent<ModdedCardUI>();
				moddedCardUI.Initialize(cardUI);
				moddedCardUIs.Add(cardUI, moddedCardUI);
			}
		}

		internal void ApplyCardUIChanges(CardUI cardUI, CardData cardData, ModCardExpansionData expansion)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			SetCardBack(cardUI, cardData, expansion);
			if (moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI value))
			{
				StreamingAsset<Sprite> cardFoilMask = expansion.Cards[cardData.monsterType].FoilMask ?? expansion.FoilMask;
				value.ApplyModdedCardSpecs(cardMask, cardFoilMask);
				((Component)value).gameObject.SetActive(false);
				((Component)value).gameObject.SetActive(true);
			}
		}

		internal void RestoreOriginalState(CardUI cardUI, CardData cardData)
		{
			RestoreCardBack(cardUI);
			if (moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI value))
			{
				value.RestoreDefaults(cardData);
			}
		}

		public void ApplyEplCardUI(CardUI cardUI, CardData cardData)
		{
			//IL_0010: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardData.expansionType} is not a registered EPL expansion.");
			}
			SetModdedCardUI(cardUI);
			ApplyCardUIChanges(cardUI, cardData, value);
		}

		public void RestoreOriginalCardUI(CardUI cardUI, CardData cardData)
		{
			RestoreOriginalState(cardUI, cardData);
		}

		private void SetCardBack(CardUI cardUI, CardData cardData, ModCardExpansionData expansion)
		{
			//IL_005a: 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)
			Card3dUIGroup card3dUIGroup = cardUI.m_Card3dUIGroup;
			Renderer renderer = ((card3dUIGroup != null) ? card3dUIGroup.m_CardBackMesh.GetComponent<Renderer>() : null);
			if (renderer != null)
			{
				EplCaches caches = EplRuntimeData.Caches;
				if (caches.OriginalCardBackMaterial == null)
				{
					Material val = (caches.OriginalCardBackMaterial = renderer.material);
				}
				ModCardData modCardData = expansion.Cards[cardData.monsterType];
				StreamingAsset<Texture> cardback = modCardData.Cardback ?? expansion.CardBack;
				string key = ((modCardData.Cardback == null) ? expansion.Name : $"{expansion.Name}_{modCardData.MonsterData.MonsterType}");
				Material orAdd = EplRuntimeData.Caches.CardBackMaterials.GetOrAdd<string, Material>(key, delegate
				{
					//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_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Expected O, but got Unknown
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_0043: Expected O, but got Unknown
					//IL_0044: Expected O, but got Unknown
					Material val2 = new Material(renderer.material);
					val2.CopyPropertiesFromMaterial(renderer.material);
					StreamingAssetExtensions.SetTextureAsync(val2, "_BaseMap", cardback);
					StreamingAssetExtensions.SetTextureAsync(val2, "_EmissionMap", cardback);
					return val2;
				});
				renderer.material = orAdd;
			}
		}

		private void RestoreCardBack(CardUI cardUI)
		{
			Card3dUIGroup card3dUIGroup = cardUI.m_Card3dUIGroup;
			object obj;
			if (card3dUIGroup == null)
			{
				obj = null;
			}
			else
			{
				GameObject cardBackMesh = card3dUIGroup.m_CardBackMesh;
				obj = ((cardBackMesh != null) ? cardBackMesh.GetComponent<Renderer>() : null);
			}
			Renderer val = (Renderer)obj;
			if (val != null && EplRuntimeData.Caches.OriginalCardBackMaterial != null)
			{
				val.material = EplRuntimeData.Caches.OriginalCardBackMaterial;
			}
		}
	}
	internal class DecoService : IDecoService
	{
		public void SetLevelRequirement(EDecoObject decoObject, int level)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				throw new ArgumentException($"{decoObject} is not a registered decoration object.");
			}
			value.BasePurchaseData.levelRequirement = level;
		}
	}
	internal class EplServices : IEplServices
	{
		public IItemService ItemService => (IItemService)(object)itemService;

		public ICardExpansionService CardExpansionService => (ICardExpansionService)(object)cardExpansionService;

		public ICardUIService CardUIService => (ICardUIService)(object)cardUIService;

		public IMenuService MenuService => (IMenuService)(object)menuService;

		public IFurnitureService FurnitureService => (IFurnitureService)(object)furnitureService;

		public IDecoService DecoService => (IDecoService)(object)decoService;

		internal MenuService menuService { get; private set; } = new MenuService();


		internal CardExpansionService cardExpansionService { get; private set; } = new CardExpansionService();


		internal ItemService itemService { get; private set; } = new ItemService();


		internal SaveDataService SaveDataManager { get; private set; }

		internal BundleManager BundleManager { get; private set; }

		internal StreamingAssetService StreamingAssetService { get; private set; }

		internal ShopService ShopService { get; private set; }

		internal ShopInventoryManager ShopInventoryManager { get; private set; }

		internal CardUIService cardUIService { get; private set; }

		internal FurnitureService furnitureService { get; private set; }

		internal DecoService decoService { get; private set; }

		internal CollectionBinderService CollectionBinderService { get; private set; }

		internal CardExpansionSelectService CardExpansionSelectService { get; private set; }

		internal CardRaritySelectService CardRaritySelectService { get; private set; }

		internal WorkerPackOpenerScreenService WorkerPackOpenerScreenService { get; private set; }

		internal CardTradeManager CardTradeManager { get; private set; }

		internal SettingsScreenService SettingsScreenService { get; private set; }

		public EplServices(SaveDataService saveDataManager)
		{
			SaveDataManager = saveDataManager;
			BundleManager = new BundleManager();
			StreamingAssetService = new StreamingAssetService();
			ShopService = new ShopService();
			ShopInventoryManager = new ShopInventoryManager();
			cardUIService = new CardUIService();
			furnitureService = new FurnitureService();
			decoService = new DecoService();
			CollectionBinderService = new CollectionBinderService();
			CardExpansionSelectService = new CardExpansionSelectService();
			CardRaritySelectService = new CardRaritySelectService();
			WorkerPackOpenerScreenService = new WorkerPackOpenerScreenService();
			CardTradeManager = new CardTradeManager();
			SettingsScreenService = new SettingsScreenService();
			base..ctor();
		}
	}
	internal class FurnitureService : IFurnitureService
	{
		public void SetLevelRequirement(EObjectType objectType, int level)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				throw new ArgumentException($"{objectType} is not a registered furniture object.");
			}
			value.BaseFurniturePurchaseData.levelRequirement = level;
		}
	}
	internal class ItemService : IItemService
	{
		public void SetPackGenerator(EItemType pack, IPackGenerator generator)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.PackGenerator = generator;
		}

		public void SetNormalGenerationWeight(EItemType pack, ERarity rarity, float weight)
		{
			//IL_000f: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			if (value.NormalGenerationWeights.Count != 0)
			{
				value.NormalGenerationWeights[rarity] = weight;
			}
		}

		public void SetGodGenerationWeight(EItemType pack, ERarity rarity, float weight)
		{
			//IL_000f: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			if (value.GodGenerationWeights.Count != 0)
			{
				value.GodGenerationWeights[rarity] = weight;
			}
		}

		public void SetSlotWeight(EItemType pack, PackSlot slot, ERarity rarity, float weight)
		{
			//IL_000f: 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_001e: 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)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			if (value.PackSlotWeights.TryGetValue(slot, out Dictionary<ERarity, float> value2))
			{
				value2[rarity] = weight;
			}
		}

		public void SetItemPriceGenerator(string bundleId, IItemPriceGenerator generator)
		{
			EplRuntimeData.Assets.ItemLibrary.ItemPriceGenerators[bundleId] = generator;
		}

		public List<CardData> GeneratePackContent(EItemType pack)
		{
			//IL_000f: 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_0052: 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_0058: 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_0065: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"Type {pack} is not a valid pack.");
			}
			bool flag = value.CanHaveGodPack && Random.value < value.GodPackPercentage;
			EplRuntimeData.Events.ItemEvents.FireBeforePackGenerated(new PackGenerationEventArgs
			{
				Pack = pack,
				IsGodPack = flag,
				NormalWeights = ((value.NormalGenerationWeights.Count > 0) ? value.NormalGenerationWeights : null),
				GodWeights = ((value.GodGenerationWeights.Count > 0) ? value.GodGenerationWeights : null),
				SlotWeights = ((value.PackSlotWeights.Count > 0) ? value.PackSlotWeights : null)
			});
			object obj = (flag ? ((object)value.GodPackGenerator) : ((object)value.PackGenerator));
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(value.Expansion, out ModCardExpansionData value2))
			{
				throw new InvalidOperationException($"Unable to find expansion data for {value.Expansion}");
			}
			List<MonsterData> list = value2.Cards.Select<KeyValuePair<EMonsterType, ModCardData>, MonsterData>((KeyValuePair<EMonsterType, ModCardData> kvp) => kvp.Value.MonsterData).ToList();
			List<MonsterData> list2 = ((IPackGenerator)obj).GeneratePack(value.Expansion, list, value2.HasRandomFoils);
			EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(value.Expansion, out CardExpansionSaveData data);
			List<CardData> list3 = new List<CardData>();
			foreach (MonsterData item in list2)
			{
				CardData val = value2.Cards[item.MonsterType];
				if (value2.HasRandomFoils)
				{
					val.isFoil = flag || Random.value < value2.FoilChance;
				}
				if (data != null)
				{
					int num = item.MonsterType - 1;
					if (value2.HasRandomFoils)
					{
						num = num * 2 + (val.isFoil ? 1 : 0);
					}
					val.isNew = data.CardCountList[num] == 0;
				}
				list3.Add(val);
			}
			return list3;
		}

		public float GenerateItemCost(EItemType itemType)
		{
			//IL_0000: 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_0049: Invalid comparison between Unknown and I4
			//IL_0072: 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)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			string bundleIdFor = EplRuntimeData.Assets.BundleRegistry.GetBundleIdFor<EItemType>(itemType);
			if (bundleIdFor != null && EplRuntimeData.Assets.ItemLibrary.ItemPriceGenerators.TryGetValue(bundleIdFor, out IItemPriceGenerator value))
			{
				return value.GenerateItemCost(itemType, itemData.baseCost);
			}
			if ((int)itemData.boxFollowItemPrice == -1)
			{
				return itemData.baseCost * Mathf.Clamp(Random.Range(0.9f, 1.3f), 1f, 1.3f);
			}
			return CPlayerData.GetItemCost(itemData.boxFollowItemPrice) * 8f * Mathf.Clamp(Random.Range(0.9f, 1.2f), 1f, 1.15f);
		}

		public float GenerateItemMarketPrice(EItemType itemType, float costPrice, float minMarkup, float maxMarkup)
		{
			//IL_0000: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			//IL_005a: 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)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			string bundleIdFor = EplRuntimeData.Assets.BundleRegistry.GetBundleIdFor<EItemType>(itemType);
			if (bundleIdFor != null && EplRuntimeData.Assets.ItemLibrary.ItemPriceGenerators.TryGetValue(bundleIdFor, out IItemPriceGenerator value))
			{
				return value.GenerateItemMarketPrice(itemType, itemData.baseCost, minMarkup, maxMarkup);
			}
			if ((int)itemData.boxFollowItemPrice == -1)
			{
				return costPrice * Random.Range(minMarkup, maxMarkup);
			}
			return CPlayerData.GetItemMarketPrice(itemData.boxFollowItemPrice) * 8f * Random.Range(minMarkup, maxMarkup);
		}

		internal float GenerateItemMarketPrice(int index, float costPrice)
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			EItemType val = ItemTypeResolver.Resolve(index);
			ItemData itemData = InventoryBase.GetItemData(val);
			float num = itemData.marketPriceMinPercent;
			float maxMarkup = itemData.marketPriceMaxPercent;
			if (num == 0f)
			{
				num = 1.5f;
				maxMarkup = 3f;
			}
			return GenerateItemMarketPrice(val, costPrice, num, maxMarkup);
		}

		public void SetGodPackPercentage(EItemType pack, float percentage)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.GodPackPercentage = percentage;
		}

		public void SetGodPack(EItemType pack, bool enabled, float percentage)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.CanHaveGodPack = enabled;
			value.GodPackPercentage = percentage;
		}

		public void SetCanHaveGodPacks(EItemType pack, bool enabled)
		{
			//IL_000f: 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)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.CanHaveGodPack = enabled;
		}

		public void SetFollowItemPrice(EItemType itemType, EItemType sourceItemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			ItemData itemData2 = InventoryBase.GetItemData(sourceItemType);
			itemData.baseCost = itemData2.baseCost;
			itemData.marketPriceMinPercent = itemData2.marketPriceMinPercent;
			itemData.marketPriceMaxPercent = itemData2.marketPriceMaxPercent;
		}

		public void SetMarketPricePercent(EItemType itemType, float min, float max)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			itemData.marketPriceMinPercent = min;
			itemData.marketPriceMaxPercent = max;
		}

		public void SetAutoBoxPrice(EItemType itemType, EItemType followItemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			InventoryBase.GetItemData(itemType).boxFollowItemPrice = followItemType;
		}

		public void SetLicensePrice(EItemType itemType, bool isBigBox, float price)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			foreach (ModRestockData restockEntry in EplRuntimeData.Assets.ItemLibrary.RestockEntries)
			{
				if (restockEntry.RestockData.itemType == itemType && restockEntry.RestockData.isBigBox == isBigBox)
				{
					restockEntry.RestockData.licensePrice = price;
					break;
				}
			}
		}

		public void SetLicenseLevel(EItemType itemType, bool isBigBox, int level)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			foreach (ModRestockData restockEntry in EplRuntimeData.Assets.ItemLibrary.RestockEntries)
			{
				if (restockEntry.RestockData.itemType == itemType && restockEntry.RestockData.isBigBox == isBigBox)
				{
					restockEntry.RestockData.licenseShopLevelRequired = level;
					break;
				}
			}
		}

		internal float GenerateItemCost(int index)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			EItemType itemType = ItemTypeResolver.Resolve(index);
			return GenerateItemCost(itemType);
		}
	}
	internal class MenuService : IMenuService
	{
		internal List<NestedMenu.MenuEntry> GenericExpansionEntries { get; } = new List<NestedMenu.MenuEntry>();


		internal List<NestedMenu.MenuEntry> BinderExpansionEntries { get; } = new List<NestedMenu.MenuEntry>();


		public void AddGenericExpansionButton(string label, Action onClick)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Action onClick2 = onClick;
			GenericExpansionEntries.Add(new NestedMenu.MenuEntry
			{
				Label = label,
				OnClick = (UnityAction)delegate
				{
					onClick2();
				}
			});
		}

		public void AddBinderExpansionButton(string label, Action onClick)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Action onClick2 = onClick;
			BinderExpansionEntries.Add(new NestedMenu.MenuEntry
			{
				Label = label,
				OnClick = (UnityAction)delegate
				{
					onClick2();
				}
			});
		}
	}
}
namespace EnhancedPrefabLoader.Core.Services.Internal
{
	internal class BundleMaintenanceService
	{
		internal bool ResetPricesFor(string bundleId)
		{
			//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_002c: 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_007a: 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)
			BundleAssetTracker bundleAssetTracker = EplRuntimeData.BundleAssetTracker;
			SaveDataService saveDataManager = EplRuntimeData.Services.SaveDataManager;
			int num = 0;
			foreach (EItemType item in bundleAssetTracker.GetEnumValuesForBundle<EItemType>(bundleId))
			{
				if (saveDataManager.TryGetSaveData<EItemType, ItemSaveData>(item, out ItemSaveData data))
				{
					IPriceResettable priceResettable = data;
					if (priceResettable != null)
					{
						priceResettable.ResetPrices();
						num++;
					}
				}
			}
			foreach (ECardExpansionType item2 in bundleAssetTracker.GetEnumValuesForBundle<ECardExpansionType>(bundleId))
			{
				if (saveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(item2, out CardExpansionSaveData data2))
				{
					IPriceResettable priceResettable2 = data2;
					if (priceResettable2 != null)
					{
						priceResettable2.ResetPrices();
						num++;
					}
				}
			}
			if (num > 0)
			{
				CSingleton<RestockManager>.Instance.Init();
				ModLogger.Info($"Reset prices for {num} assets in bundle '{bundleId}'", "ResetPricesFor", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\BundleMaintenanceService.cs");
			}
			return num > 0;
		}

		internal RemovalResult UninstallBundle(string bundleId)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			if (!CanCurrentlyUninstall())
			{
				return RemovalResult.Failure("Cannot uninstall until end of day or while pack openers are running.");
			}
			BundleAssetTracker bundleAssetTracker = EplRuntimeData.BundleAssetTracker;
			HashSet<ECardExpansionType> enumValuesForBundle = bundleAssetTracker.GetEnumValuesForBundle<ECardExpansionType>(bundleId);
			HashSet<EItemType> enumValuesForBundle2 = bundleAssetTracker.GetEnumValuesForBundle<EItemType>(bundleId);
			HashSet<EObjectType> enumValuesForBundle3 = bundleAssetTracker.GetEnumValuesForBundle<EObjectType>(bundleId);
			HashSet<EDecoObject> enumValuesForBundle4 = bundleAssetTracker.GetEnumValuesForBundle<EDecoObject>(bundleId);
			List<IAssetRemovalStrategy> obj = new List<IAssetRemovalStrategy>(4)
			{
				new CardRemovalStrategy(enumValuesForBundle),
				new ItemRemovalStrategy(enumValuesForBundle2),
				new DecoRemovalStrategy(enumValuesForBundle4, bundleId),
				new InteractableObjectRemovalStrategy(enumValuesForBundle3, enumValuesForBundle4)
			};
			RemovalResult removalResult = RemovalResult.Empty();
			foreach (IAssetRemovalStrategy item in obj)
			{
				try
				{
					removalResult.Merge(item.RemoveAssets());
				}
				catch (Exception ex)
				{
					ModLogger.Error("Error during uninstall strategy " + item.GetType().Name + ": " + ex.Message, "UninstallBundle", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\BundleMaintenanceService.cs");
					removalResult.Merge(RemovalResult.Failure(ex.Message));
				}
			}
			CleanupPackageBoxSaveData(enumValuesForBundle2);
			ResetExpansionSelections(enumValuesForBundle);
			if (removalResult.IsSuccess)
			{
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddCoin(removalResult.TotalValue / 2f, false));
				ModLogger.Info($"Uninstalled bundle '{bundleId}': removed {removalResult.AssetsRemoved} assets, refunded {removalResult.TotalValue / 2f:F2} coins", "UninstallBundle", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\BundleMaintenanceService.cs");
			}
			return removalResult;
		}

		private static void CleanupPackageBoxSaveData(HashSet<EItemType> itemTypes)
		{
			HashSet<EItemType> itemTypes2 = itemTypes;
			CPlayerData.m_PackageBoxItemSaveDataList.RemoveAll((PackageBoxItemaveData box) => itemTypes2.Contains(box.itemTypeAmount.itemType) || EplRuntimeData.BundleAssetTracker.GetBundleIdFor<EItemType>(box.itemTypeAmount.itemType) != null);
		}

		private static void ResetExpansionSelections(HashSet<ECardExpansionType> expansions)
		{
			//IL_0001: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			if (expansions.Contains(CPlayerData.m_QuickFillCardExpansionType))
			{
				CPlayerData.m_QuickFillCardExpansionType = (ECardExpansionType)0;
			}
			if (expansions.Contains(CPlayerData.m_DonationQuickFillCardExpansionType))
			{
				CPlayerData.m_DonationQuickFillCardExpansionType = (ECardExpansionType)0;
			}
			if (expansions.Contains(CPlayerData.m_WorkbenchCardExpansionType))
			{
				CPlayerData.m_WorkbenchCardExpansionType = (ECardExpansionType)0;
			}
		}

		private bool CanCurrentlyUninstall()
		{
			bool num = CSingleton<ShelfManager>.Instance.m_AutoPackOpenerList.Any((InteractableAutoPackOpener p) => p.m_IsProcessing);
			bool flag = CSingleton<LightManager>.Instance.m_TimeHour == 21;
			return !num && flag;
		}
	}
	internal class CardExpansionSelectService
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__10_3;

			public static UnityAction <>9__10_4;

			public static UnityAction <>9__10_5;

			public static Func<KeyValuePair<ECardExpansionType, ModCardExpansionData>, string> <>9__10_0;

			public static Func<KeyValuePair<ECardExpansionType, ModCardExpansionData>, NestedMenu.MenuEntry> <>9__10_6;

			public static Func<KeyValuePair<ECardExpansionType, ModCardExpansionData>, NestedMenu.MenuEntry> <>9__10_8;

			public static Func<IGrouping<string, KeyValuePair<ECardExpansionType, ModCardExpansionData>>, IEnumerable<NestedMenu.MenuEntry>> <>9__10_1;

			public static Func<IEnumerable<NestedMenu.MenuEntry>, IEnumerable<NestedMenu.MenuEntry>> <>9__10_2;

			internal void <PopulateMainMenu>b__10_3()
			{
				CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton(0);
			}

			internal void <PopulateMainMenu>b__10_4()
			{
				CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton(1);
			}

			internal void <PopulateMainMenu>b__10_5()
			{
				CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton(2);
			}

			internal string <PopulateMainMenu>b__10_0(KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp)
			{
				return kvp.Value.MenuCategory;
			}

			internal IEnumerable<NestedMenu.MenuEntry> <PopulateMainMenu>b__10_1(IGrouping<string, KeyValuePair<ECardExpansionType, ModCardExpansionData>> group)
			{
				if (!string.IsNullOrWhiteSpace(group.Key))
				{
					return new <>z__ReadOnlySingleElementList<NestedMenu.MenuEntry>(new NestedMenu.MenuEntry
					{
						Label = group.Key,
						SubMenu = group.Select(delegate(KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp)
						{
							//IL_0030: Unknown result type (might be due to invalid IL or missing references)
							//IL_003a: Expected O, but got Unknown
							<>c__DisplayClass10_1 CS$<>8__locals1 = new <>c__DisplayClass10_1
							{
								kvp = kvp
							};
							return new NestedMenu.MenuEntry
							{
								Label = CS$<>8__locals1.kvp.Value.Name,
								OnClick = (UnityAction)delegate
								{
									//IL_000b: Unknown result type (might be due to invalid IL or missing references)
									//IL_0015: Expected I4, but got Unknown
									CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)CS$<>8__locals1.kvp.Key);
								}
							};
						}).ToList()
					});
				}
				return group.Select(delegate(KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp)
				{
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_003a: Expected O, but got Unknown
					<>c__DisplayClass10_0 CS$<>8__locals0 = new <>c__DisplayClass10_0
					{
						kvp = kvp
					};
					return new NestedMenu.MenuEntry
					{
						Label = CS$<>8__locals0.kvp.Value.Name,
						OnClick = (UnityAction)delegate
						{
							//IL_000b: Unknown result type (might be due to invalid IL or missing references)
							//IL_0015: Expected I4, but got Unknown
							CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)CS$<>8__locals0.kvp.Key);
						}
					};
				});
			}

			internal NestedMenu.MenuEntry <PopulateMainMenu>b__10_6(KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Expected O, but got Unknown
				<>c__DisplayClass10_0 CS$<>8__locals0 = new <>c__DisplayClass10_0
				{
					kvp = kvp
				};
				return new NestedMenu.MenuEntry
				{
					Label = CS$<>8__locals0.kvp.Value.Name,
					OnClick = (UnityAction)delegate
					{
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0015: Expected I4, but got Unknown
						CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)CS$<>8__locals0.kvp.Key);
					}
				};
			}

			internal NestedMenu.MenuEntry <PopulateMainMenu>b__10_8(KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Expected O, but got Unknown
				<>c__DisplayClass10_1 CS$<>8__locals0 = new <>c__DisplayClass10_1
				{
					kvp = kvp
				};
				return new NestedMenu.MenuEntry
				{
					Label = CS$<>8__locals0.kvp.Value.Name,
					OnClick = (UnityAction)delegate
					{
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0015: Expected I4, but got Unknown
						CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)CS$<>8__locals0.kvp.Key);
					}
				};
			}

			internal IEnumerable<NestedMenu.MenuEntry> <PopulateMainMenu>b__10_2(IEnumerable<NestedMenu.MenuEntry> x)
			{
				return x;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp;

			internal void <PopulateMainMenu>b__7()
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected I4, but got Unknown
				CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)kvp.Key);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_1
		{
			public KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp;

			internal void <PopulateMainMenu>b__9()
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected I4, but got Unknown
				CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)kvp.Key);
			}
		}

		private CardExpansionSelectScreen? screen;

		private FlowLayoutGroup? flowLayoutGroup;

		private NestedMenu? nestedMenuController;

		private Transform? cloneableButton;

		private bool isLoaded;

		internal bool IsLoaded
		{
			get
			{
				return isLoaded;
			}
			set
			{
				isLoaded = value;
				if (!value)
				{
					screen = null;
					flowLayoutGroup = null;
					nestedMenuController = null;
				}
			}
		}

		internal void OpenScreen()
		{
			if (screen == null)
			{
				screen = CSingleton<CardExpansionSelectScreen>.Instance;
			}
			if (flowLayoutGroup == null)
			{
				flowLayoutGroup = InitFlowLayoutGroup();
			}
			if (nestedMenuController == null)
			{
				nestedMenuController = ((Component)flowLayoutGroup).gameObject.AddComponent<NestedMenu>()?.Setup(flowLayoutGroup, cloneableButton);
			}
			ControllerScreenUIExtension component = ((Component)screen).GetComponent<ControllerScreenUIExtension>();
			nestedMenuController?.OnOpen(PopulateMainMenu(), component);
		}

		private FlowLayoutGroup InitFlowLayoutGroup()
		{
			//IL_007c: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00ee: 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_012e: 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 obj = screen.m_ScreenGrp.transform.Find("AnimGrp/Mask/UIGroup");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			Transform val2 = ((Transform)val).Find("Tetramon_Button");
			if (val2 != null)
			{
				((Component)val2).transform.SetParent((Transform)null);
				((Component)val2).gameObject.SetActive(false);
				cloneableButton = val2;
			}
			GameObject val3 = FlowLayoutGroup.Create(((Transform)val).parent, isScrollable: true);
			flowLayoutGroup = val3.GetComponentInChildren<FlowLayoutGroup>(true);
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetSiblingIndex(((Transform)val).GetSiblingIndex());
			component.anchorMin = val.anchorMin;
			component.anchorMax = val.anchorMax;
			component.pivot = val.pivot;
			component.anchoredPosition = val.anchoredPosition;
			component.sizeDelta = val.sizeDelta;
			((Transform)component).localScale = ((Transform)val).localScale;
			component.offsetMin = val.offsetMin;
			component.offsetMax = val.offsetMax;
			Object.Destroy((Object)(object)((Component)val).gameObject);
			Vector2 value = EplRuntimeData.Config.CardExpansionSelectButtonSizeEntry.Value;
			flowLayoutGroup.SpacingX = EplRuntimeData.Config.CardExpansionSelectSpacingXEntry.Value;
			flowLayoutGroup.SpacingY = EplRuntimeData.Config.CardExpansionSelectSpacingYEntry.Value;
			flowLayoutGroup.ChildWidth = value.x;
			flowLayoutGroup.ChildHeight = value.y;
			EplRuntimeData.Config.CardExpansionSelectSpacingXEntry.SettingChanged += delegate
			{
				if (flowLayoutGroup != null)
				{
					flowLayoutGroup.SpacingX = EplRuntimeData.Config.CardExpansionSelectSpacingXEntry.Value;
				}
			};
			EplRuntimeData.Config.CardExpansionSelectSpacingYEntry.SettingChanged += delegate
			{
				if (flowLayoutGroup != null)
				{
					flowLayoutGroup.SpacingY = EplRuntimeData.Config.CardExpansionSelectSpacingYEntry.Value;
				}
			};
			EplRuntimeData.Config.CardExpansionSelectButtonSizeEntry.SettingChanged += delegate
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: 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)
				if (flowLayoutGroup != null)
				{
					Vector2 value2 = EplRuntimeData.Config.CardExpansionSelectButtonSizeEntry.Value;
					flowLayoutGroup.ChildWidth = value2.x;
					flowLayoutGroup.ChildHeight = value2.y;
				}
			};
			return flowLayoutGroup;
		}

		private List<NestedMenu.MenuEntry> PopulateMainMenu()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			List<NestedMenu.MenuEntry> list = new List<NestedMenu.MenuEntry>();
			NestedMenu.MenuEntry obj = new NestedMenu.MenuEntry
			{
				Label = "Tetramon"
			};
			object obj2 = <>c.<>9__10_3;
			if (obj2 == null)
			{
				UnityAction val = delegate
				{
					CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton(0);
				};
				<>c.<>9__10_3 = val;
				obj2 = (object)val;
			}
			obj.OnClick = (UnityAction)obj2;
			list.Add(obj);
			NestedMenu.MenuEntry obj3 = new NestedMenu.MenuEntry
			{
				Label = "Destiny"
			};
			object obj4 = <>c.<>9__10_4;
			if (obj4 == null)
			{
				UnityAction val2 = delegate
				{
					CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton(1);
				};
				<>c.<>9__10_4 = val2;
				obj4 = (object)val2;
			}
			obj3.OnClick = (UnityAction)obj4;
			list.Add(obj3);
			NestedMenu.MenuEntry obj5 = new NestedMenu.MenuEntry
			{
				Label = "Ghost"
			};
			object obj6 = <>c.<>9__10_5;
			if (obj6 == null)
			{
				UnityAction val3 = delegate
				{
					CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton(2);
				};
				<>c.<>9__10_5 = val3;
				obj6 = (object)val3;
			}
			obj5.OnClick = (UnityAction)obj6;
			list.Add(obj5);
			IEnumerable<NestedMenu.MenuEntry> collection = (from kvp in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData
				group kvp by kvp.Value.MenuCategory into @group
				select (!string.IsNullOrWhiteSpace(@group.Key)) ? new <>z__ReadOnlySingleElementList<NestedMenu.MenuEntry>(new NestedMenu.MenuEntry
				{
					Label = @group.Key,
					SubMenu = @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
					{
						Label = kvp.Value.Name,
						OnClick = (UnityAction)delegate
						{
							//IL_000b: Unknown result type (might be due to invalid IL or missing references)
							//IL_0015: Expected I4, but got Unknown
							CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)kvp.Key);
						}
					}).ToList()
				}) : @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
				{
					Label = kvp.Value.Name,
					OnClick = (UnityAction)delegate
					{
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0015: Expected I4, but got Unknown
						CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)kvp.Key);
					}
				})).SelectMany((IEnumerable<NestedMenu.MenuEntry> x) => x);
			list.AddRange(collection);
			list.AddRange(EplRuntimeData.Services.menuService.GenericExpansionEntries);
			return list;
		}
	}
	internal class CardRaritySelectService
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__10_1;

			public static UnityAction <>9__10_2;

			public static UnityAction <>9__10_3;

			public static UnityAction <>9__10_4;

			public static UnityAction <>9__10_5;

			public static Func<ERarity, NestedMenu.MenuEntry> <>9__10_0;

			internal void <PopulateMainMenu>b__10_1()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(-1);
			}

			internal void <PopulateMainMenu>b__10_2()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(0);
			}

			internal void <PopulateMainMenu>b__10_3()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(1);
			}

			internal void <PopulateMainMenu>b__10_4()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(2);
			}

			internal void <PopulateMainMenu>b__10_5()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(3);
			}

			internal NestedMenu.MenuEntry <PopulateMainMenu>b__10_0(ERarity r)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				<>c__DisplayClass10_0 CS$<>8__locals0 = new <>c__DisplayClass10_0
				{
					r = r
				};
				return new NestedMenu.MenuEntry
				{
					Label = StringExtensions.Prettierize(((object)(ERarity)(ref CS$<>8__locals0.r)).ToString()),
					OnClick = (UnityAction)delegate
					{
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						//IL_0010: Expected I4, but got Unknown
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton((int)CS$<>8__locals0.r);
					}
				};
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public ERarity r;

			internal void <PopulateMainMenu>b__6()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Expected I4, but got Unknown
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton((int)r);
			}
		}

		private CardRaritySelectScreen? screen;

		private FlowLayoutGroup? flowLayoutGroup;

		private NestedMenu? nestedMenuController;

		private Transform? cloneableButton;

		private bool isLoaded;

		internal bool IsLoaded
		{
			get
			{
				return isLoaded;
			}
			set
			{
				isLoaded = value;
				if (!value)
				{
					screen = null;
					flowLayoutGroup = null;
					nestedMenuController = null;
				}
			}
		}

		internal void OpenScreen(ECardExpansionType expansionType)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (screen == null)
			{
				screen = CSingleton<CardRaritySelectScreen>.Instance;
			}
			if (flowLayoutGroup == null)
			{
				flowLayoutGroup = InitFlowLayoutGroup();
			}
			if (nestedMenuController == null)
			{
				nestedMenuController = ((Component)flowLayoutGroup).gameObject.AddComponent<NestedMenu>()?.Setup(flowLayoutGroup, cloneableButton);
			}
			ControllerScreenUIExtension component = ((Component)screen).GetComponent<ControllerScreenUIExtension>();
			nestedMenuController?.OnOpen(PopulateMainMenu(expansionType), component);
		}

		private FlowLayoutGroup InitFlowLayoutGroup()
		{
			//IL_007c: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00ee: 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_012e: 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 obj = screen.m_ScreenGrp.transform.Find("AnimGrp/Mask/UIGroup");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			Transform val2 = ((Transform)val).Find("AnyRarity_Button");
			if (val2 != null)
			{
				((Component)val2).transform.SetParent((Transform)null);
				((Component)val2).gameObject.SetActive(false);
				cloneableButton = val2;
			}
			GameObject val3 = FlowLayoutGroup.Create(((Transform)val).parent, isScrollable: true);
			flowLayoutGroup = val3.GetComponentInChildren<FlowLayoutGroup>(true);
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetSiblingIndex(((Transform)val).GetSiblingIndex());
			component.anchorMin = val.anchorMin;
			component.anchorMax = val.anchorMax;
			component.pivot = val.pivot;
			component.anchoredPosition = val.anchoredPosition;
			component.sizeDelta = val.sizeDelta;
			((Transform)component).localScale = ((Transform)val).localScale;
			component.offsetMin = val.offsetMin;
			component.offsetMax = val.offsetMax;
			Object.Destroy((Object)(object)((Component)val).gameObject);
			Vector2 value = EplRuntimeData.Config.RaritySelectButtonSizeEntry.Value;
			flowLayoutGroup.SpacingX = EplRuntimeData.Config.RaritySelectSpacingXEntry.Value;
			flowLayoutGroup.SpacingY = EplRuntimeData.Config.RaritySelectSpacingYEntry.Value;
			flowLayoutGroup.ChildWidth = value.x;
			flowLayoutGroup.ChildHeight = value.y;
			EplRuntimeData.Config.RaritySelectSpacingXEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj3 = flowLayoutGroup;
				if (obj3 != null)
				{
					obj3.SpacingX = EplRuntimeData.Config.RaritySelectSpacingXEntry.Value;
				}
			};
			EplRuntimeData.Config.RaritySelectSpacingYEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj2 = flowLayoutGroup;
				if (obj2 != null)
				{
					obj2.SpacingY = EplRuntimeData.Config.RaritySelectSpacingYEntry.Value;
				}
			};
			EplRuntimeData.Config.RaritySelectButtonSizeEntry.SettingChanged += delegate
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: 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)
				if (flowLayoutGroup != null)
				{
					Vector2 value2 = EplRuntimeData.Config.RaritySelectButtonSizeEntry.Value;
					flowLayoutGroup.ChildWidth = value2.x;
					flowLayoutGroup.ChildHeight = value2.y;
				}
			};
			return flowLayoutGroup;
		}

		private List<NestedMenu.MenuEntry> PopulateMainMenu(ECardExpansionType expansionType)
		{
			//IL_0050: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00fb: 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_0106: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			List<NestedMenu.MenuEntry> list = new List<NestedMenu.MenuEntry>();
			NestedMenu.MenuEntry obj = new NestedMenu.MenuEntry
			{
				Label = "Any Rarity"
			};
			object obj2 = <>c.<>9__10_1;
			if (obj2 == null)
			{
				UnityAction val = delegate
				{
					CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(-1);
				};
				<>c.<>9__10_1 = val;
				obj2 = (object)val;
			}
			obj.OnClick = (UnityAction)obj2;
			list.Add(obj);
			List<NestedMenu.MenuEntry> list2 = list;
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				NestedMenu.MenuEntry[] array = new NestedMenu.MenuEntry[4];
				NestedMenu.MenuEntry obj3 = new NestedMenu.MenuEntry
				{
					Label = "Common"
				};
				object obj4 = <>c.<>9__10_2;
				if (obj4 == null)
				{
					UnityAction val2 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(0);
					};
					<>c.<>9__10_2 = val2;
					obj4 = (object)val2;
				}
				obj3.OnClick = (UnityAction)obj4;
				array[0] = obj3;
				NestedMenu.MenuEntry obj5 = new NestedMenu.MenuEntry
				{
					Label = "Rare"
				};
				object obj6 = <>c.<>9__10_3;
				if (obj6 == null)
				{
					UnityAction val3 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(1);
					};
					<>c.<>9__10_3 = val3;
					obj6 = (object)val3;
				}
				obj5.OnClick = (UnityAction)obj6;
				array[1] = obj5;
				NestedMenu.MenuEntry obj7 = new NestedMenu.MenuEntry
				{
					Label = "Epic"
				};
				object obj8 = <>c.<>9__10_4;
				if (obj8 == null)
				{
					UnityAction val4 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(2);
					};
					<>c.<>9__10_4 = val4;
					obj8 = (object)val4;
				}
				obj7.OnClick = (UnityAction)obj8;
				array[2] = obj7;
				NestedMenu.MenuEntry obj9 = new NestedMenu.MenuEntry
				{
					Label = "Legendary"
				};
				object obj10 = <>c.<>9__10_5;
				if (obj10 == null)
				{
					UnityAction val5 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(3);
					};
					<>c.<>9__10_5 = val5;
					obj10 = (object)val5;
				}
				obj9.OnClick = (UnityAction)obj10;
				array[3] = obj9;
				list2.AddRange(new <>z__ReadOnlyArray<NestedMenu.MenuEntry>(array));
				return list2;
			}
			list2.AddRange(value.Rarities.Select((ERarity r) => new NestedMenu.MenuEntry
			{
				Label = StringExtensions.Prettierize(((object)(ERarity)(ref r)).ToString()),
				OnClick = (UnityAction)delegate
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Expected I4, but got Unknown
					CSingleton<CardRaritySelectScreen>.Instance.OnPressButton((int)r);
				}
			}));
			return list2;
		}
	}
	public class CardSelectionService
	{
		private static readonly (EItemType pack, int foil, int grade)[] PackBonuses = new(EItemType, int, int)[7]
		{
			((EItemType)2, 0, 2),
			((EItemType)4, 0, 2),
			((EItemType)6, 1, 2),
			((EItemType)8, 1, 2),
			((EItemType)10, 1, 2),
			((EItemType)12, 1, 2),
			((EItemType)14, 1, 3)
		};

		public CardData SelectRandomCard()
		{
			//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_006d: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Invalid comparison between Unknown and I4
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			ECardExpansionType val = RandomUtils.Weighted(CalculateExpansionWeights());
			(int foil, int grade) tuple = PackBonuses.Where(((EItemType pack, int foil, int grade) b) => CPlayerData.m_ShopLevel >= InventoryBase.GetUnlockItemLevelRequired(b.pack)).Aggregate((0, 0), ((int foil, int grade) acc, (EItemType pack, int foil, int grade) b) => (acc.foil + b.foil, acc.grade + b.grade));
			int item = tuple.foil;
			int item2 = tuple.grade;
			int num = InventoryBase.GetShownMonsterList(val).Count * CPlayerData.GetCardAmountPerMonsterType(val, true);
			int num2 = Random.Range(0, num);
			bool flag = (int)val == 2 && Random.Range(0, 100) < 50;
			CardData val2 = ((Random.Range(0, 100) < item2) ? CPlayerData.GetGradedCardData(new CompactCardDataAmount
			{
				cardSaveIndex = num2,
				expansionType = val,
				isDestiny = flag,
				amount = Random.Range(1, 11)
			}) : CPlayerData.GetCardData(num2, val, flag));
			if ((int)val == 2)
			{
				val2.isFoil = Random.Range(0, 100) < item;
			}
			return val2;
		}

		public CardData? SelectPlayerCard(CardData targetCard, CustomerTradeData customerTradeData)
		{
			//IL_0012: 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_0026: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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)
			int num = 4;
			float cardMarketPrice = CPlayerData.GetCardMarketPrice(targetCard);
			Dictionary<ECardExpansionType, float> dictionary = CalculateExpansionWeights();
			if (dictionary.ContainsKey(targetCard.expansionType))
			{
				dictionary[targetCard.expansionType] *= 3f;
				if ((int)targetCard.expansionType == 2)
				{
					dictionary[targetCard.expansionType] *= 4f;
				}
			}
			for (int i = 0; i < num; i++)
			{
				if (dictionary.Count <= 0)
				{
					break;
				}
				ECardExpansionType val = RandomUtils.Weighted(dictionary);
				CardData val2 = TryFindInExpansion(val, targetCard, cardMarketPrice);
				if (val2 != null)
				{
					return val2;
				}
				dictionary.Remove(val);
			}
			return null;
		}

		private CardData? TryFindInExpansion(ECardExpansionType expansion, CardData targetCard, float targetPrice)
		{
			//IL_0000: 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_005b: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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)
			List<int> cardCollectedList = CPlayerData.GetCardCollectedList(expansion, false);
			List<CardData> list = new List<CardData>();
			for (int i = 0; i < cardCollectedList.Count; i++)
			{
				if (cardCollectedList[i] > 0)
				{
					float cardMarketPrice = CPlayerData.GetCardMarketPrice(i, expansion, false, 0);
					if (cardMarketPrice >= targetPrice * 0.75f && cardMarketPrice < targetPrice * 1.5f)
					{
						CardData cardData = CPlayerData.GetCardData(i, expansion, false);
						if (!cardData.IsEqual(targetCard))
						{
							list.Add(cardData);
						}
					}
				}
				if ((int)expansion != 2 || CPlayerData.GetCardCollectedList(expansion, true)[i] <= 0)
				{
					continue;
				}
				float cardMarketPrice2 = CPlayerData.GetCardMarketPrice(i, expansion, true, 0);
				if (cardMarketPrice2 >= targetPrice * 0.75f && cardMarketPrice2 < targetPrice * 1.5f)
				{
					CardData cardData2 = CPlayerData.GetCardData(i, expansion, true);
					if (!cardData2.IsEqual(targetCard))
					{
						list.Add(cardData2);
					}
				}
			}
			for (int j = 0; j < CPlayerData.m_GradedCardInventoryList.Count; j++)
			{
				CompactCardDataAmount val = CPlayerData.m_GradedCardInventoryList[j];
				if (val.expansionType != expansion)
				{
					continue;
				}
				float cardMarketPrice3 = CPlayerData.GetCardMarketPrice(val.cardSaveIndex, val.expansionType, val.isDestiny, val.amount);
				if (cardMarketPrice3 >= targetPrice * 0.75f && cardMarketPrice3 < targetPrice * 1.5f)
				{
					CardData gradedCardData = CPlayerData.GetGradedCardData(val);
					if (!gradedCardData.IsEqual(targetCard))
					{
						list.Add(gradedCardData);
					}
				}
			}
			if (list.Count != 0)
			{
				return list[Random.Range(0, list.Count)];
			}
			return null;
		}

		private Dictionary<ECardExpansionType, float> CalculateExpansionWeights()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			bool excludeBaseGameCardsFromTrade = EplRuntimeData.Config.ExcludeBaseGameCardsFromTrade;
			Dictionary<ECardExpansionType, float> dictionary = new Dictionary<ECardExpansionType, float>();
			if (!excludeBaseGameCardsFromTrade)
			{
				dictionary[(ECardExpansionType)0] = 48f;
				dictionary[(ECardExpansionType)1] = CalculateExpansionWeight((ECardExpansionType)1, InventoryBase.GetUnlockItemLevelRequired((EItemType)8), 15, 48);
			}
			foreach (KeyValuePair<ECardExpansionType, ModCardExpansionData> cardExpansionDatum in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData)
			{
				dictionary[cardExpansionDatum.Key] = CalculateExpansionWeight(cardExpansionDatum.Key, cardExpansionDatum.Value.TradeUnlockLevel, 15, 48);
			}
			if (!excludeBaseGameCardsFromTrade)
			{
				dictionary[(ECardExpansionType)2] = CalculateDynamicExpansionWeight((ECardExpansionType)2, InventoryBase.GetUnlockItemLevelRequired((EItemType)2), 0.04f, dictionary);
			}
			return dictionary;
		}

		private float CalculateExpansionWeight(ECardExpansionType expansionType, int unlockLevel, int minWeight, int maxWeight)
		{
			if (CPlayerData.m_ShopLevel < unlockLevel)
			{
				return 0f;
			}
			if (CPlayerData.m_ShopLevel >= 50)
			{
				return maxWeight;
			}
			int num = CPlayerData.m_ShopLevel - unlockLevel;
			int num2 = 50 - unlockLevel;
			float num3 = (float)num / (float)num2;
			int num4 = maxWeight - minWeight;
			return (float)minWeight + (float)num4 * num3;
		}

		private float CalculateDynamicExpansionWeight(ECardExpansionType expansionType, int unlockLevel, float targetPercentage, Dictionary<ECardExpansionType, float> allWeights)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (CPlayerData.m_ShopLevel < unlockLevel)
			{
				return 0f;
			}
			int maxWeight = Mathf.RoundToInt(allWeights.Values.Sum() * targetPercentage / (1f - targetPercentage));
			return CalculateExpansionWeight(expansionType, unlockLevel, 1, maxWeight);
		}
	}
	internal class CollectionBinderService
	{
		private CollectionBinderUI? collectionBinderUI;

		private FlowLayoutGroup? flowLayoutGroup;

		private NestedMenu? nestedMenuController;

		private Transform? cloneableButton;

		private bool isLoaded;

		internal List<ECardExpansionType> Buttons { get; set; } = new List<ECardExpansionType>();


		internal bool IsLoaded
		{
			get
			{
				return isLoaded;
			}
			set
			{
				isLoaded = value;
				if (!value)
				{
					collectionBinderUI = null;
					flowLayoutGroup = null;
					nestedMenuController = null;
				}
			}
		}

		internal void OpenScreen(CollectionBinderUI collectionBinderUI)
		{
			if (this.collectionBinderUI == null)
			{
				this.collectionBinderUI = collectionBinderUI;
			}
			if (flowLayoutGroup == null)
			{
				flowLayoutGroup = InitFlowLayoutGroup();
			}
			if (nestedMenuController == null)
			{
				nestedMenuController = ((Component)flowLayoutGroup).gameObject.AddComponent<NestedMenu>()?.Setup(flowLayoutGroup, cloneableButton);
			}
			ControllerScreenUIExtension component = ((Component)collectionBinderUI).GetComponent<ControllerScreenUIExtension>();
			nestedMenuController?.OnOpen(PopulateMainMenu(), component, saveLastEntry: true);
		}

		private FlowLayoutGroup InitFlowLayoutGroup()
		{
			//IL_007c: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00ee: 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_012e: 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 obj = collectionBinderUI.m_ExpansionSelectScreen.transform.Find("Mask/UIGroup");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			Transform val2 = ((Transform)val).Find("Tetramon_Button");
			if (val2 != null)
			{
				((Component)val2).transform.SetParent((Transform)null);
				((Component)val2).gameObject.SetActive(false);
				cloneableButton = val2;
			}
			GameObject val3 = FlowLayoutGroup.Create(((Transform)val).parent, isScrollable: true);
			flowLayoutGroup = val3.GetComponentInChildren<FlowLayoutGroup>(true);
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetSiblingIndex(((Transform)val).GetSiblingIndex());
			component.anchorMin = val.anchorMin;
			component.anchorMax = val.anchorMax;
			component.pivot = val.pivot;
			component.anchoredPosition = val.anchoredPosition;
			component.sizeDelta = val.sizeDelta;
			((Transform)component).localScale = ((Transform)val).localScale;
			component.offsetMin = val.offsetMin;
			component.offsetMax = val.offsetMax;
			Object.Destroy((Object)(object)((Component)val).gameObject);
			Vector2 value = EplRuntimeData.Config.CollectionBinderButtonSizeEntry.Value;
			flowLayoutGroup.SpacingX = EplRuntimeData.Config.CollectionBinderSpacingXEntry.Value;
			flowLayoutGroup.SpacingY = EplRuntimeData.Config.CollectionBinderSpacingYEntry.Value;
			flowLayoutGroup.ChildWidth = value.x;
			flowLayoutGroup.ChildHeight = value.y;
			EplRuntimeData.Config.CollectionBinderSpacingXEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj3 = flowLayoutGroup;
				if (obj3 != null)
				{
					obj3.SpacingX = EplRuntimeData.Config.CollectionBinderSpacingXEntry.Value;
				}
			};
			EplRuntimeData.Config.CollectionBinderSpacingYEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj2 = flowLayoutGroup;
				if (obj2 != null)
				{
					obj2.SpacingY = EplRuntimeData.Config.CollectionBinderSpacingYEntry.Value;
				}
			};
			EplRuntimeData.Config.CollectionBinderButtonSizeEntry.SettingChanged += delegate
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				Vector2 value2 = EplRuntimeData.Config.CollectionBinderButtonSizeEntry.Value;
				if (collectionBinderUI != null)
				{
					foreach (Transform expansionBtn in collectionBinderUI.m_ExpansionBtnList)
					{
						RectTransform val4 = (RectTransform)(object)((expansionBtn is RectTransform) ? expansionBtn : null);
						if (val4 != null)
						{
							val4.sizeDelta = value2;
						}
					}
				}
			};
			return flowLayoutGroup;
		}

		private List<NestedMenu.MenuEntry> PopulateMainMenu()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			List<NestedMenu.MenuEntry> list = new List<NestedMenu.MenuEntry>();
			list.Add(new NestedMenu.MenuEntry
			{
				Label = "Tetramon",
				OnClick = (UnityAction)delegate
				{
					collectionBinderUI.OnPressSwitchExpansion(0);
				}
			});
			list.Add(new NestedMenu.MenuEntry
			{
				Label = "Destiny",
				OnClick = (UnityAction)delegate
				{
					collectionBinderUI.OnPressSwitchExpansion(1);
				}
			});
			list.Add(new NestedMenu.MenuEntry
			{
				Label = "Ghost",
				OnClick = (UnityAction)delegate
				{
					collectionBinderUI.OnPressSwitchExpansion(2);
				}
			});
			list.Add(new NestedMenu.MenuEntry
			{
				Label = "Graded Cards",
				OnClick = (UnityAction)delegate
				{
					collectionBinderUI.OnPressSwitchToGradedAlbum();
				}
			});
			IEnumerable<NestedMenu.MenuEntry> collection = (from kvp in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData
				group kvp by kvp.Value.MenuCategory into @group
				select (!string.IsNullOrWhiteSpace(@group.Key)) ? new <>z__ReadOnlySingleElementList<NestedMenu.MenuEntry>(new NestedMenu.MenuEntry
				{
					Label = @group.Key,
					SubMenu = @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
					{
						Label = kvp.Value.Name,
						OnClick = (UnityAction)delegate
						{
							//IL_0011: Unknown result type (might be due to invalid IL or missing references)
							//IL_001b: Expected I4, but got Unknown
							collectionBinderUI.OnPressSwitchExpansion((int)kvp.Key);
						}
					}).ToList()
				}) : @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
				{
					Label = kvp.Value.Name,
					OnClick = (UnityAction)delegate
					{
						//IL_0011: Unknown result type (might be due to invalid IL or missing references)
						//IL_001b: Expected I4, but got Unknown
						collectionBinderUI.OnPressSwitchExpansion((int)kvp.Key);
					}
				})).SelectMany((IEnumerable<NestedMenu.MenuEntry> x) => x);
			list.AddRange(collection);
			list.AddRange(EplRuntimeData.Services.menuService.BinderExpansionEntries);
			return list;
		}
	}
	internal class SaveDataService
	{
		[CompilerGenerated]
		private BundleAssetTracker <assetTracker>P;

		private readonly SaveDataReconciler saveDataReconciler;

		private readonly SaveDataSerialization saveDataSerializationService;

		private readonly Dictionary<string, SaveData> saveData;

		public SaveDataService(BundleAssetTracker assetTracker)
		{
			<assetTracker>P = assetTracker;
			saveDataReconciler = new SaveDataReconciler();
			saveDataSerializationService = new SaveDataSerialization();
			saveData = new Dictionary<string, SaveData>();
			base..ctor();
		}

		internal void RegisterSaveData<TEnum, TData>(string bundleId, TEnum enumValue, TData data) where TEnum : Enum where TData : EplBaseSaveData
		{
			SetSaveData(bundleId, enumValue, data);
		}

		internal void RegisterSaveData<TData>(string bundleId, string category, string assetName, TData data) where TData : EplBaseSaveData
		{
			SetSaveData(bundleId, category, assetName, data);
		}

		internal bool TryGetSaveData<TEnum, TData>(TEnum enumValue, out TData? data) where TEnum : Enum where TData : EplBaseSaveData
		{
			string bundleIdFor = <assetTracker>P.GetBundleIdFor(enumValue);
			if (string.IsNullOrWhiteSpace(bundleIdFor))
			{
				data = null;
				return false;
			}
			string key = GenerateKey(enumValue);
			data = (saveData.TryGetValue(bundleIdFor, out SaveData value) ? value.GetData<TData>(key) : null);
			return data != null;
		}

		internal bool TryGetSaveData<TData>(string category, string assetName, out TData? data) where TData : EplBaseSaveData
		{
			string bundleIdFor = <assetTracker>P.GetBundleIdFor(category, assetName);
			if (string.IsNullOrWhiteSpace(bundleIdFor))
			{
				data = null;
				return false;
			}
			string key = GenerateKey(category, assetName);
			data = (saveData.TryGetValue(bundleIdFor, out SaveData value) ? value.GetData<TData>(key) : null);
			return data != null;
		}

		private void SetSaveData<TEnum, TData>(string bundleId, TEnum enumValue, TData data) where TEnum : Enum where TData : EplBaseSaveData
		{
			if (string.IsNullOrWhiteSpace(bundleId))
			{
				ModLogger.Warning($"Registration of save data for item {enumValue} failed. Mod id is not defined", "SetSaveData", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SaveDataService.cs");
				return;
			}
			string key = GenerateKey(enumValue);
			saveData.GetOrAdd(bundleId, (string _) => new SaveData()).SetData(key, data);
		}

		private void SetSaveData<TData>(string bundleId, string category, string assetName, TData data) where TData : EplBaseSaveData
		{
			if (string.IsNullOrWhiteSpace(bundleId))
			{
				ModLogger.Warning("Registration of save data for item " + assetName + " failed. Mod id is not defined", "SetSaveData", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SaveDataService.cs");
				return;
			}
			string key = GenerateKey(category, assetName);
			saveData.GetOrAdd(bundleId, (string _) => new SaveData()).SetData(key, data);
		}

		internal void LoadFromFile(string filePath)
		{
			Dictionary<string, SaveData> dictionary = saveDataSerializationService.LoadFromFile(filePath);
			if (dictionary == null)
			{
				return;
			}
			saveDataReconciler.Reconcile(dictionary, saveData);
			foreach (SaveData value in saveData.Values)
			{
				foreach (string key in value.GetKeys())
				{
					if (value.GetData<EplBaseSaveData>(key) is IPostLoadNormalizer postLoadNormalizer)
					{
						postLoadNormalizer.NormalizeAfterLoad(key);
					}
				}
			}
		}

		internal void ResetAllSaveData()
		{
			foreach (SaveData value in saveData.Values)
			{
				value.ResetData();
			}
		}

		internal void SaveToFile(string filePath)
		{
			saveDataSerializationService.SaveToFile(saveData, filePath);
		}

		private string GenerateKey<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			return $"{typeof(TEnum).Name}:{enumValue}";
		}

		private string GenerateKey(string category, string assetName)
		{
			return category + ":" + assetName;
		}
	}
	internal class SettingsScreenService
	{
		private GameObject? modSettingScreen;

		private TMP_Dropdown? bundleDropdown;

		private GameObject? labelTemplate;

		private GameObject? dropdownTemplate;

		private readonly BundleMaintenanceService maintenanceService = new BundleMaintenanceService();

		private TextMeshProUGUI? bundleIdValue;

		private TextMeshProUGUI? itemCountValue;

		private TextMeshProUGUI? decoCountValue;

		private TextMeshProUGUI? furnitureCountValue;

		private TextMeshProUGUI? textureCountValue;

		private GameObject? expansionDropdownRow;

		private TMP_Dropdown? expansionDropdown;

		private TextMeshProUGUI? expansionCountValue;

		private TextMeshProUGUI? cardCountValue;

		internal bool IsLoaded { get; set; }

		internal void Initialize(SettingScreen settingsScreen)
		{
			if (!IsLoaded)
			{
				CreateTabButton(settingsScreen);
				CreateContentScreen(settingsScreen);
				IsLoaded = true;
			}
		}

		private void CreateTabButton(SettingScreen settingsScreen)
		{
			//IL_0086: 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_00ce: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			SettingScreen settingsScreen2 = settingsScreen;
			GameObject gameObject = ((Component)settingsScreen2.m_ScreenGrp.transform.Find("KeybindSettingBtn")).gameObject;
			GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
			settingsScreen2.m_SubSettingBtnHighlight.Add(((Component)val.transform.Find("AnimGrp/BGHighlight")).gameObject);
			Transform transform = val.transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			obj.localPosition = new Vector3(-588f, 73f, 0f);
			obj.SetSiblingIndex(gameObject.transform.GetSiblingIndex() + 1);
			((Component)obj).GetComponentInChildren<Localize>(true).Term = "EPL";
			Button componentInChildren = val.GetComponentInChildren<Button>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.onClick = new ButtonClickedEvent();
				((UnityEvent)componentInChildren.onClick).AddListener((UnityAction)delegate
				{
					OnPressModSettings(settingsScreen2);
				});
			}
		}

		private void CreateContentScreen(SettingScreen settingsScreen)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)settingsScreen.m_ScreenGrp.transform.Find("Settings Content")).gameObject;
			modSettingScreen = Object.Instantiate<GameObject>(gameObject, settingsScreen.m_ScreenGrp.transform);
			modSettingScreen.transform.SetSiblingIndex(gameObject.transform.GetSiblingIndex() + 1);
			modSettingScreen.SetActive(false);
			VerticalLayoutGroup component = modSettingScreen.GetComponent<VerticalLayoutGroup>();
			if ((Object)(object)component != (Object)null)
			{
				((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
			}
			Transform val = modSettingScreen.transform.Find("CurrencyType (Custom)");
			((Component)val).GetComponent<Localize>().Term = "Bundle";
			Transform val2 = modSettingScreen.transform.Find("Separator");
			Transform val3 = modSettingScreen.transform.Find("Music (Custom)");
			if ((Object)(object)val3 != (Object)null)
			{
				labelTemplate = Object.Instantiate<GameObject>(((Component)val3).gameObject);
				labelTemplate.SetActive(false);
				Localize component2 = labelTemplate.GetComponent<Localize>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
				}
				Transform val4 = labelTemplate.transform.Find("Music Slider");
				if ((Object)(object)val4 != (Object)null)
				{
					TextMeshProUGUI component3 = labelTemplate.GetComponent<TextMeshProUGUI>();
					GameObject val5 = new GameObject("ValueText");
					val5.transform.SetParent(labelTemplate.transform, false);
					TextMeshProUGUI obj = val5.AddComponent<TextMeshProUGUI>();
					((TMP_Text)obj).font = ((TMP_Text)component3).font;
					((TMP_Text)obj).fontSize = ((TMP_Text)component3).fontSize;
					((Graphic)obj).color = ((Graphic)component3).color;
					((TMP_Text)obj).alignment = (TextAlignmentOptions)513;
					((TMP_Text)obj).enableWordWrapping = false;
					((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
					RectTransform component4 = val5.GetComponent<RectTransform>();
					component4.anchorMin = new Vector2(0.25f, 0f);
					component4.anchorMax = new Vector2(1f, 1f);
					component4.offsetMin = Vector2.zero;
					component4.offsetMax = Vector2.zero;
					Object.DestroyImmediate((Object)(object)((Component)val4).gameObject);
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				dropdownTemplate = Object.Instantiate<GameObject>(((Component)val).gameObject);
				dropdownTemplate.SetActive(false);
			}
			if (val != null)
			{
				val.SetParent((Transform)null);
			}
			if (val2 != null)
			{
				val2.SetParent((Transform)null);
			}
			foreach (Transform item in modSettingScreen.transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			if (val2 != null)
			{
				val2.SetParent(modSettingScreen.transform);
			}
			if (val != null)
			{
				val.SetParent(modSettingScreen.transform);
			}
			SetupDropdown(val);
			CreateInfoPanel();
			CreateActionButtons(settingsScreen);
			UpdateBundleInfo();
		}

		private void SetupDropdown(Transform? dropdownTransform)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if ((Object)(object)dropdownTransform == (Object)null)
			{
				return;
			}
			Transform obj = dropdownTransform.Find("Currency Dropdown");
			TMP_Dropdown val = ((obj != null) ? ((Component)obj).GetComponent<TMP_Dropdown>() : null);
			if (!((Object)(object)val == (Object)null))
			{
				bundleDropdown = val;
				bundleDropdown.onValueChanged = new DropdownEvent();
				bundleDropdown.ClearOptions();
				bundleDropdown.AddOptions(EplRuntimeData.Assets.BundleRegistry.BundleInfo.Select<KeyValuePair<string, BundleInfo>, OptionData>((KeyValuePair<string, BundleInfo> kvp) => new OptionData(kvp.Value.Name)).ToList());
				((UnityEvent<int>)(object)bundleDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					UpdateBundleInfo();
				});
			}
		}

		private void CreateInfoPanel()
		{
			if (!((Object)(object)modSettingScreen == (Object)null) && !((Object)(object)labelTemplate == (Object)null))
			{
				bundleIdValue = CreateLabelRow("Bundle ID:");
				itemCountValue = CreateLabelRow("Items:");
				furnitureCountValue = CreateLabelRow("Furniture:");
				decoCountValue = CreateLabelRow("Deco Objects:");
				textureCountValue = CreateLabelRow("Textures:");
				expansionCountValue = CreateLabelRow("Card Expansions:");
				CreateExpansionDropdown();
				cardCountValue = CreateLabelRow("Cards:");
			}
		}

		private TextMeshProUGUI CreateLabelRow(string labelText)
		{
			GameObject obj = Object.Instantiate<GameObject>(labelTemplate, modSettingScreen.transform);
			((Object)obj).name = labelText;
			obj.SetActive(true);
			TextMeshProUGUI component = obj.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = labelText;
			Transform obj2 = obj.transform.Find("ValueText");
			TextMeshProUGUI val = ((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)val).text = string.Empty;
			}
			return val ?? component;
		}

		private void CreateExpansionDropdown()
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			if ((Object)(object)modSettingScreen == (Object)null || (Object)(object)dropdownTemplate == (Object)null)
			{
				return;
			}
			expansionDropdownRow = Object.Instantiate<GameObject>(dropdownTemplate, modSettingScreen.transform);
			((Object)expansionDropdownRow).name = "ExpansionDropdown";
			expansionDropdownRow.SetActive(false);
			GameObject? obj = expansionDropdownRow;
			Localize component = obj.GetComponent<Localize>();
			if ((Object)(object)component != (Object)null)
			{
				component.Term = "Card Expansion";
			}
			Transform val = obj.transform.Find("Currency Dropdown");
			if ((Object)(object)val != (Object)null)
			{
				((Object)val).name = "Expansion Dropdown";
				expansionDropdown = ((Component)val).GetComponent<TMP_Dropdown>();
				Transform obj2 = val.Find("Label");
				TextMeshProUGUI val2 = ((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					expansionDropdown.captionText = (TMP_Text)(object)val2;
				}
				((UnityEventBase)expansionDropdown.onValueChanged).RemoveAllListeners();
				expansionDropdown.onValueChanged = new DropdownEvent();
				expansionDropdown.ClearOptions();
				((UnityEvent<int>)(object)expansionDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					UpdateCardCount();
				});
			}
		}

		private void UpdateBundleInfo()
		{
			string selectedBundleId = GetSelectedBundleId();
			if (selectedBundleId != null && EplRuntimeData.Assets.BundleRegistry.BundleInfo.TryGetValue(selectedBundleId, out BundleInfo value))
			{
				SetValue(bundleIdValue, value.BundleId);
				SetValue(itemCountValue, value.ItemTypes.Count.ToString());
				SetValue(furnitureCountValue, value.FurnitureTypes.Count.ToString());
				SetValue(decoCountValue, value.DecoObjects.Count.ToString());
				int num = value.WallTextures.Count + value.FloorTextures.Count + value.CeilingTextures.Count;
				SetValue(textureCountValue, $"{num} (Wall: {value.WallTextures.Count}, Floor: {value.FloorTextures.Count}, Ceiling: {value.CeilingTextures.Count})");
				PopulateExpansionDropdown(value);
			}
		}

		private void PopulateExpansionDropdown(BundleInfo info)
		{
			if (info.ExpansionTypes.Count == 0)
			{
				GameObject? obj = expansionDropdownRow;
				if (obj != null)
				{
					obj.SetActive(false);
				}
				TextMeshProUGUI? obj2 = expansionCountValue;
				if (obj2 != null)
				{
					((Component)((TMP_Text)obj2).transform.parent).gameObject.SetActive(true);
				}
				SetValue(expansionCountValue, "0");
				TextMeshProUGUI? obj3 = cardCountValue;
				if (obj3 != null)
				{
					((Component)((TMP_Text)obj3).transform.parent).gameObject.SetActive(false);
				}
				return;
			}
			TextMeshProUGUI? obj4 = expansionCountValue;
			if (obj4 != null)
			{
				((Component)((TMP_Text)obj4).transform.parent).gameObject.SetActive(false);
			}
			GameObject? obj5 = expansionDropdownRow;
			if (obj5 != null)
			{
				obj5.SetActive(true);
			}
			TextMeshProUGUI? obj6 = cardCountValue;
			if (obj6 != null)
			{
				((Component)((TMP_Text)obj6).transform.parent).gameObject.SetActive(true);
			}
			if ((Object)(object)expansionDropdown == (Object)null)
			{
				return;
			}
			expansionDropdown.ClearOptions();
			CardExpansionLibrary expansionLibrary = EplRuntimeData.Assets.CardExpansionLibrary;
			List<OptionData> list = ((IEnumerable<ECardExpansionType>)info.ExpansionTypes).Select((Func<ECardExpansionType, OptionData>)delegate(ECardExpansionType e)
			{
				//IL_0019: 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_003e: Expected O, but got Unknown
				string text = ((object)(ECardExpansionType)(ref e)).ToString();
				if (expansionLibrary.CardExpansionData.TryGetValue(e, out ModCardExpansionData value) && !string.IsNullOrWhiteSpace(value.Name))
				{
					text = value.Name;
				}
				return new OptionData(text);
			}).ToList();
			expansionDropdown.AddOptions(list);
			expansionDropdown.value = 0;
			UpdateCardCount();
		}

		private void UpdateCardCount()
		{
			//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)
			string selectedBundleId = GetSelectedBundleId();
			if (selectedBundleId == null || !EplRuntimeData.Assets.BundleRegistry.BundleInfo.TryGetValue(selectedBundleId, out BundleInfo value))
			{
				return;
			}
			if ((Object)(object)expansionDropdown == (Object)null || value.ExpansionTypes.Count == 0)
			{
				SetValue(cardCountValue, "0");
				return;
			}
			int value2 = expansionDropdown.value;
			if (value2 < 0 || value2 >= value.ExpansionTypes.Count)
			{
				SetValue(cardCountValue, "0");
				return;
			}
			ECardExpansionType key = value.ExpansionTypes[value2];
			int num = 0;
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(key, out ModCardExpansionData value3))
			{
				num = value3.Cards.Count;
			}
			SetValue(cardCountValue, num.ToString());
		}

		private static void SetValue(TextMeshProUGUI? valueTmp, string value)
		{
			if ((Object)(object)valueTmp != (Object)null)
			{
				((TMP_Text)valueTmp).text = value;
			}
		}

		private void CreateActionButtons(SettingScreen settingsScreen)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			if (!((Object)(object)modSettingScreen == (Object)null))
			{
				Transform obj = settingsScreen.m_ScreenGrp.transform.Find("Settings Content");
				Button val = ((obj != null) ? ((Component)obj).GetComponentInChildren<Button>(true) : null);
				if ((Object)(object)val == (Object)null)
				{
					ModLogger.Warning("Could not find a button to clone for mod settings screen", "CreateActionButtons", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SettingsScreenService.cs");
					return;
				}
				GameObject obj2 = Object.Instantiate<GameObject>(((Component)val).gameObject, modSettingScreen.transform);
				((Object)obj2).name = "ResetPricesBtn";
				Button component = obj2.GetComponent<Button>();
				component.onClick = new ButtonClickedEvent();
				((UnityEvent)component.onClick).AddListener(new UnityAction(OnPressResetPrices));
				GameObject obj3 = Object.Instantiate<GameObject>(((Component)val).gameObject, modSettingScreen.transform);
				((Object)obj3).name = "UninstallBtn";
				Button component2 = obj3.GetComponent<Button>();
				component2.onClick = new ButtonClickedEvent();
				((UnityEvent)component2.onClick).AddListener(new UnityAction(OnPressUninstall));
			}
		}

		internal void HideModScreen()
		{
			GameObject? obj = modSettingScreen;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}

		private void OnPressModSettings(SettingScreen settingsScreen)
		{
			SoundManager.GenericConfirm(1f, 1f);
			settingsScreen.m_GameSettingScreen.SetActive(false);
			settingsScreen.m_DisplaySettingScreen.SetActive(false);
			settingsScreen.m_LanguageScreen.SetActive(false);
			settingsScreen.m_KeybindScreen.SetActive(false);
			GameObject? obj = modSettingScreen;
			if (obj != null)
			{
				obj.SetActive(true);
			}
			int num = settingsScreen.m_SubSettingBtnHighlight.Count - 1;
			for (int i = 0; i < settingsScreen.m_SubSettingBtnHighlight.Count; i++)
			{
				settingsScreen.m_SubSettingBtnHighlight[i].SetActive(i == num);
			}
		}

		private void OnPressResetPrices()
		{
			string selectedBundleId = GetSelectedBundleId();
			if (selectedBundleId != null)
			{
				SoundManager.GenericConfirm(1f, 1f);
				maintenanceService.ResetPricesFor(selectedBundleId);
			}
		}

		private void OnPressUninstall()
		{
			string selectedBundleId = GetSelectedBundleId();
			if (selectedBundleId != null)
			{
				SoundManager.GenericConfirm(1f, 1f);
				RemovalResult removalResult = maintenanceService.UninstallBundle(selectedBundleId);
				if (!removalResult.IsSuccess)
				{
					ModLogger.Warning("Uninstall failed for '" + selectedBundleId + "': " + removalResult.ErrorMessage, "OnPressUninstall", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SettingsScreenService.cs");
				}
			}
		}

		private string? GetSelectedBundleId()
		{
			if ((Object)(object)bundleDropdown == (Object)null)
			{
				return null;
			}
			int value = bundleDropdown.value;
			List<string> list = EplRuntimeData.Assets.BundleRegistry.BundleInfo.Keys.ToList();
			if (value >= 0 && value < list.Count)
			{
				return list[value];
			}
			return null;
		}
	}
	internal class ShopService
	{
		private bool IsFurnitureUILoaded { get; set; }

		private bool IsItemUILoaded { get; set; }

		private bool IsBoardGameUILoaded { get; set; }

		private bool IsCheckPriceUILoaded { get; set; }

		internal void CreateAndRegisterCustomShops()
		{
			if (!PhoneOverhaulBridge.Instance.IsLoaded || EplRuntimeData.Assets.ShopLibrary.CustomShops.Count == 0)
			{
				return;
			}
			int num = 0;
			string key;
			CustomShopData value;
			foreach (KeyValuePair<string, CustomShopData> customShop in EplRuntimeData.Assets.ShopLibrary.CustomShops)
			{
				customShop.Deconstruct(out key, out value);
				CustomShopData shopData = value;
				foreach (ModRestockData item in EplRuntimeData.Assets.ItemLibrary.RestockEntries.Where((ModRestockData m) => m.PhoneAppId == shopData.PhoneAppId))
				{
					if ((item.ItemFlags & ItemFlags.TCG) != 0)
					{
						shopData.TCG.Add(item.RestockData);
					}
					if ((item.ItemFlags & ItemFlags.Accessory) != 0)
					{
						shopData.Accessories.Add(item.RestockData);
					}
					if ((item.ItemFlags & ItemFlags.Figurine) != 0)
					{
						shopData.Figurines.Add(item.RestockData);
					}
				}
				int num2 = Mathf.Max(shopData.TCG.Count, Mathf.Max(shopData.Accessories.Count, shopData.Figurines.Count));
				if (num2 > num)
				{
					num = num2;
				}
			}
			GameObject val = GameObject.Find("Canvas/RestockItemScreen_Grp");
			GameObject val2 = Object.Instantiate<GameObject>(val, val.transform.parent);
			Object.Destroy((Object)(object)val2.GetComponent<RestockItemScreen>());
			CustomShopScreen sharedScreen = val2.AddComponent<CustomShopScreen>();
			((Object)sharedScreen).name = "CustomShop_SharedScreen_Grp";
			((Component)sharedScreen).transform.SetSiblingIndex(val.transform.GetSiblingIndex());
			ShopService.SetupShopPanels<CustomShopScreen>(sharedScreen, num, 4, (Action<CustomShopScreen, Transform>)delegate(CustomShopScreen s, Transform panel)
			{
				((RestockItemScreen)s).m_RestockItemPanelUIList.Add(((Component)panel).GetComponent<RestockItemPanelUI>());
			});
			sharedScreen.InitializeControllerExtension();
			foreach (KeyValuePair<string, CustomShopData> customShop2 in EplRuntimeData.Assets.ShopLibrary.CustomShops)
			{
				customShop2.Deconstruct(out key, out value);
				CustomShopData customShopData = value;
				CustomShopData capturedData = customShopData;
				PhoneOverhaulBridge.Instance.RegisterApp(customShopData.PhoneAppId, customShopData.AppDisplayName, customShopData.AppIcon, customShopData.AppInnerBGImage, customShopData.AppOuterBGImage, delegate
				{
					sharedScreen.SwapTo(capturedData);
					UI_PhoneScreen component = GameObject.Find("CanvasWorldspaceFixedFOV/CanvasGrp/UI_PhoneScreen_Grp").GetComponent<UI_PhoneScreen>();
					SoundManager.PlayAudio("SFX_ButtonLightTap", 0.15f, 1f);
					((UIScreenBase)component).OpenChildScreen((UIScreenBase)(object)sharedScreen);
					PhoneManager.SetCanClosePhone(false);
					component.SetPhoneButtonRaycastEnable(false);
				});
			}
			EplRuntimeData.Events.ShopEvents.FireShopsReady();
		}

		internal void ClearShopItemLists()
		{
			EplRuntimeData.Assets.ShopLibrary.ItemShopLookup.Clear();
			foreach (var (_, customShopData2) in EplRuntimeData.Assets.ShopLibrary.CustomShops)
			{
				customShopData2.TCG.Clear();
				customShopData2.Accessories.Clear();
				customShopData2.Figurines.Clear();
			}
		}

		internal void ResetUIState()
		{
			ClearShopItemLists();
			IsFurnitureUILoaded = false;
			IsItemUILoaded = false;
			IsBoardGameUILoaded = false;
			IsCheckPriceUILoaded = false;
		}

		internal void SetupFurnitureShopUI(FurnitureShopUIScreen furnitureItemScreen)
		{
			if (!IsFurnitureUILoaded)
			{
				ShopService.SetupShopPanels<FurnitureShopUIScreen>(furnitureItemScreen, EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.Count, 3, (Action<FurnitureShopUIScreen, Transform>)delegate(FurnitureShopUIScreen s, Transform panel)
				{
					s.m_FurnitureShopPanelUIList.Add(((Component)panel).GetComponent<FurnitureShopPanelUI>());
				});
				IsFurnitureUILoaded = true;
			}
		}

		internal void SetupItemShopUI(RestockItemScreen restockItemScreen)
		{
			if (!IsItemUILoaded)
			{
				ShopService.SetupShopPanels<RestockItemScreen>(restockItemScreen, EplRuntimeData.Assets.ItemLibrary.ItemData.Count, 4, (Action<RestockItemScreen, Transform>)delegate(RestockItemScreen s, Transform panel)
				{
					s.m_RestockItemPanelUIList.Add(((Component)panel).GetComponent<RestockItemPanelUI>());
				});
				IsItemUILoaded = true;
			}
		}

		internal void SetupCheckPriceScreenUI(CheckPriceScreen checkPriceScreen)
		{
			if (!IsCheckPriceUILoaded)
			{
				ShopService.SetupShopPanels<CheckPriceScreen>(checkPriceScreen, EplRuntimeData.Assets.ItemLibrary.ItemData.Count, 4, (Action<CheckPriceScreen, Transform>)delegate(CheckPriceScreen s, Transform panel)
				{
					s.m_CheckPricePanelUIList.Add(((Component)panel).GetComponent<CheckPricePanelUI>());
				});
				IsCheckPriceUILoaded = true;
			}
		}

		internal void SetupBoardgameShopUI(RestockItemBoardGameScreen boardgameItemScreen)
		{
			if (!IsBoardGameUILoaded)
			{
				ShopService.SetupShopPanels<RestockItemBoardGameScreen>(boardgameItemScreen, EplRuntimeData.Assets.ItemLibrary.ItemData.Count, 4, (Action<RestockItemBoardGameScreen, Transform>)delegate(RestockItemBoardGameScreen s, Transform panel)
				{
					((RestockItemScreen)s).m_RestockItemPanelUIList.Add(((Component)panel).GetComponent<RestockItemPanelUI>());
				});
				IsBoardGameUILoaded = true;
			}
		}

		internal static void SetupShopPanels<T>(T shopUI, int itemCount, int itemsPerRow, Action<T, Transform> addPanel) where T : GenericSliderScreen
		{
			//IL_0051: 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_0065: 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_007e: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)(object)shopUI).transform.Find("ScreenGrp/AnimGrp/WebsiteContent_Grp/ScrollerGrp");
			Transform val2 = val.Find("HorizontalLayout");
			int result;
			int num = Math.DivRem(itemCount, itemsPerRow, out result);
			if (result != 0)
			{
				num++;
			}
			ControllerScreenUIExtension component = ((Component)(object)shopUI).GetComponent<ControllerScreenUIExtension>();
			for (int i = 0; i < num; i++)
			{
				Transform obj = Object.Instantiate<Transform>(val2, val);
				ControllerBtnList val3 = new ControllerBtnList
				{
					rowList = new List<ControllerButton>()
				};
				foreach (Transform item in obj)
				{
					Transform val4 = item;
					addPanel(shopUI, val4);
					val3.rowList.Add(((Component)val4).GetComponent<ControllerButton>());
				}
				if (component != null)
				{
					component.m_ControllerBtnColumnList.Add(val3);
					component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
				}
			}
		}
	}
	internal class WorkerPackOpenerScreenService
	{
		private WorkerSetPackOpenerTypeOptionScreen? screen;

		private FlowLayoutGroup? flowLayoutGroup;

		private ScrollRect? scrollRect;

		private bool isLoaded;

		internal bool IsLoaded
		{
			get
			{
				return isLoaded;
			}
			set
			{
				isLoaded = value;
				if (!value)
				{
					screen = null;
					flowLayoutGroup = null;
					scrollRect = null;
				}
			}
		}

		internal void OpenScreen(WorkerSetPackOpenerTypeOptionScreen workerSetPackOpenerTypeOptionScreen)
		{
			if (screen == null)
			{
				screen = workerSetPackOpenerTypeOptionScreen;
			}
			if (flowLayoutGroup == null)
			{
				flowLayoutGroup = InitFlowLayoutGroup();
			}
		}

		internal void LoadEplPackIcons()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (screen == null)
			{
				return;
			}
			List<EItemType> list = EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.Keys.OrderBy((EItemType k) => (int)k).ToList();
			int num = screen.m_WorkerPackTypeOptionPanelUIList.Count - list.Count;
			for (int i = 0; i < list.Count; i++)
			{
				EItemType key = list[i];
				if (EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(key, out ModItemData value))
				{
					StreamingAssetExtensions.SetSpriteAsync(screen.m_WorkerPackTypeOptionPanelUIList[num + i].m_Image, value.Icon);
				}
			}
		}

		internal void ResetScroll()
		{
			if (scrollRect != null && flowLayoutGroup != null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)flowLayoutGroup).GetComponent<RectTransform>());
				scrollRect.verticalNormalizedPosition = 1f;
			}
		}

		private FlowLayoutGroup? InitFlowLayoutGroup()
		{
			//IL_0094: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = screen.m_ScreenGrp.transform.Find("AnimGrp/UIGroup ");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			if (val == null)
			{
				ModLogger.Error("AnimGrp/UIGroup not found; layout wiring skipped.", "InitFlowLayoutGroup", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\WorkerPackOpenerScreenService.cs");
				return null;
			}
			if (((Transform)val).Find("WorkerPackTypeOptionPanelUI") == null)
			{
				ModLogger.Error("Failed to find a clonable panel.", "InitFlowLayoutGroup", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Services\\Internal\\WorkerPackOpenerScreenService.cs");
				return null;
			}
			Transform val2 = ((Transform)val).Find("BG") ?? ((Transform)val).Find("Background");
			if (val2 != null)
			{
				Object.Destroy((Object)(object)((Component)val2).gameObject);
			}
			GameObject val3 = FlowLayoutGroup.Create((Transform)(object)val, isScrollable: true);
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(0f, 80f);
			component.offsetMax = Vector2.zero;
			Image component2 = val3.GetComponent<Image>();
			if (component2 != null)
			{
				((Graphic)component2).color = new Color(0f, 0f, 0f, 0.75f);
			}
			scrollRect = val3.GetComponent<ScrollRect>();
			flowLayoutGroup = val3.GetComponentInChildren<FlowLayoutGroup>(true);
			List<Transform> list = (from Transform t in (IEnumerable)val
				where ((Object)t).name.Contains("HorizontalLayout")
				select t).ToList();
			float num;
			Rect rect;
			if (list.Count <= 0)
			{
				num = 400f;
			}
			else
			{
				rect = ((RectTransform)list[0]).rect;
				num = ((Rect)(ref rect)).height;
			}
			float childHeight = num;
			rect = val.rect;
			float width = ((Rect)(ref rect)).width;
			flowLayoutGroup.ChildWidth = width;
			flowLayoutGroup.ChildHeight = childHeight;
			flowLayoutGroup.SpacingX = 0f;
			flowLayoutGroup.SpacingY = -180f;
			flowLayoutGroup.CenterContent = false;
			((LayoutGroup)flowLayoutGroup).padding = new RectOffset(0, 0, 10, 10);
			foreach (Transform item2 in list)
			{
				flowLayoutGroup.AdoptExisting(item2);
			}
			List<EItemType> list2 = EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.Keys.OrderBy((EItemType k) => (int)k).ToList();
			if (list2.Count > 0 && list.Count > 0)
			{
				Transform val4 = list[0];
				int childCount = val4.childCount;
				int num2 = (list2.Count + childCount - 1) / childCount;
				int num3 = 0;
				for (int i = 0; i < num2; i++)
				{
					Transform val5 = flowLayoutGroup.AddFromTemplate(val4);
					for (int j = 0; j < childCount; j++)
					{
						Transform child = val5.GetChild(j);
						WorkerPackTypeOptionPanelUI component3 = ((Component)child).GetComponent<WorkerPackTypeOptionPanelUI>();
						if (num3 < list2.Count)
						{
							EItemType val6 = list2[num3];
							ModItemData value;
							ItemData item = (ItemData)(EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(val6, out value) ? ((object)value.BaseItemData) : ((object)new ItemData
							{
								affectedPriceChangeType = new List<EPriceChangeType>()
							}));
							screen.m_CardPackItemTypeList.Add(val6);
							screen.m_CardPackItemDataList.Add(item);
							screen.m_WorkerPackTypeOptionPanelUIList.Add(component3);
							num3++;
						}
						else
						{
							((Component)child).gameObject.SetActive(false);
						}
					}
				}
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)flowLayoutGroup).GetComponent<RectTransform>());
			return flowLayoutGroup;
		}

		private void UpdateControllerNavigation()
		{
			//IL_0055: 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_0069: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			if (screen == null || flowLayoutGroup == null)
			{
				return;
			}
			ControllerScreenUIExtension controllerScreenUIExtension = screen.m_ControllerScreenUIExtension;
			if (controllerScreenUIExtension == null)
			{
				return;
			}
			int itemsPerRow = flowLayoutGroup.ItemsPerRow;
			List<Transform> children = flowLayoutGroup.Children;
			controllerScreenUIExtension.m_ControllerBtnColumnList.Clear();
			controllerScreenUIExtension.m_CtrlBtnXChangeMethodList.Clear();
			for (int i = 0; i < children.Count; i += itemsPerRow)
			{
				ControllerBtnList val = default(ControllerBtnList);
				val.rowList = new List<ControllerButton>();
				ControllerBtnList val2 = val;
				int num = Mathf.Min(itemsPerRow, children.Count - i);
				for (int j = 0; j < num; j++)
				{
					ControllerButton component = ((Component)children[i + j]).GetComponent<ControllerButton>();
					if (component != null)
					{
						val2.rowList.Add(component);
					}
				}
				controllerScreenUIExtension.m_ControllerBtnColumnList.Add(val2);
				controllerScreenUIExtension.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Saves
{
	internal class EplSerializationBinder : ISerializationBinder
	{
		private readonly Dictionary<string, Type> typeToName = new Dictionary<string, Type>
		{
			{
				"item",
				typeof(ItemSaveData)
			},
			{
				"deco",
				typeof(DecoSaveData)
			},
			{
				"cardExpansion",
				typeof(CardExpansionSaveData)
			},
			{
				"savedata",
				typeof(SaveData)
			}
		};

		private readonly Dictionary<Type, string> nameToType = new Dictionary<Type, string>
		{
			{
				typeof(ItemSaveData),
				"item"
			},
			{
				typeof(DecoSaveData),
				"deco"
			},
			{
				typeof(CardExpansionSaveData),
				"cardExpansion"
			},
			{
				typeof(SaveData),
				"savedata"
			}
		};

		public Type BindToType(string? assemblyName, string typeName)
		{
			if (!typeToName.TryGetValue(typeName, out Type value))
			{
				throw new InvalidOperationException("Unauthorized type resolution attempted for '" + typeName + "'.");
			}
			return value;
		}

		public void BindToName(Type serializedType, out string? assemblyName, out string? typeName)
		{
			assemblyName = null;
			if (!nameToType.TryGetValue(serializedType, out typeName))
			{
				throw new InvalidOperationException("Cannot serialize unmapped type: " + serializedType.Name);
			}
		}
	}
	internal class SaveData
	{
		[JsonProperty("Data")]
		private Dictionary<string, EplBaseSaveData?> data = new Dictionary<string, EplBaseSaveData>();

		internal T? GetData<T>(string key) where T : EplBaseSaveData
		{
			if (!data.TryGetValue(key, out EplBaseSaveData value))
			{
				return null;
			}
			return value as T;
		}

		internal void SetData<T>(string key, T? value) where T : EplBaseSaveData
		{
			data[key] = value;
		}

		internal IEnumerable<string> GetKeys()
		{
			return data.Keys;
		}

		internal bool ContainsKey(string key)
		{
			return data.ContainsKey(key);
		}

		internal void MergeFrom(SaveData other)
		{
			foreach (KeyValuePair<string, EplBaseSaveData> datum in other.data)
			{
				data[datum.Key] = datum.Value;
			}
		}

		internal void ResetData()
		{
			foreach (KeyValuePair<string, EplBaseSaveData> datum in data)
			{
				if (datum.Value is IResettable resettable)
				{
					resettable.Reset();
				}
			}
		}
	}
	internal class SaveDataReconciler
	{
		internal void Reconcile(Dictionary<string, SaveData> loadedData, Dictionary<string, SaveData> currentBundleData)
		{
			foreach (var (_, saveData2) in loadedData)
			{
				foreach (string key in saveData2.GetKeys())
				{
					string text2 = FindTargetModId(key, currentBundleData);
					if (text2 != null)
					{
						currentBundleData[text2].SetData(key, saveData2.GetData<EplBaseSaveData>(key));
					}
				}
			}
		}

		private string? FindTargetModId(string key, Dictionary<string, SaveData> currentBundleData)
		{
			foreach (var (result, saveData2) in currentBundleData)
			{
				if (saveData2.ContainsKey(key))
				{
					return result;
				}
			}
			return null;
		}
	}
	internal class SaveDataSerialization
	{
		private readonly JsonSerializerSettings serializerSettings = new JsonSerializerSettings
		{
			TypeNameHandling = (TypeNameHandling)4,
			Formatting = (Formatting)1,
			SerializationBinder = (ISerializationBinder)(object)new EplSerializationBinder()
		};

		private static readonly Dictionary<string, string> LegacyTypeRewrites = new Dictionary<string, string>
		{
			{ "EnhancedPrefabLoader.Models.SaveData.ItemSaveData", "item" },
			{ "EnhancedPrefabLoader.Models.SaveData.DecoSaveData", "deco" },
			{ "EnhancedPrefabLoader.Models.SaveData.CardExpansionSaveData", "cardExpansion" },
			{ "EnhancedPrefabLoader.Saves.ModSaveData", "savedata" }
		};

		internal Dictionary<string, SaveData>? LoadFromFile(string filePath)
		{
			if (!File.Exists(filePath))
			{
				ModLogger.Warning("No save file found at path " + filePath, "LoadFromFile", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
				return null;
			}
			try
			{
				JToken obj = JToken.Parse(File.ReadAllText(filePath));
				NormalizeTypeAnnotations(obj);
				return obj.ToObject<Dictionary<string, SaveData>>(JsonSerializer.Create(serializerSettings));
			}
			catch (Exception ex)
			{
				ModLogger.Error("Failed to load save file " + filePath + ": " + ex.Message, "LoadFromFile", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
				return null;
			}
		}

		private static void NormalizeTypeAnnotations(JToken token)
		{
			JObject val = (JObject)(object)((token is JObject) ? token : null);
			if (val != null)
			{
				JProperty val2 = val.Property("$type");
				if (val2 != null)
				{
					string text = ((object)val2.Value).ToString();
					string key = text.Split(',')[0].Trim();
					if (LegacyTypeRewrites.TryGetValue(key, out string value))
					{
						val2.Value = JToken.op_Implicit(value);
					}
					else if (text.Contains('.') || text.Contains(','))
					{
						((JToken)val2).Remove();
					}
				}
				{
					foreach (JProperty item in val.Properties())
					{
						NormalizeTypeAnnotations(item.Value);
					}
					return;
				}
			}
			JArray val3 = (JArray)(object)((token is JArray) ? token : null);
			if (val3 == null)
			{
				return;
			}
			foreach (JToken item2 in val3)
			{
				NormalizeTypeAnnotations(item2);
			}
		}

		internal void SaveToFile(Dictionary<string, SaveData> saveData, string filePath)
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)saveData, serializerSettings);
				File.WriteAllText(filePath, contents);
			}
			catch (Exception ex)
			{
				ModLogger.Error("Failed to save file " + filePath + ": " + ex.Message, "SaveToFile", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Registry
{
	internal class BundleAssetTracker
	{
		private readonly Dictionary<Type, Dictionary<object, string>> enumTrackers = new Dictionary<Type, Dictionary<object, string>>();

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

		internal void Register<TEnum>(string modId, TEnum enumValue) where TEnum : Enum
		{
			Type typeFromHandle = typeof(TEnum);
			enumTrackers.GetOrAdd(typeFromHandle, (Type _) => new Dictionary<object, string>())[enumValue] = modId;
		}

		internal void Register(string modId, string category, string assetName)
		{
			nameTrackers.GetOrAdd(category, (string _) => new Dictionary<string, string>())[assetName] = modId;
		}

		internal string? GetBundleIdFor<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			if (!enumTrackers.TryGetValue(typeof(TEnum), out Dictionary<object, string> value) || !value.TryGetValue(enumValue, out var value2))
			{
				return null;
			}
			return value2;
		}

		internal string? GetBundleIdFor(string category, string assetName)
		{
			if (!nameTrackers.TryGetValue(category, out Dictionary<string, string> value) || !value.TryGetValue(assetName, out var value2))
			{
				return null;
			}
			return value2;
		}

		internal HashSet<T> GetEnumValuesForBundle<T>(string bundleId) where T : Enum
		{
			if (!enumTrackers.TryGetValue(typeof(T), out Dictionary<object, string> value))
			{
				return new HashSet<T>();
			}
			HashSet<T> hashSet = new HashSet<T>();
			foreach (var (obj2, text2) in value)
			{
				if (text2 == bundleId)
				{
					hashSet.Add((T)obj2);
				}
			}
			return hashSet;
		}

		internal HashSet<string> GetNamedAssetsForBundle(string bundleId, string category)
		{
			if (!nameTrackers.TryGetValue(category, out Dictionary<string, string> value))
			{
				return new HashSet<string>();
			}
			HashSet<string> hashSet = new HashSet<string>();
			foreach (var (item, text3) in value)
			{
				if (text3 == bundleId)
				{
					hashSet.Add(item);
				}
			}
			return hashSet;
		}
	}
	internal class BundleRegistry : IBundleRegistry
	{
		[CompilerGenerated]
		private BundleAssetTracker <assetTracker>P;

		private readonly Dictionary<string, BundleInfo> bundleInfo;

		public IReadOnlyDictionary<string, BundleInfo> BundleInfo => bundleInfo;

		public BundleRegistry(BundleAssetTracker assetTracker)
		{
			<assetTracker>P = assetTracker;
			bundleInfo = new Dictionary<string, BundleInfo>();
			base..ctor();
		}

		internal void RegisterBundle(BundleInfo bundleInfo)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0063: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			foreach (EItemType itemType in bundleInfo.itemTypes)
			{
				<assetTracker>P.Register<EItemType>(bundleInfo.BundleId, itemType);
			}
			foreach (EObjectType furnitureType in bundleInfo.furnitureTypes)
			{
				<assetTracker>P.Register<EObjectType>(bundleInfo.BundleId, furnitureType);
			}
			foreach (EDecoObject decoObject in bundleInfo.decoObjects)
			{
				<assetTracker>P.Register<EDecoObject>(bundleInfo.BundleId, decoObject);
			}
			foreach (ECardExpansionType expansionType in bundleInfo.expansionTypes)
			{
				<assetTracker>P.Register<ECardExpansionType>(bundleInfo.BundleId, expansionType);
			}
			DecoFlags val;
			foreach (string wallTexture in bundleInfo.wallTextures)
			{
				BundleAssetTracker bundleAssetTracker = <assetTracker>P;
				string bundleId = bundleInfo.BundleId;
				val = (DecoFlags)2;
				bundleAssetTracker.Register(bundleId, ((object)(DecoFlags)(ref val)).ToString(), wallTexture);
			}
			foreach (string ceilingTexture in bundleInfo.ceilingTextures)
			{
				BundleAssetTracker bundleAssetTracker2 = <assetTracker>P;
				string bundleId2 = bundleInfo.BundleId;
				val = (DecoFlags)3;
				bundleAssetTracker2.Register(bundleId2, ((object)(DecoFlags)(ref val)).ToString(), ceilingTexture);
			}
			foreach (string floorTexture in bundleInfo.floorTextures)
			{
				BundleAssetTracker bundleAssetTracker3 = <assetTracker>P;
				string bundleId3 = bundleInfo.BundleId;
				val = (DecoFlags)1;
				bundleAssetTracker3.Register(bundleId3, ((object)(DecoFlags)(ref val)).ToString(), floorTexture);
			}
			this.bundleInfo[bundleInfo.BundleId] = bundleInfo;
		}

		public string? GetBundleIdFor<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			return <assetTracker>P.GetBundleIdFor(enumValue);
		}

		public string? GetBundleIdFor(DecoFlags category, string assetName)
		{
			return <assetTracker>P.GetBundleIdFor(((object)(DecoFlags)(ref category)).ToString(), assetName);
		}

		public bool IsEplAsset<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			return <assetTracker>P.GetBundleIdFor(enumValue) != null;
		}

		public bool IsEplAsset(string category, string assetName)
		{
			return <assetTracker>P.GetBundleIdFor(category, assetName) != null;
		}

		public bool HasRegisteredRestockData(EItemType itemType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.LookupLibrary.RestockDataLookup.TryGetValue(itemType, out List<RestockData> value))
			{
				return value.Count > 0;
			}
			return false;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("EnhancedPrefabLoader.Core.Properties.Resources", typeof(Resources).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] CardMask => (byte[])ResourceManager.GetObject("CardMask", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace EnhancedPrefabLoader.Core.PatchesTODO
{
	[HarmonyPatch(typeof(CardUI))]
	public class CardUIPatches
	{
		[HarmonyPatch("SetCardUI")]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0094: 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_00b4: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(1).RemoveInstruction().InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				})
					.RemoveInstruction();
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("SetCardUI")]
		[HarmonyPriority(800)]
		[HarmonyPrefix]
		private static void SetCardUIPrefix(CardUI __instance, CardData cardData)
		{
			//IL_0010: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				EplRuntimeData.Services.cardUIService.RestoreOriginalCardUI(__instance, cardData);
			}
			else
			{
				cardData.borderType = (ECardBorderType)5;
			}
		}

		[HarmonyPatch("SetCardUI")]
		[HarmonyPriority(800)]
		[HarmonyPostfix]
		private static void SetCardUIPostfix(CardUI __instance, CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(__instance.m_CenterFrameImage, value.Cards[cardData.monsterType].Icon);
				EplRuntimeData.Services.cardUIService.ApplyEplCardUI(__instance, cardData);
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Patches
{
	[HarmonyPatch(typeof(BulkDonationBoxQuickFillScreen))]
	internal class BulkDonationBoxQuickFillScreenPatches
	{
		[HarmonyPatch("RunBundleCardBulkFunction")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RunBundleCardBulkFunctionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_008b: 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_00ab: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[2]
			{
				typeof(ECardExpansionType),
				typeof(EMonsterType)
			}, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(EMonsterType));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				}).RemoveInstruction();
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("OnPressChangeRarityButton")]
		[HarmonyPostfix]
		private static void OnPressChangeRarityButtonPostfix(BulkDonationBoxQuickFillScreen __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			EplRuntimeData.Services.CardRaritySelectService.OpenScreen(__instance.m_CurrentCardExpansionType);
		}

		[HarmonyPatch("OnCardExpansionUpdated")]
		[HarmonyPostfix]
		private static void OnCardExpansionUpdatedPostfix(BulkDonationBoxQuickFillScreen __instance, CEventPlayer_OnCardExpansionSelectScreenUpdated evt)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			__instance.OnRarityLimitUpdated(new CEventPlayer_OnCardRaritySelectScreenUpdated(-1));
		}
	}
	[HarmonyPatch(typeof(Card3dUIGroup))]
	public class Card3dUIGroupPatches
	{
		[HarmonyPatch("EvaluateCardGrade")]
		[HarmonyPostfix]
		private static void EvaluateCardGradePostfix(Card3dUIGroup __instance, CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				((TMP_Text)__instance.m_GradeExpansionRarityText).text = value.Name + " " + CPlayerData.GetFullCardTypeName(cardData, false);
			}
		}
	}
	[HarmonyPatch(typeof(CardExpansionSelectScreen))]
	internal class CardExpansionSelectScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyPrefix]
		private static bool OpenScreenPrefix(ECardExpansionType initCardExpansion)
		{
			EplRuntimeData.Services.CardExpansionSelectService.OpenScreen();
			SoundManager.GenericMenuOpen(1f, 1f);
			CSingleton<CardExpansionSelectScreen>.Instance.m_ScreenGrp.SetActive(true);
			ControllerScreenUIExtManager.OnOpenScreen(CSingleton<CardExpansionSelectScreen>.Instance.m_ControllerScreenUIExtension);
			return false;
		}

		[HarmonyPatch("OpenScreen")]
		[HarmonyPostfix]
		private static void OpenScreenPostfix(ECardExpansionType initCardExpansion)
		{
			Canvas.ForceUpdateCanvases();
		}
	}
	[HarmonyPatch(typeof(CardFanRandomizer))]
	internal class CardFanRandomizerPatches
	{
		[HarmonyPatch("RandomizePlayCard")]
		[HarmonyPrefix]
		private static bool RandomizePlayCardPrefix(CardFanRandomizer __instance)
		{
			foreach (GameObject cardFanGrp in __instance.m_CardFanGrpList)
			{
				cardFanGrp.SetActive(false);
			}
			__instance.m_CardFanGrpList[Random.Range(0, __instance.m_CardFanGrpList.Count)].SetActive(true);
			List<Material> list = null;
			Customer componentInParent = ((Component)__instance).GetComponentInParent<Customer>();
			if (componentInParent != null)
			{
				InteractablePlayTable currentPlayTable = componentInParent.m_CurrentPlayTable;
				if (currentPlayTable != null && EplRuntimeData.Caches.PlayTableExpansionCache.TryGetValue(currentPlayTable, out List<Material> value))
				{
					list = value;
				}
			}
			if (list == null)
			{
				Dictionary<List<Material>, float> dictionary = EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Where<KeyValuePair<ECardExpansionType, ModCardExpansionData>>((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => kvp.Value.PlayCardMaterials.Count > 0).ToDictionary((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => kvp.Value.PlayCardMaterials, (KeyValuePair<ECardExpansionType, ModCardExpansionData> _) => 1f);
				if (dictionary.Count == 0 || !EplRuntimeData.Config.DisableBaseGamePlayCards)
				{
					dictionary[__instance.m_PlayCardMatList] = 1f;
				}
				list = RandomUtils.Weighted(dictionary);
			}
			foreach (MeshRenderer meshRenderer in __instance.m_MeshRendererList)
			{
				((Renderer)meshRenderer).material = list[Random.Range(0, list.Count)];
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CardOpeningSequence))]
	public class CardOpeningSequencePatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyPrefix]
		private static bool OpenScreenPrefix(CardOpeningSequence __instance, ECollectionPackType collectionPackType, bool isMultiPack, bool isPremiumPack)
		{
			//IL_000f: 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_0024: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionLookup.TryGetValue(collectionPackType, out var _))
			{
				return true;
			}
			__instance.m_IsScreenActive = true;
			__instance.m_CollectionPackType = collectionPackType;
			__instance.m_IsNewlList.Clear();
			__instance.m_TotalExpGained = 0;
			__instance.m_TotalCardValue = 0f;
			__instance.m_HasFoilCard = false;
			__instance.m_StateIndex = 0;
			__instance.m_ManualOpenCardDataList.Clear();
			__instance.m_CardValueList.Clear();
			__instance.m_CurrentOpenedCardIndex = 0;
			if (EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.ContainsKey(__instance.m_CurrentItem.GetItemType()))
			{
				foreach (Card3dUIGroup card3dUI in __instance.m_Card3dUIList)
				{
					((Component)card3dUI).gameObject.SetActive(false);
				}
				int num = 0;
				foreach (CardData item in EplRuntimeData.Services.itemService.GeneratePackContent(__instance.m_CurrentItem.GetItemType()))
				{
					__instance.m_HasFoilCard = __instance.m_HasFoilCard || item.isFoil;
					__instance.m_ManualOpenCardDataList.Add(item);
					__instance.m_CardValueList.Add(CPlayerData.GetCardMarketPrice(item));
					__instance.m_Card3dUIList[num].m_CardUI.SetCardUI(item);
					__instance.m_IsNewlList.Add(CSingleton<CGameManager>.Instance.m_OpenPackShowNewCard && item.isNew);
					CPlayerData.AddCard(item, 1);
					num++;
				}
				CSingleton<InteractionPlayerController>.Instance.m_CollectionBinderFlipAnimCtrl.SetCanUpdateSort(true);
			}
			return false;
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_005a: 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_007a: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardOpeningSequence), "m_ManualOpenCardDataList");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CardOpeningSequence), "m_TotalExpGained");
			MethodInfo methodInfo = AccessTools.Method(typeof(List<CardData>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CardOpeningSequencePatches), "ProcessCardExp", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				int num = val.Pos + 1;
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null)
				});
				if (val.IsValid)
				{
					int pos = val.Pos;
					List<CodeInstruction> list = val.Instructions();
					CodeInstruction val2 = new CodeInstruction(OpCodes.Stloc_S, (object)(byte)10);
					for (int i = num; i < pos; i++)
					{
						if (list[i].opcode == OpCodes.Stloc_S)
						{
							val2 = new CodeInstruction(OpCodes.Stloc_S, list[i].operand);
							break;
						}
					}
					val.Start().Advance(num).RemoveInstructions(pos - num)
						.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
						{
							new CodeInstruction(OpCodes.Call, (object)methodInfo2),
							val2
						});
				}
			}
			return val.InstructionEnumeration();
		}

		private static int ProcessCardExp(CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected I4, but got Unknown
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				return (int)EplRuntimeData.Services.cardExpansionService.GenerateCardExp(cardData);
			}
			if (EplRuntimeData.Config.UseCustomExpForBase)
			{
				return (int)new CardExpGenerator().CalculateExp(cardData);
			}
			? val = cardData.GetCardBorderType() + 1;
			return val * Mathf.CeilToInt((float)val / 2f) * ((!cardData.isFoil) ? 1 : 8);
		}
	}
	[HarmonyPatch(typeof(CardRaritySelectScreen))]
	internal class CardRaritySelectScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OpenScreenTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(List<GameObject>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(GameObject), "SetActive", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardRaritySelectScreen), "m_CurrentIndex");
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Stloc_0, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Br || i.opcode == OpCodes.Br_S), (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
				});
				if (val.IsValid)
				{
					int num = val.Pos + 1;
					val.Start().Advance(pos).RemoveInstructions(num - pos);
				}
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CardShelf))]
	public class CardShelfPatches
	{
		[HarmonyPatch("LoadCardCompartment")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LoadCardCompartmentTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(List<CardData>), "Item");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CardShelfPatches), "ShouldProcessCard", (Type[])null, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(CSingleton<Card3dUISpawner>), "Instance");
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo3, (string)null)
			});
			if (val.IsValid)
			{
				Label label = il.DefineLabel();
				val.AddLabels((IEnumerable<Label>)new <>z__ReadOnlySingleElementList<Label>(label)).Start().MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
				})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
					{
						new CodeInstruction(OpCodes.Ldarg_1, (object)null),
						new CodeInstruction(OpCodes.Ldloc_1, (object)null),
						new CodeInstruction(OpCodes.Callvirt, (object)methodInfo),
						new CodeInstruction(OpCodes.Call, (object)methodInfo2),
						new CodeInstruction(OpCodes.Brtrue, (object)label)
					});
			}
			return val.InstructionEnumeration();
		}

		private static bool ShouldProcessCard(CardData cardData)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (cardData != null)
			{
				return EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CGameManager))]
	internal class CGameManagerPatches
	{
		[CompilerGenerated]
		private sealed class <LoadLobbySceneAsyncPostfix>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IEnumerator __result;

			public CGameManager __instance;

			public string sceneName;

			private LoadingScreenMessageService <loadingScreenMessages>5__2;

			private BundleLoadingManager <loadManager>5__3;

			private float <displayedProgress>5__4;

			private AsyncOperation <asyncLoad>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<loadingScreenMessages>5__2 = null;
				<loadManager>5__3 = null;
				<asyncLoad>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					__result.MoveNext();
					<>2__current = __result.Current;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<loadingScreenMessages>5__2 = new LoadingScreenMessageService();
					<loadingScreenMessages>5__2.Initialize();
					<loadingScreenMessages>5__2.Start((MonoBehaviour)(object)__instance);
					<loadManager>5__3 = new BundleLoadingManager();
					((MonoBehaviour)__instance).StartCoroutine(<loadManager>5__3.LoadBundlesAsync(Paths.PluginPath));
					<displayedProgress>5__4 = 0f;
					goto IL_00fe;
				case 2:
					<>1__state = -1;
					goto IL_00fe;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_00fe:
					if (!<loadManager>5__3.isLoadingComplete)
					{
						<displayedProgress>5__4 = Mathf.MoveTowards(<displayedProgress>5__4, <loadManager>5__3.LoadingProgress, Time.deltaTime * 0.4f);
						LoadingScreen.SetPercentDone((int)(<displayedProgress>5__4 * 50f));
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					LoadingScreen.SetPercentDone(50);
					<asyncLoad>5__5 = SceneManager.LoadSceneAsync(sceneName);
					break;
				}
				if (!<asyncLoad>5__5.isDone)
				{
					float num = <asyncLoad>5__5.progress / 0.9f;
					LoadingScreen.SetPercentDone(50 + (int)(num * 50f));
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				<loadingScreenMessages>5__2.Stop((MonoBehaviour)(object)__instance);
				return false;
			}

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

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

		[IteratorStateMachine(typeof(<LoadLobbySceneAsyncPostfix>d__0))]
		[HarmonyPatch("LoadLobbySceneAsync")]
		[HarmonyPostfix]
		private static IEnumerator LoadLobbySceneAsyncPostfix(IEnumerator __result, string sceneName, CGameManager __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadLobbySceneAsyncPostfix>d__0(0)
			{
				__result = __result,
				sceneName = sceneName,
				__instance = __instance
			};
		}
	}
	[HarmonyPatch(typeof(CheckPricePanelUI))]
	public class CheckPricePanelUIPatches
	{
		[HarmonyPatch("InitCard")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitCardTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			ConstructorInfo constructorInfo = AccessTools.Constructor(typeof(CardData), (Type[])null, false);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "expansionType");
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo eplRuntimeServiceGet = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo cardExpansionServiceGet = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo getMonsterDataMethod = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CardDataFactory), "Create", (Type[])null, (Type[])null);
			LocalBuilder localCardData = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Newobj, (object)constructorInfo, (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Stfld, (object)fieldInfo, (string)null)
				});
				if (val.IsValid)
				{
					int pos2 = val.Pos;
					val.Start().Advance(pos).RemoveInstructions(pos2 - pos + 1)
						.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
						{
							new CodeInstruction(OpCodes.Ldarg_2, (object)null),
							new CodeInstruction(OpCodes.Ldarg_3, (object)null),
							new CodeInstruction(OpCodes.Ldarg, (object)4),
							new CodeInstruction(OpCodes.Ldarg, (object)5),
							new CodeInstruction(OpCodes.Call, (object)methodInfo2),
							new CodeInstruction(OpCodes.Stloc_0, (object)null)
						})
						.Start()
						.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
						{
							new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
							new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
							new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
						})
						.Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
						{
							//IL_0020: Unknown result type (might be due to invalid IL or missing references)
							//IL_0026: Expected O, but got Unknown
							//IL_0033: Unknown result type (might be due to invalid IL or missing references)
							//IL_0039: Expected O, but got Unknown
							//IL_0046: Unknown result type (might be due to invalid IL or missing references)
							//IL_004c: Expected O, but got Unknown
							//IL_0059: Unknown result type (might be due to invalid IL or missing references)
							//IL_005f: Expected O, but got Unknown
							//IL_006c: Unknown result type (might be due to invalid IL or missing references)
							//IL_0072: Expected O, but got Unknown
							matcher.Advance(1).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
							{
								new CodeInstruction(OpCodes.Stloc_S, (object)localCardData),
								new CodeInstruction(OpCodes.Call, (object)eplRuntimeServiceGet),
								new CodeInstruction(OpCodes.Callvirt, (object)cardExpansionServiceGet),
								new CodeInstruction(OpCodes.Ldloc_S, (object)localCardData),
								new CodeInstruction(OpCodes.Callvirt, (object)getMonsterDataMethod)
							});
						}, (Action<string>)null);
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("InitItem")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitItemTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(CheckPricePanelUI), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CheckPricePanelUI), "m_ItemType");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CheckPriceScreen))]
	internal class CheckPriceScreenPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyPrefix]
		private static void InitPrefix(CheckPriceScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupCheckPriceScreenUI(__instance);
		}

		[HarmonyPatch("EvaluateItemPanelUI")]
		[HarmonyPostfix]
		private static void EvaluateItemPanelUIPostfix(CheckPriceScreen __instance, int pageIndex)
		{
			//IL_0050: 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)
			ShopInventoryManager shopInventoryManager = EplRuntimeData.Services.ShopInventoryManager;
			List<EItemType> customShopItemsForCheckPricePage = shopInventoryManager.GetCustomShopItemsForCheckPricePage(pageIndex);
			if (customShopItemsForCheckPricePage.Count == 0)
			{
				return;
			}
			int baseGameItemCountForCheckPricePage = shopInventoryManager.GetBaseGameItemCountForCheckPricePage(pageIndex);
			for (int i = 0; i < customShopItemsForCheckPricePage.Count; i++)
			{
				int num = baseGameItemCountForCheckPricePage + i;
				if (num < __instance.m_CheckPricePanelUIList.Count)
				{
					CheckPricePanelUI val = __instance.m_CheckPricePanelUIList[num];
					val.InitItem(__instance, customShopItemsForCheckPricePage[i]);
					((UIElementBase)val).SetActive(true);
					__instance.m_ScrollEndParent.transform.parent = ((Component)val).transform;
					__instance.m_ScrollEndParent.transform.position = ((Component)val).transform.position;
					((GenericSliderScreen)__instance).m_ScrollEndPosParent = __instance.m_ScrollEndParent;
					continue;
				}
				break;
			}
		}
	}
	[HarmonyPatch(typeof(CollectionBinderFlipAnimCtrl))]
	public class CollectionBinderFlipAnimCtrlPatches
	{
		[HarmonyPatch("UpdateBinderAllCardUI")]
		[HarmonyPrefix]
		private static bool UpdateBinderAllCardUIPrefix(CollectionBinderFlipAnimCtrl __instance, int binderIndex, int pageIndex)
		{
			//IL_0010: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(__instance.m_ExpansionType, out ModCardExpansionData value))
			{
				return true;
			}
			for (int i = 0; i < __instance.m_BinderPageGrpList[binderIndex].m_CardList.Count; i++)
			{
				if (pageIndex <= 0 || pageIndex > __instance.m_MaxIndex)
				{
					return false;
				}
				__instance.m_BinderPageGrpList[binderIndex].SetSingleCard(i, (CardData)null, 0, __instance.m_SortingType);
				int num = (pageIndex - 1) * 12 + i;
				if (num < __instance.m_SortedIndexList.Count)
				{
					int num2 = __instance.m_SortedIndexList[num];
					CardData val = ((IEnumerable<KeyValuePair<EMonsterType, ModCardData>>)value.Cards.OrderBy<KeyValuePair<EMonsterType, ModCardData>, EMonsterType>((KeyValuePair<EMonsterType, ModCardData> kvp) => kvp.Value.MonsterData.MonsterType)).Select((Func<KeyValuePair<EMonsterType, ModCardData>, CardData>)((KeyValuePair<EMonsterType, ModCardData> kvp) => kvp.Value)).ToList()[value.HasRandomFoils ? (num2 >> 1) : num2];
					if (value.HasRandomFoils)
					{
						val.isFoil = (num2 & 1) == 1;
					}
					int cardAmountByIndex = CPlayerData.GetCardAmountByIndex(num2, val.expansionType, false);
					__instance.m_BinderPageGrpList[binderIndex].SetSingleCard(i, val, cardAmountByIndex, __instance.m_SortingType);
				}
			}
			return false;
		}

		[HarmonyPatch("EnterViewUpCloseState")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EnterViewUpCloseStateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0094: 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_00b4: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(1).RemoveInstruction().InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				})
					.RemoveInstruction();
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("SortByCardRarity")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SortByCardRarityTranspilier(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo expansionTypeField = AccessTools.Field(typeof(CollectionBinderFlipAnimCtrl), "m_ExpansionType");
			MethodInfo eplRuntimeServiceGet = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo cardExpansionServiceGet = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo getMonsterDataMethod = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[2]
			{
				typeof(ECardExpansionType),
				typeof(EMonsterType)
			}, (Type[])null);
			LocalBuilder localMonsterType = il.DeclareLocal(typeof(EMonsterType));
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Expected O, but got Unknown
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[7]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localMonsterType),
					new CodeInstruction(OpCodes.Call, (object)eplRuntimeServiceGet),
					new CodeInstruction(OpCodes.Callvirt, (object)cardExpansionServiceGet),
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)expansionTypeField),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localMonsterType),
					new CodeInstruction(OpCodes.Callvirt, (object)getMonsterDataMethod)
				}).RemoveInstruction();
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CollectionBinderUI))]
	internal class CollectionBinderUIPatches
	{
		[HarmonyPatch("OpenSortAlbumScreen")]
		[HarmonyPrefix]
		private static void OpenSortAlbumScreenPrefix(CollectionBinderUI __instance, int sortingMethodIndex, int currentExpansionIndex, bool isGradedCardAlbum)
		{
			EplRuntimeData.Services.CollectionBinderService.OpenScreen(__instance);
		}

		[HarmonyPatch("OpenSortAlbumScreen")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OpenSortAlbumScreenTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_3, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction op) => op.opcode == OpCodes.Brfalse || op.opcode == OpCodes.Brfalse_S), (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null)
				});
				if (val.IsValid)
				{
					int num = val.Pos + 1;
					val.Start().Advance(pos).RemoveInstructions(num - pos);
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("OpenSortAlbumScreen")]
		[HarmonyPostfix]
		private static void OpenSortAlbumScreenPostfix(int sortingMethodIndex, int currentExpansionIndex, bool isGradedCardAlbum)
		{
			Canvas.ForceUpdateCanvases();
		}
	}
	[HarmonyPatch(typeof(CPlayerData))]
	public class CPlayerDataPatches
	{
		[HarmonyPatch("GetCardCollectedList")]
		[HarmonyPrefix]
		private static bool GetCardCollectedListPrefix(ECardExpansionType expansionType, bool isDimension, ref List<int>? __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data?.CardCountList;
			return false;
		}

		[HarmonyPatch("GetIsCardCollectedList")]
		[HarmonyPrefix]
		private static bool GetIsCardCollectedListPrefix(ECardExpansionType expansionType, bool isDimension, ref List<bool>? __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data?.IsCardCollectedList;
			return false;
		}

		[HarmonyPatch("GetCardMarketPrice", new Type[]
		{
			typeof(int),
			typeof(ECardExpansionType),
			typeof(bool),
			typeof(int)
		})]
		[HarmonyPrefix]
		private static bool GetCardMarketPricePrefix(int index, ECardExpansionType expansionType, bool isDestiny, int cardGrade, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardMarketPriceList[index].GetMarketPrice(index, cardGrade);
			return false;
		}

		[HarmonyPatch("GetCardMarketPrice", new Type[] { typeof(CardData) })]
		[HarmonyPrefix]
		private static bool GetCardMarketPricePrefix(CardData cardData, ref float __result)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			__result = data.CardMarketPriceList[cardSaveIndex].GetMarketPrice(cardSaveIndex, cardData.cardGrade);
			return false;
		}

		[HarmonyPatch("GetCardAmountPerMonsterType")]
		[HarmonyPrefix]
		private static bool GetCardAmountPerMonsterTypePrefix(ECardExpansionType expansionType, bool includeFoilCount, ref int __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			__result = ((!(value.HasRandomFoils && includeFoilCount)) ? 1 : 2);
			return false;
		}

		[HarmonyPatch("GetCardBorderType")]
		[HarmonyPrefix]
		private static bool GetCardBorderTypePrefix(int borderTypeIndex, ECardExpansionType expansionType, ref ECardBorderType __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType))
			{
				return true;
			}
			__result = (ECardBorderType)borderTypeIndex;
			return false;
		}

		[HarmonyPatch("GetCardSaveIndex")]
		[HarmonyPrefix]
		private static bool GetCardSaveIndex(CardData cardData, ref int __result)
		{
			//IL_0010: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			__result = value.Cards.Keys.OrderBy((EMonsterType key) => (int)key).ToList().IndexOf(cardData.monsterType);
			if (value.HasRandomFoils)
			{
				__result = __result * 2 + (cardData.isFoil ? 1 : 0);
			}
			return false;
		}

		[HarmonyPatch("GetCardPrice")]
		[HarmonyPrefix]
		private static bool GetCardPricePrefix(CardData cardData, ref float __result)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			double value = ((cardData.cardGrade > 0) ? ((double)data.GradedCardPriceList[cardSaveIndex][cardData.cardGrade - 1]) : ((double)data.CardPriceList[cardSaveIndex]));
			value = ((GameInstance.GetCurrencyConversionRate() > 1f) ? Math.Round(value, 3, MidpointRounding.AwayFromZero) : Math.Round(value, 2, MidpointRounding.AwayFromZero));
			__result = (float)value;
			return false;
		}

		[HarmonyPatch("GetCardPriceUsingIndex")]
		[HarmonyPrefix]
		private static bool GetCardPriceUsingIndexPrefix(int index, ECardExpansionType expansionType, bool isDestiny, int cardGrade, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			double value = ((cardGrade > 0) ? ((double)data.GradedCardPriceList[index][cardGrade - 1]) : ((double)data.CardPriceList[index]));
			value = ((GameInstance.GetCurrencyConversionRate() > 1f) ? Math.Round(value, 3, MidpointRounding.AwayFromZero) : Math.Round(value, 2, MidpointRounding.AwayFromZero));
			__result = (float)value;
			return false;
		}

		[HarmonyPatch("SetCardPrice")]
		[HarmonyPrefix]
		private static bool SetCardPricePrefix(CardData cardData, float priceSet)
		{
			//IL_000b: 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: Expected O, but got Unknown
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			if (cardData.cardGrade > 0)
			{
				if (data != null)
				{
					data.GradedCardPriceList[cardSaveIndex][cardData.cardGrade - 1] = priceSet;
				}
			}
			else if (data != null)
			{
				data.CardPriceList[cardSaveIndex] = priceSet;
			}
			CEventManager.QueueEvent((CEvent)new CEventPlayer_CardPriceChanged(cardData, priceSet));
			return false;
		}

		[HarmonyPatch("SetCardGeneratedMarketPrice")]
		[HarmonyPrefix]
		private static bool SetCardGeneratedMarketPricePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, float price)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			if (data != null)
			{
				data.CardMarketPriceList[cardIndex].generatedMarketPrice = price;
			}
			return false;
		}

		[HarmonyPatch("AddCardPricePercentChange")]
		[HarmonyPrefix]
		private static bool AddCardPricePercentChangePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, float percentChange)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			float? obj;
			if (data == null)
			{
				obj = null;
			}
			else
			{
				MarketPrice obj2 = data.CardMarketPriceList[cardIndex];
				obj = (obj2.pricePercentChangeList += percentChange);
			}
			if (obj < -80f && data != null)
			{
				data.CardMarketPriceList[cardIndex].pricePercentChangeList = -80f;
			}
			if (obj > 200f && data != null)
			{
				data.CardMarketPriceList[cardIndex].pricePercentChangeList = 200f;
			}
			return false;
		}

		[HarmonyPatch("GetCardPricePercentChange")]
		[HarmonyPrefix]
		private static bool GetCardPricePercentChangePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardMarketPriceList[cardIndex].pricePercentChangeList;
			return false;
		}

		[HarmonyPatch("UpdatePastCardPricePercentChange")]
		[HarmonyPostfix]
		private static void UpdatePastCardPricePercentChangePostfix()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(key, out CardExpansionSaveData data))
				{
					continue;
				}
				foreach (MarketPrice cardMarketPrice in data.CardMarketPriceList)
				{
					MarketPrice val = cardMarketPrice;
					if (val.pastPricePercentChangeList == null)
					{
						val.pastPricePercentChangeList = new List<float>();
					}
					cardMarketPrice.pastPricePercentChangeList.Add(cardMarketPrice.pricePercentChangeList);
					if (cardMarketPrice.pastPricePercentChangeList.Count > 30)
					{
						cardMarketPrice.pastPricePercentChangeList.RemoveRange(0, cardMarketPrice.pastPricePercentChangeList.Count - 30);
					}
				}
			}
		}

		[HarmonyPatch("GetPastCardPricePercentChange")]
		[HarmonyPrefix]
		private static bool GetPastCardPricePercentChangePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, ref List<float> __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardMarketPriceList[cardIndex].pastPricePercentChangeList;
			if (__result.Count > 30)
			{
				__result.RemoveRange(0, __result.Count - 30);
			}
			return false;
		}

		[HarmonyPatch("GetCardMarketPriceCustomPercent")]
		[HarmonyPrefix]
		private static bool GetCardMarketPriceCustomPercentPrefix(int index, ECardExpansionType expansionType, bool isDestiny, float percent, int cardGrade, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardMarketPriceList[index].GetMarketPriceCustomPercent(percent, index, cardGrade);
			return false;
		}

		[HarmonyPatch("AddCard")]
		[HarmonyPrefix]
		private static bool AddCardPrefix(CardData cardData, int addAmount)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_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_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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			if (cardData.cardGrade > 0)
			{
				CPlayerData.m_GradedCardInventoryList.Add(new CompactCardDataAmount
				{
					cardSaveIndex = cardSaveIndex,
					amount = cardData.cardGrade,
					expansionType = cardData.expansionType,
					isDestiny = cardData.isDestiny,
					gradedCardIndex = CPlayerData.m_GradedCardInventoryList.Count + 1
				});
				return false;
			}
			if (data != null)
			{
				data.CardCountList[cardSaveIndex] += addAmount;
			}
			if (data != null)
			{
				data.IsCardCollectedList[cardSaveIndex] = true;
			}
			return false;
		}

		[HarmonyPatch("ReduceCard")]
		[HarmonyPrefix]
		private static bool ReduceCardPrefix(CardData cardData, int reduceAmount)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			if (data != null)
			{
				data.CardCountList[cardSaveIndex] -= reduceAmount;
			}
			return false;
		}

		[HarmonyPatch("ReduceCardUsingIndex")]
		[HarmonyPrefix]
		private static bool ReduceCardUsingIndexPrefix(int index, ECardExpansionType expansionType, bool isDestiny, int reduceAmount)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			if (data != null)
			{
				data.CardCountList[index] -= reduceAmount;
			}
			return false;
		}

		[HarmonyPatch("SetCard")]
		[HarmonyPrefix]
		private static bool SetCardPrefix(CardData cardData, int amount)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			if (data != null)
			{
				data.CardCountList[cardSaveIndex] = amount;
			}
			return false;
		}

		[HarmonyPatch("GetCardData")]
		[HarmonyPrefix]
		private static bool GetCardDataPrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, ref CardData __result)
		{
			//IL_000f: 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_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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			int num = cardIndex;
			if (value.HasRandomFoils)
			{
				num >>= 1;
			}
			EMonsterType key2 = value.Cards.Keys.OrderBy((EMonsterType key) => (int)key).ToList()[num];
			ModCardData modCardData = value.Cards[key2];
			__result = modCardData;
			if (value.HasRandomFoils)
			{
				__result.isFoil = (cardIndex & 1) == 1;
			}
			return false;
		}

		[HarmonyPatch("GetGradedCardData")]
		[HarmonyPrefix]
		private static bool GetGradedCardDataPrefix(CompactCardDataAmount compactCardData, ref CardData __result)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(compactCardData.expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			EMonsterType monsterTypeFromCardSaveIndex = CPlayerData.GetMonsterTypeFromCardSaveIndex(compactCardData.cardSaveIndex, compactCardData.expansionType);
			CardData val = value.Cards[monsterTypeFromCardSaveIndex];
			val.gradedCardIndex = compactCardData.gradedCardIndex;
			val.cardGrade = compactCardData.amount;
			if (value.HasRandomFoils)
			{
				val.isFoil = (compactCardData.cardSaveIndex & 1) == 1;
			}
			__result = val;
			return false;
		}

		[HarmonyPatch("GetTotalCardCollectedAmount")]
		[HarmonyPostfix]
		private static int GetTotalCardCollectedAmountPostfix(int __result)
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(key, out CardExpansionSaveData data))
				{
					continue;
				}
				foreach (int cardCount in data.CardCountList)
				{
					num += cardCount;
				}
			}
			return __result + num;
		}

		[HarmonyPatch("GetFullCardTypeName")]
		[HarmonyPrefix]
		private static bool GetFullCardTypeNamePrefix(CardData cardData, bool ignoreRarity, ref string __result)
		{
			//IL_0010: 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 (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			if (value.Cards.TryGetValue(cardData.monsterType, out ModCardData value2))
			{
				__result = StringExtensions.Prettierize(((object)(ERarity)(ref value2.MonsterData.Rarity)).ToString().Split("_").Last());
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CSaveLoad))]
	public class CSaveLoadPatches
	{
		[HarmonyPatch("Save")]
		[HarmonyPrefix]
		private static void SavePrefix(int saveSlotIndex, bool skipJSONSave)
		{
			if (!Directory.Exists(Application.persistentDataPath + "/PrefabLoader"))
			{
				Directory.CreateDirectory(Application.persistentDataPath + "/PrefabLoader");
			}
			EplRuntimeData.Services.SaveDataManager.SaveToFile(string.Format("{0}/PrefabLoader/{1}_{2}", Application.persistentDataPath, "EnhancedPrefabLoader", saveSlotIndex));
		}

		[HarmonyPatch("Load")]
		[HarmonyPrefix]
		private static void LoadPrefix(int slotIndex)
		{
			SaveDataService saveDataManager = EplRuntimeData.Services.SaveDataManager;
			if (File.Exists(string.Format("{0}/PrefabLoader/{1}_{2}", Application.persistentDataPath, "EnhancedPrefabLoader", slotIndex)))
			{
				saveDataManager.LoadFromFile(string.Format("{0}/PrefabLoader/{1}_{2}", Application.persistentDataPath, "EnhancedPrefabLoader", slotIndex));
			}
		}
	}
	[HarmonyPatch(typeof(CustomerManager))]
	public class CustomerManagerPatches
	{
		public class HiddenItemsState
		{
			public List<InteractableObject> DecoObjects = new List<InteractableObject>();

			public List<InteractableObject> Interactables = new List<InteractableObject>();

			public List<Shelf> Shelves = new List<Shelf>();

			public List<InteractablePlayTable> PlayTables = new List<InteractablePlayTable>();

			public bool HasData
			{
				get
				{
					if (DecoObjects.Count <= 0 && Interactables.Count <= 0 && Shelves.Count <= 0)
					{
						return PlayTables.Count > 0;
					}
					return true;
				}
			}
		}

		[HarmonyPatch("EvaluateMaxCustomerCount")]
		[HarmonyPrefix]
		private static void EvaluateMaxCustomerCountPrefix(ref HiddenItemsState __state)
		{
			HiddenItemsState state = new HiddenItemsState();
			__state = state;
			ShelfManager instance = CSingleton<ShelfManager>.Instance;
			instance.m_DecoObjectList.RemoveAll(delegate(InteractableObject x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)x.m_DecoObjectType >= 200000)
				{
					state.DecoObjects.Add(x);
					return true;
				}
				return false;
			});
			instance.m_InteractableObjectList.RemoveAll(delegate(InteractableObject x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)x.m_ObjectType >= 200000)
				{
					state.Interactables.Add(x);
					return true;
				}
				return false;
			});
			instance.m_ShelfList.RemoveAll(delegate(Shelf x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)((InteractableObject)x).m_ObjectType >= 200000)
				{
					state.Shelves.Add(x);
					return true;
				}
				return false;
			});
			instance.m_PlayTableList.RemoveAll(delegate(InteractablePlayTable x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)((InteractableObject)x).m_ObjectType >= 200000)
				{
					state.PlayTables.Add(x);
					return true;
				}
				return false;
			});
		}

		[HarmonyPatch("EvaluateMaxCustomerCount")]
		[HarmonyPostfix]
		private static void EvaluateMaxCustomerCountPostfix(CustomerManager __instance, HiddenItemsState __state)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!__state.HasData)
			{
				return;
			}
			float extraBonus;
			if (__instance.m_CustomerCountMax < 20)
			{
				extraBonus = 0f;
				foreach (InteractableObject decoObject in __state.DecoObjects)
				{
					DecoPurchaseData itemDecoPurchaseData = InventoryBase.GetItemDecoPurchaseData(decoObject.m_DecoObjectType);
					if (itemDecoPurchaseData != null)
					{
						extraBonus += itemDecoPurchaseData.price / 20000f;
					}
				}
				ProcessList<InteractableObject>(__state.Interactables);
				ProcessList<Shelf>(__state.Shelves);
				ProcessList<InteractablePlayTable>(__state.PlayTables);
				__instance.m_CustomerCountMax = Mathf.Clamp(__instance.m_CustomerCountMax + Mathf.RoundToInt(extraBonus), 0, 25);
			}
			ShelfManager instance = CSingleton<ShelfManager>.Instance;
			if (__state.DecoObjects.Count > 0)
			{
				instance.m_DecoObjectList.AddRange(__state.DecoObjects);
			}
			if (__state.Interactables.Count > 0)
			{
				instance.m_InteractableObjectList.AddRange(__state.Interactables);
			}
			if (__state.Shelves.Count > 0)
			{
				instance.m_ShelfList.AddRange(__state.Shelves);
			}
			if (__state.PlayTables.Count > 0)
			{
				instance.m_PlayTableList.AddRange(__state.PlayTables);
			}
			void ProcessList<T>(List<T> items) where T : notnull, InteractableObject
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				foreach (T item in items)
				{
					ObjectData objectData = InventoryBase.GetObjectData(((InteractableObject)item).m_ObjectType);
					if (objectData != null)
					{
						extraBonus += objectData.decoBonus;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(CustomerTradeCardScreen))]
	internal class CustomerTradeCardScreenPatches
	{
		[HarmonyPatch("SetCustomer")]
		[HarmonyPrefix]
		private static bool SetCustomerPrefix(CustomerTradeCardScreen __instance, Customer customer, CustomerTradeData customerTradeData)
		{
			EplRuntimeData.Services.CardTradeManager.SetCustomer(__instance, customer, customerTradeData);
			return false;
		}
	}
	[HarmonyPatch]
	public class FastPackOpeningCompatibilityPatches
	{
		[CompilerGenerated]
		private sealed class <TargetMethods>d__1 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private MethodBase <>2__current;

			private int <>l__initialThreadId;

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

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

			[DebuggerHidden]
			public <TargetMethods>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = AccessTools.Method(AccessTools.TypeByName("FastPackOpening.Patches"), "InteractionPlayerController_EvaluateOpenCardPack_Prefix", (Type[])null, (Type[])null);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = AccessTools.Method(AccessTools.TypeByName("FastPackOpening.Patches"), "InteractionPlayerController_OnGameDataFinishLoaded_Postfix", (Type[])null, (Type[])null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <TargetMethods>d__1(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<MethodBase>)this).GetEnumerator();
			}
		}

		private static bool Prepare()
		{
			PluginInfo value;
			return Chainloader.PluginInfos.TryGetValue("FastPackOpening", out value);
		}

		[IteratorStateMachine(typeof(<TargetMethods>d__1))]
		private static IEnumerable<MethodBase> TargetMethods()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TargetMethods>d__1(-2);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(Item), "SetMesh", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(ItemMeshData), "materialList");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(ItemMeshData), "materialSecondary");
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				object operand = val.Instruction.operand;
				val.Advance(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldloc_S, operand),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo)
				}).RemoveInstructions(1);
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(FurnitureShopConfirmPurchaseScreen))]
	public class FurnitureShopConfirmPurchaseScreenPatches
	{
		[HarmonyPatch("UpdateData")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateDataTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0079: 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: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(FurnitureShopConfirmPurchaseScreen), "m_Image");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(FurniturePurchaseData), "icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[2]
			{
				typeof(Image),
				typeof(FurniturePurchaseData)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(FurnitureShopPanelUI))]
	public class FurnitureShopPanelUIPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0079: 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: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(FurnitureShopPanelUI), "m_Image");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(FurniturePurchaseData), "icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[2]
			{
				typeof(Image),
				typeof(FurniturePurchaseData)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(FurnitureShopUIScreen))]
	internal class FurnitureShopUIScreenPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyPrefix]
		private static void InitPrefix(FurnitureShopUIScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupFurnitureShopUI(__instance);
		}
	}
	[HarmonyPatch(typeof(HostTournamentScreen))]
	public class HostTournamentScreenPatches
	{
		[HarmonyPatch("EvaluateSideRewardImage")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EvaluateSideRewardImageTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_00db: 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_00fb: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(HostTournamentScreen), "m_RewardSideItemImageList");
			MethodInfo methodInfo = AccessTools.Method(typeof(List<Image>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo listGetItemTypeMethod = AccessTools.Method(typeof(List<EItemType>), "get_Item", (Type[])null, (Type[])null);
			AccessTools.Method(typeof(List<TournamentPrizeData>), "get_Item", (Type[])null, (Type[])null);
			AccessTools.Field(typeof(TournamentPrizeDataList), "m_PrizeDataList");
			MethodInfo replacementSetSpriteMethod = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			return new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[6]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Ldloc_S || i.opcode == OpCodes.Ldc_I4_2 || i.opcode == OpCodes.Ldc_I4_1), (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Expected O, but got Unknown
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Expected O, but got Unknown
				matcher.Advance(1);
				CodeInstruction instruction = matcher.Instruction;
				matcher.Advance(3).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(instruction.opcode, instruction.operand),
					new CodeInstruction(OpCodes.Callvirt, (object)listGetItemTypeMethod),
					new CodeInstruction(OpCodes.Call, (object)replacementSetSpriteMethod)
				});
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(InteractableAutoPackOpener))]
	public class InteractableAutoPackOpenerPatches
	{
		[HarmonyPatch("OpenPack")]
		[HarmonyPrefix]
		private static bool OpenPackPrefix(InteractableAutoPackOpener __instance)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(__instance.m_StoredItemList[0].GetItemType(), out CardGenerationData _))
			{
				return true;
			}
			__instance.m_PackOpenedCount++;
			foreach (CardData item2 in EplRuntimeData.Services.itemService.GeneratePackContent(__instance.m_StoredItemList[0].GetItemType()))
			{
				int cardSaveIndex = CPlayerData.GetCardSaveIndex(item2);
				bool flag = false;
				for (int i = 0; i < __instance.m_CompactCardDataAmountList.Count; i++)
				{
					if (__instance.m_CompactCardDataAmountList[i].cardSaveIndex == cardSaveIndex && __instance.m_CompactCardDataAmountList[i].expansionType == item2.expansionType)
					{
						flag = true;
						CompactCardDataAmount obj = __instance.m_CompactCardDataAmountList[i];
						obj.amount++;
						break;
					}
				}
				if (!flag)
				{
					CompactCardDataAmount item = new CompactCardDataAmount
					{
						expansionType = item2.expansionType,
						isDestiny = false,
						cardSaveIndex = cardSaveIndex,
						amount = 1
					};
					__instance.m_CompactCardDataAmountList.Add(item);
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InteractablePlayTable))]
	internal class InteractablePlayTablePatches
	{
		[HarmonyPatch("CustomerHasReached")]
		[HarmonyPrefix]
		private static void CustomerHasReachedPrefix(InteractablePlayTable __instance)
		{
			if (__instance.m_CurrentPlayerCount + 1 < __instance.m_MaxSeatCount)
			{
				return;
			}
			Dictionary<InteractablePlayTable, List<Material>> playTableExpansionCache = EplRuntimeData.Caches.PlayTableExpansionCache;
			if (!playTableExpansionCache.ContainsKey(__instance))
			{
				Dictionary<List<Material>, float> dictionary = EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Where<KeyValuePair<ECardExpansionType, ModCardExpansionData>>((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => kvp.Value.PlayCardMaterials.Count > 0).ToDictionary((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => kvp.Value.PlayCardMaterials, (KeyValuePair<ECardExpansionType, ModCardExpansionData> _) => 1f);
				if (dictionary.Count > 0)
				{
					playTableExpansionCache[__instance] = RandomUtils.Weighted(dictionary);
				}
			}
		}

		[HarmonyPatch("StopTableGame")]
		[HarmonyPostfix]
		private static void StopTableGamePostfix(InteractablePlayTable __instance)
		{
			EplRuntimeData.Caches.PlayTableExpansionCache.Remove(__instance);
		}
	}
	[HarmonyPatch(typeof(InteractableWorkbench))]
	public class InteractableWorkbenchPatches
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix(InteractableWorkbench __instance)
		{
			foreach (var (_, list2) in EplRuntimeData.Assets.ItemLibrary.BulkBoxes)
			{
				if (list2.Count > 0)
				{
					__instance.m_ValidStoreItemTypeList.AddRange(list2.Select<(int, EItemType), EItemType>(((int MinPrice, EItemType ItemType) b) => b.ItemType));
				}
			}
		}

		[HarmonyPatch("GetBulkBoxItemType")]
		[HarmonyPrefix]
		private static bool GetBulkBoxItemTypePrefix(ECardExpansionType cardExpansionType, float totalPrice, ref EItemType __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.ItemLibrary.BulkBoxes.TryGetValue(cardExpansionType, out List<(int, EItemType)> value) || value.Count == 0)
			{
				return true;
			}
			foreach (var (num, val) in value)
			{
				if (totalPrice > (float)num)
				{
					__result = (EItemType)(int)val;
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InteractionPlayerController))]
	public class InteractionPlayerControllerPatches
	{
		[HarmonyPatch("IsHoldingSpray")]
		[HarmonyPrefix]
		private static bool IsHoldingSprayPrefix(InteractionPlayerController __instance, ref bool __result)
		{
			//IL_0029: 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)
			if (__instance.m_HoldItemList.Count <= 0 || !EplRuntimeData.Assets.ItemLibrary.ItemData.ContainsKey(__instance.m_HoldItemList[0].GetItemType()))
			{
				return true;
			}
			__result = EplRuntimeData.Assets.ItemLibrary.SprayCanList.Contains(__instance.m_HoldItemList[0].GetItemType());
			return false;
		}

		[HarmonyPatch("IsCardPackType")]
		[HarmonyPrefix]
		private static bool IsCardPackTypePrefix(EItemType itemType, ref bool __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value))
			{
				return true;
			}
			__result = !value.BaseItemData.isNotBoosterPack;
			return false;
		}

		[HarmonyPatch("CanOpenCardBox")]
		[HarmonyPrefix]
		private static bool CanOpenCardBoxPrefix(InteractionPlayerController __instance, ref bool __result)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.m_HoldItemList.Count == 0)
			{
				return true;
			}
			if (!EplRuntimeData.Assets.LookupLibrary.SpawnPackLookup.ContainsKey(__instance.m_HoldItemList[0].GetItemType()))
			{
				return true;
			}
			__result = true;
			return false;
		}

		[HarmonyPatch("CardBoxToCardPack")]
		[HarmonyPrefix]
		private static bool CardBoxToCardPackPrefix(EItemType cardBoxItemType, ref EItemType __result)
		{
			//IL_000f: 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_001e: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.SpawnPackLookup.TryGetValue(cardBoxItemType, out var value))
			{
				return true;
			}
			__result = (EItemType)(int)value;
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryBase))]
	public class InventoryBasePatches
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix()
		{
			EplRuntimeData.Events.FireOnInventoryBaseAwake();
		}

		[HarmonyPatch("GetCardUISetting")]
		[HarmonyPrefix]
		private static bool GetCardUISettingsPrefix(ECardExpansionType expansionType, ref CardUISetting __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType))
			{
				return true;
			}
			__result = CSingleton<InventoryBase>.Instance.m_MonsterData_SO.m_CardUISettingList[0];
			return false;
		}

		[HarmonyPatch("GetCardUISettingWithBorder")]
		[HarmonyPrefix]
		private static bool GetCardUISettingsWithBorderPrefix(ECardExpansionType expansionType, ref CardUISetting __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType))
			{
				return true;
			}
			__result = CSingleton<InventoryBase>.Instance.m_MonsterData_SO.m_CardUISettingList[0];
			return false;
		}

		[HarmonyPatch("GetCardExpansionType")]
		[HarmonyPrefix]
		private static bool GetCardExpansionTypePrefix(ECollectionPackType collectionPackType, ref ECardExpansionType __result)
		{
			//IL_000f: 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_001e: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionLookup.TryGetValue(collectionPackType, out var value))
			{
				return true;
			}
			__result = (ECardExpansionType)(int)value;
			return false;
		}

		[HarmonyPatch("ItemTypeToCollectionPackType")]
		[HarmonyPrefix]
		private static bool ItemTypeToCollectionPackTypePrefix(EItemType itemType, ref ECollectionPackType __result)
		{
			//IL_000f: 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_0023: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(itemType, out CardGenerationData value))
			{
				return true;
			}
			__result = (ECollectionPackType)(int)value.PackType;
			return false;
		}

		[HarmonyPatch("GetShownMonsterList")]
		[HarmonyPrefix]
		private static bool GetShownMonsterListPrefix(ECardExpansionType expansionType, ref List<EMonsterType> __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			__result = (from kvp in value.Cards
				select kvp.Key into key
				orderby (int)key
				select key).ToList();
			return false;
		}

		[HarmonyPatch("GetCardExpansionName")]
		[HarmonyPrefix]
		private static bool GetCardExpansionNamePrefix(ECardExpansionType cardExpansion, ref string __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardExpansion, out ModCardExpansionData value))
			{
				return true;
			}
			__result = value.Name;
			return false;
		}
	}
	[HarmonyPatch(typeof(Item))]
	internal class ItemPatches
	{
		[HarmonyPatch("SetMesh")]
		[HarmonyPrefix]
		private static bool SetMeshPrefix(Item __instance, Mesh mesh, Material material, EItemType itemType, Mesh meshSecondary, Material materialSecondary, List<Material> materialList)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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_00ec: 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_0102: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			__instance.m_ItemType = itemType;
			MeshRenderer mesh2 = __instance.m_Mesh;
			__instance.m_MeshFilter.sharedMesh = mesh;
			if (materialList != null && materialList.Count > 0)
			{
				if (EplRuntimeData.BundleAssetTracker.GetBundleIdFor<EItemType>(itemType) != null)
				{
					((Renderer)mesh2).sharedMaterial = materialList[Random.Range(0, materialList.Count)];
				}
				else
				{
					((Renderer)mesh2).sharedMaterials = materialList.ToArray();
				}
			}
			else
			{
				((Renderer)mesh2).sharedMaterial = material;
			}
			if ((Object)(object)meshSecondary != (Object)null)
			{
				__instance.m_MeshFilterSecondary.sharedMesh = meshSecondary;
				((Renderer)__instance.m_MeshSecondary).sharedMaterial = materialSecondary;
				((Component)__instance.m_MeshFilterSecondary).gameObject.SetActive(true);
			}
			else if ((Object)(object)meshSecondary == (Object)null && (Object)(object)materialSecondary != (Object)null)
			{
				((Renderer)mesh2).sharedMaterials = (Material[])(object)new Material[2] { material, materialSecondary };
			}
			else
			{
				((Component)__instance.m_MeshFilterSecondary).gameObject.SetActive(false);
			}
			__instance.m_OutlineMeshFilter.sharedMesh = mesh;
			__instance.m_Collider.size = InventoryBase.GetItemData(itemType).colliderScale;
			__instance.m_Collider.center = InventoryBase.GetItemData(itemType).colliderPosOffset;
			__instance.m_ItemVolume = InventoryBase.GetItemData(itemType).GetItemVolume();
			((Behaviour)__instance.m_InteractableScanItem).enabled = false;
			__instance.m_ItemContentFill = 1f;
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemPriceGraphScreen))]
	public class ItemPriceGraphScreenPatches
	{
		[HarmonyPatch("ShowCardPriceChart")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShowCardPriceChartTranspilier(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			ConstructorInfo constructorInfo = AccessTools.Constructor(typeof(CardData), (Type[])null, false);
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CardData), "cardGrade");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			MethodInfo methodInfo5 = AccessTools.Method(typeof(CardDataFactory), "Create", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Newobj, (object)constructorInfo, (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Stfld, (object)fieldInfo2, (string)null)
				});
				if (val.IsValid)
				{
					int pos2 = val.Pos;
					val.Start().Advance(pos).RemoveInstructions(pos2 - pos + 1)
						.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
						{
							new CodeInstruction(OpCodes.Ldarg_1, (object)null),
							new CodeInstruction(OpCodes.Ldarg_2, (object)null),
							new CodeInstruction(OpCodes.Ldarg_3, (object)null),
							new CodeInstruction(OpCodes.Ldarg, (object)4),
							new CodeInstruction(OpCodes.Call, (object)methodInfo5),
							new CodeInstruction(OpCodes.Stloc_2, (object)null)
						})
						.Start()
						.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
						{
							new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
							new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
							new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
						})
						.RemoveInstructions(3)
						.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
						{
							new CodeInstruction(OpCodes.Call, (object)methodInfo2),
							new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
							new CodeInstruction(OpCodes.Ldloc_2, (object)null),
							new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
						});
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("ShowItemPriceChart")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShowItemPriceChartTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: 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_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(ItemPriceGraphScreen), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(LightManager))]
	internal class LightManagerPatches
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix()
		{
			EplRuntimeData.Events.FireOnLightManagerAwake();
		}

		[HarmonyPatch("EvaluateWorldUIBrightness")]
		[HarmonyPostfix]
		private static void EvaluateWorldUIBrightnessPostfix(LightManager __instance)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			foreach (Material value in EplRuntimeData.Caches.CardBackMaterials.Values)
			{
				value.SetColor("_EmissionColor", __instance.m_CardBackMatOriginalEmissionColor * Mathf.Lerp(0.2f, 1f, __instance.m_GlobalBrightness));
			}
		}
	}
	[HarmonyPatch(typeof(MonsterData))]
	public class MonsterDataPatches
	{
		[HarmonyPatch("GetRarityName")]
		[HarmonyPostfix]
		private static void GetRarityNamePostfix(MonsterData __instance, ref string __result)
		{
			__result = StringExtensions.Prettierize(((object)(ERarity)(ref __instance.Rarity)).ToString().Split("_").Last());
		}

		[HarmonyPatch("GetIcon")]
		[HarmonyPrefix]
		private static bool GetIconPrefix(ECardExpansionType cardExpansionType, MonsterData __instance, ref Sprite __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardExpansionType))
			{
				return true;
			}
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(PriceChangeManager))]
	internal class PriceChangeManagerPatches
	{
		[HarmonyPatch("UpdateCardMarketPrice")]
		[HarmonyPrefix]
		private static bool UpdateCardMarketPricePrefix(PriceChangeManager __instance, ECardExpansionType expansionType, EPriceChangeType priceChangeType, bool isIncrease)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected I4, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Invalid comparison between Unknown and I4
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Invalid comparison between Unknown and I4
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Invalid comparison between Unknown and I4
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Invalid comparison between Unknown and I4
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Invalid comparison between Unknown and I4
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Invalid comparison between Unknown and I4
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Invalid comparison between Unknown and I4
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			foreach (ModCardData value2 in value.Cards.Values)
			{
				int cardSaveIndex = CPlayerData.GetCardSaveIndex((CardData)value2);
				int num = (priceChangeType - 6) switch
				{
					11 => (value.HasRandomFoils ? ((cardSaveIndex & 1) == 1) : value2.IsFoil) ? 1 : 0, 
					12 => (value.HasRandomFoils ? ((cardSaveIndex & 1) == 0) : (!value2.IsFoil)) ? 1 : 0, 
					5 => ((int)value2.BorderType == 1) ? 1 : 0, 
					6 => ((int)value2.BorderType == 2) ? 1 : 0, 
					7 => ((int)value2.BorderType == 3) ? 1 : 0, 
					8 => ((int)value2.BorderType == 4) ? 1 : 0, 
					9 => ((int)value2.BorderType == 5) ? 1 : 0, 
					0 => ((int)value2.MonsterData.ElementIndex == 0) ? 1 : 0, 
					1 => ((int)value2.MonsterData.ElementIndex == 1) ? 1 : 0, 
					2 => ((int)value2.MonsterData.ElementIndex == 2) ? 1 : 0, 
					3 => ((int)value2.MonsterData.ElementIndex == 3) ? 1 : 0, 
					_ => 0, 
				};
				float num2 = Random.Range(__instance.m_PriceChangeMin, __instance.m_PriceChangeMax);
				if (num != 0)
				{
					num2 = (isIncrease ? num2 : (0f - num2));
					CPlayerData.AddCardPricePercentChange(cardSaveIndex, expansionType, false, num2);
				}
				int num3 = Random.Range(0, 100);
				if (num3 < 40)
				{
					if ((num3 & 1) == 0)
					{
						num2 = 0f - num2;
					}
					CPlayerData.AddCardPricePercentChange(cardSaveIndex, expansionType, false, num2 / 2.5f);
				}
			}
			return false;
		}

		[HarmonyPatch("EvaluatePriceCrash")]
		[HarmonyPostfix]
		private static void EvaluatePriceCrashPostfix(PriceChangeManager __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				__instance.EvaluateCardPriceCrash(key);
			}
		}

		[HarmonyPatch("EvaluatePriceChange")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EvaluatePriceChangeTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(PriceChangeManagerPatches), "UpdateCustomExpansions", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.End().MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ret, (object)null, (string)null)
			});
			if (val.IsValid)
			{
				val.Insert((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldloc_2, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo)
				});
			}
			return val.InstructionEnumeration();
		}

		private static void UpdateCustomExpansions(PriceChangeManager priceChangeManager, EPriceChangeType positive, EPriceChangeType negative)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				priceChangeManager.UpdateCardMarketPrice(key, positive, true);
				priceChangeManager.UpdateCardMarketPrice(key, negative, false);
			}
		}
	}
	[HarmonyPatch(typeof(RestockItemBoardGameScreen))]
	internal class RestockItemBoardGameScreenPatches
	{
		[HarmonyPatch("EvaluateRestockItemPanelUI")]
		[HarmonyPrefix]
		private static void EvaluateRestockItemPanelUIPrefix(RestockItemBoardGameScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupBoardgameShopUI(__instance);
		}
	}
	[HarmonyPatch(typeof(RestockItemPanelUI))]
	public class RestockItemPanelUIPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(RestockItemPanelUI), "m_ItemImage");
			AccessTools.Field(typeof(RestockItemPanelUI), "m_ItemImage2");
			AccessTools.Field(typeof(RestockItemPanelUI), "m_ItemImageB");
			AccessTools.Field(typeof(RestockItemPanelUI), "m_ItemImage2B");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "get_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			FieldInfo itemTypeField = AccessTools.Field(typeof(RestockItemPanelUI), "m_ItemType");
			MethodInfo replacementSetSpriteMethod = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instruction) => CodeInstructionExtensions.IsLdloc(instruction, (LocalBuilder)null)), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
			});
			if (val.IsValid)
			{
				CodeInstruction itemDataLoad = val.InstructionAt(1).Clone();
				val.Advance(1).RemoveInstructions(3).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
				{
					itemDataLoad,
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)itemTypeField),
					new CodeInstruction(OpCodes.Call, (object)replacementSetSpriteMethod)
				});
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
				}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
				{
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Expected O, but got Unknown
					//IL_003c: 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_0055: Expected O, but got Unknown
					matcher.Advance(1).RemoveInstructions(4).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
					{
						itemDataLoad.Clone(),
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Ldfld, (object)itemTypeField),
						new CodeInstruction(OpCodes.Call, (object)replacementSetSpriteMethod)
					});
				}, (Action<string>)null);
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(RestockItemScreen))]
	internal class RestockItemScreenPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyPrefix]
		private static void InitPrefix(RestockItemScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupItemShopUI(__instance);
		}
	}
	[HarmonyPatch(typeof(RestockManager))]
	public class RestockManagerPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Expected O, but got Unknown
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Expected O, but got Unknown
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Expected O, but got Unknown
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Expected O, but got Unknown
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Expected O, but got Unknown
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Expected O, but got Unknown
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Expected O, but got Unknown
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Expected O, but got Unknown
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Expected O, but got Unknown
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Expected O, but got Unknown
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Expected O, but got Unknown
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Services");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplServices), "itemService");
			MethodInfo methodInfo3 = AccessTools.Method(typeof(ItemService), "GenerateItemCost", new Type[1] { typeof(int) }, (Type[])null);
			MethodInfo methodInfo4 = AccessTools.Method(typeof(ItemService), "GenerateItemMarketPrice", new Type[2]
			{
				typeof(int),
				typeof(float)
			}, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(ItemData), "baseCost");
			List<CodeInstruction> list = instructions.ToList();
			object operand = list.First((CodeInstruction c) => c.opcode == OpCodes.Call && c.operand is MethodInfo methodInfo5 && methodInfo5.Name == "InvokeGet_Item" && methodInfo5.ReturnType == typeof(float)).operand;
			object operand2 = list.First((CodeInstruction c) => c.opcode == OpCodes.Ldsfld && c.operand is FieldInfo fieldInfo4 && fieldInfo4.Name == "m_GeneratedCostPriceList").operand;
			CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find baseCost anchor", "InitTranspiler", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int num = val.Pos - 6;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"CPlayerData.m_GeneratedCostPriceList", (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find cost Ldstr anchor", "InitTranspiler", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int pos = val.Pos;
			int num2 = pos + 2;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction c) => c.opcode == OpCodes.Ldsfld && c.operand is FieldInfo fieldInfo3 && fieldInfo3.Name == "m_GeneratedMarketPriceList"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction c) => c.opcode == OpCodes.Ldsfld && c.operand is FieldInfo fieldInfo2 && fieldInfo2.Name == "m_GeneratedCostPriceList"), (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find default market frame anchor", "InitTranspiler", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int pos2 = val.Pos;
			int num3 = pos2 + 2;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"CPlayerData.m_GeneratedMarketPriceList", (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find market Ldstr anchor", "InitTranspiler", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int pos3 = val.Pos;
			val.Start().Advance(num3).RemoveInstructions(pos3 - num3)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[8]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo2),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldsfld, operand2),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldstr, (object)"CPlayerData.m_GeneratedCostPriceList"),
					new CodeInstruction(OpCodes.Call, operand),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				})
				.Start()
				.Advance(num2)
				.RemoveInstructions(pos2 - num2)
				.Start()
				.Advance(num)
				.RemoveInstructions(pos - num)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo2),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3)
				});
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("Init")]
		[HarmonyPostfix]
		private static void InitPostfix(RestockManager __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(key, out CardExpansionSaveData data))
				{
					continue;
				}
				__instance.GenerateCardMarketPrice(key);
				foreach (MarketPrice cardMarketPrice in data.CardMarketPriceList)
				{
					MarketPrice val = cardMarketPrice;
					if (val.pastPricePercentChangeList == null)
					{
						val.pastPricePercentChangeList = new List<float>();
					}
					cardMarketPrice.pastPricePercentChangeList.Add(cardMarketPrice.pricePercentChangeList);
				}
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix()
		{
			EplRuntimeData.Events.FireOnRestockManagerAwake();
		}

		[HarmonyPatch("GenerateCardMarketPrice")]
		[HarmonyPrefix]
		private static bool GenerateCardMarketPricePrefix(ECardExpansionType expansionType)
		{
			//IL_000f: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			List<ModCardData> list = value.Cards.Values.OrderBy((ModCardData data) => (int)data.MonsterData.MonsterType).ToList();
			for (int i = 0; i < list.Count; i++)
			{
				if (CPlayerData.GetCardMarketPrice((CardData)list[i]) == 0f)
				{
					int num = (value.HasRandomFoils ? (i * 2) : i);
					float num2 = EplRuntimeData.Services.cardExpansionService.GenerateCardMarketPrice(expansionType, list[i].MonsterData.MonsterType, list[i].IsFoil);
					CPlayerData.SetCardGeneratedMarketPrice(num, expansionType, false, num2);
					if (value.HasRandomFoils)
					{
						float num3 = EplRuntimeData.Services.cardExpansionService.GenerateCardMarketPrice(expansionType, list[i].MonsterData.MonsterType, isFoil: true);
						CPlayerData.SetCardGeneratedMarketPrice(num + 1, expansionType, false, num3);
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(SetItemPriceScreen))]
	public class SetItemPriceScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OpenScreenTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: 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_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(SetItemPriceScreen), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(3).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(ShelfManager))]
	public class ShelfManagerPatches
	{
		[HarmonyPatch("SpawnInteractableObject")]
		[HarmonyPostfix]
		private static void SpawnInteractableObjectPostfix(EObjectType objType, ref InteractableObject __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			__result.m_ObjectType = objType;
		}

		[HarmonyPatch("SpawnDecoObject")]
		[HarmonyPostfix]
		private static void SpawnDecoObjectPostfix(EDecoObject objType, ref InteractableObject __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			__result.m_DecoObjectType = objType;
		}
	}
	[HarmonyPatch(typeof(ShopDecoPanelUI))]
	public class ShopDecoPanelUIPatches
	{
		[HarmonyPatch("InitDecoObject")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitDecoObjectTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_009c: 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_00bc: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(ShopDecoPanelUI), "m_Image");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(ShopDecoPanelUI), "m_DecoPurchaseData");
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(DecoPurchaseData), "icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(DecoPurchaseData),
				typeof(EDecoObject)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo3, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(3).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_2, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(ShowCardObtainedPage))]
	internal class ShowCardObtainedPagePatches
	{
		[HarmonyPatch("ShowCardObtained")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShowCardObtainedTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0045: 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_0065: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(CardData), "GetCardBorderType", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(ShowCardObtainedPage), "m_TotalExpGained");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ShowCardObtainedPagePatches), "ProcessCardExp", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null)
				});
				if (val.IsValid)
				{
					int pos2 = val.Pos;
					List<CodeInstruction> list = val.Instructions();
					CodeInstruction val2 = new CodeInstruction(OpCodes.Stloc_S, (object)(byte)5);
					for (int i = pos; i < pos2; i++)
					{
						if (list[i].opcode == OpCodes.Stloc_S)
						{
							val2 = new CodeInstruction(OpCodes.Stloc_S, list[i].operand);
							break;
						}
					}
					val.Start().Advance(pos).RemoveInstructions(pos2 - pos)
						.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
						{
							new CodeInstruction(OpCodes.Call, (object)methodInfo2),
							val2
						});
				}
			}
			return val.InstructionEnumeration();
		}

		private static int ProcessCardExp(CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected I4, but got Unknown
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				return (int)EplRuntimeData.Services.cardExpansionService.GenerateCardExp(cardData);
			}
			if (EplRuntimeData.Config.UseCustomExpForBase)
			{
				return (int)new CardExpGenerator().CalculateExp(cardData);
			}
			? val = cardData.GetCardBorderType() + 1;
			return val * Mathf.CeilToInt((float)val / 2f) * ((!cardData.isFoil) ? 1 : 8);
		}
	}
	internal static class TextureReplacerCompatibilityPatches
	{
		[HarmonyPatch]
		internal class SetCardUIPrefixPatch
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__1 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

				[DebuggerHidden]
				public <TargetMethods>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(AccessTools.TypeByName("TextureReplacer.BepInExPlugin+CardUI_Patch"), "Prefix_SetCardUI", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__1(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodBase>)this).GetEnumerator();
				}
			}

			private static bool Prepare()
			{
				return IsTextureReplacerLoaded();
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__1))]
			private static IEnumerable<MethodBase> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__1(-2);
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Expected O, but got Unknown
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Expected O, but got Unknown
				MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
				FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldind_Ref, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Stloc_0, (object)null, (string)null)
				});
				if (val.IsValid)
				{
					val.SetAndAdvance(OpCodes.Ldnull, (object)null).RemoveInstructions(4);
				}
				return val.InstructionEnumeration();
			}
		}

		[HarmonyPatch]
		public class SetCardUIPostfixPatch
		{
			[CompilerGenerated]
			private sealed class <TargetMethods>d__1 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private MethodBase <>2__current;

				private int <>l__initialThreadId;

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

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

				[DebuggerHidden]
				public <TargetMethods>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

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

				private bool MoveNext()
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = AccessTools.Method(AccessTools.TypeByName("TextureReplacer.BepInExPlugin+CardUI_Patch"), "Postfix_SetCardUI", (Type[])null, (Type[])null);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						return false;
					}
				}

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

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

				[DebuggerHidden]
				IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
				{
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						return this;
					}
					return new <TargetMethods>d__1(0);
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<MethodBase>)this).GetEnumerator();
				}
			}

			private static bool Prepare()
			{
				return IsTextureReplacerLoaded();
			}

			[IteratorStateMachine(typeof(<TargetMethods>d__1))]
			private static IEnumerable<MethodBase> TargetMethods()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <TargetMethods>d__1(-2);
			}

			private static bool Prefix(CardUI __0, ref CardData cardData)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
				{
					return false;
				}
				EplRuntimeData.Services.cardUIService.SetDirty(__0);
				return true;
			}
		}

		[HarmonyPatch]
		internal class GetFullCardTypeNamePatch
		{
			private static bool Prepare()
			{
				return IsTextureReplacerLoaded();
			}

			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(AccessTools.TypeByName("TextureReplacer.BepInExPlugin+Patch_GetFullCardTypeName"), "Postfix", (Type[])null, (Type[])null);
			}

			private static bool Prefix(CardData __0, bool ignoreRarity)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				return !EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(__0.expansionType);
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
			{
				//IL_0094: 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_00b4: Expected O, but got Unknown
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Expected O, but got Unknown
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Expected O, but got Unknown
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Expected O, but got Unknown
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Expected O, but got Unknown
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Expected O, but got Unknown
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Expected O, but got Unknown
				MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
				FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
				MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
				MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
				MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
				LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
				});
				if (val.IsValid)
				{
					val.Advance(1).RemoveInstruction().InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
					{
						new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
						new CodeInstruction(OpCodes.Call, (object)methodInfo2),
						new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
						new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
						new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
					})
						.RemoveInstruction();
				}
				return val.InstructionEnumeration();
			}
		}

		private static bool IsTextureReplacerLoaded()
		{
			PluginInfo value;
			return Chainloader.PluginInfos.TryGetValue("shaklin.TextureReplacer", out value);
		}
	}
	[HarmonyPatch(typeof(TournamentPrizePanelUI))]
	public class TournamentPrizePanelUIPatches
	{
		[HarmonyPatch("InitItem")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitItemTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: 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_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(TournamentPrizePanelUI), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("InitCard")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitCardTranspiler(IEnumerable<CodeInstruction> codeInstructions, ILGenerator il)
		{
			//IL_0094: 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_00b4: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(1).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(TournamentPrizeUIGrp))]
	public class TournamentPrizeUIGrpPatches
	{
		[HarmonyPatch("UpdatePrizeData")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdatePrizeDataTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_00cc: 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_00ec: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(TournamentPrizeUIGrp), "m_ItemImageList");
			MethodInfo methodInfo = AccessTools.Method(typeof(List<Image>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(TournamentPrizeData), "m_ItemType");
			MethodInfo methodInfo3 = AccessTools.Method(typeof(List<TournamentPrizeData>), "get_Item", (Type[])null, (Type[])null);
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(TournamentPrizeDataList), "m_PrizeDataList");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[6]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_3, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(4).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo3),
					new CodeInstruction(OpCodes.Ldloc_2, (object)null),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)methodInfo4)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(UI_BarcodeScannerScreen))]
	public class UI_BarcodeScannerScreenPatches
	{
		[HarmonyPatch("UpdateScannerUI")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateSannerUITranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: 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_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(UI_BarcodeScannerScreen), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(UI_CashCounterScreen))]
	public class UI_CashCounterScreenPatches
	{
		[HarmonyPatch("OnCardScanned")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OnCardScannedTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0094: 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_00b4: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_2, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(1).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(UI_PriceTag))]
	public class UI_PriceTagPatches
	{
		[CompilerGenerated]
		private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private MethodBase <>2__current;

			private int <>l__initialThreadId;

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

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

			[DebuggerHidden]
			public <TargetMethods>d__0(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = AccessTools.Method(typeof(UI_PriceTag), "SetItemImage", (Type[])null, (Type[])null);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = AccessTools.Method(typeof(UI_PriceTag), "SetObjectImage", (Type[])null, (Type[])null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <TargetMethods>d__0(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<MethodBase>)this).GetEnumerator();
			}
		}

		[IteratorStateMachine(typeof(<TargetMethods>d__0))]
		private static IEnumerable<MethodBase> TargetMethods()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TargetMethods>d__0(-2);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> codeInstructions, MethodBase original)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(UI_PriceTag), "m_Icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			Type typeFromHandle = typeof(ImageExtensions);
			string name = original.Name;
			Type[] array = ((name == "SetItemImage") ? new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			} : ((!(name == "SetObjectImage")) ? null : new Type[2]
			{
				typeof(Image),
				typeof(FurniturePurchaseData)
			}));
			MethodInfo methodInfo2 = AccessTools.Method(typeFromHandle, "SetSprite", array, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(3).RemoveInstructions(2);
				if (original.Name == "SetItemImage")
				{
					val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_1, (object)null)
					});
				}
				val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(WorkbenchUIScreen))]
	public class WorkbenchUIScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyPostfix]
		private static void OpenScreenPostfix(InteractableWorkbench interactableWorkbench)
		{
			CSingleton<WorkbenchUIScreen>.Instance.m_SliderPriceLimit.maxValue = 999999f;
			CSingleton<WorkbenchUIScreen>.Instance.m_SliderPriceMinimum.maxValue = 999999f;
			((TMP_Text)CSingleton<WorkbenchUIScreen>.Instance.m_PriceLimitMaxText).text = GameInstance.GetPriceString(9999.99f, false, true, false, "F2");
			((TMP_Text)CSingleton<WorkbenchUIScreen>.Instance.m_PriceMinimumMaxText).text = GameInstance.GetPriceString(9999.99f, false, true, false, "F2");
		}

		[HarmonyPatch("RunBundleCardBulkFunction")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RunBundleCardBulkFunctionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_00a2: 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_00c2: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[2]
			{
				typeof(ECardExpansionType),
				typeof(EMonsterType)
			}, (Type[])null);
			AccessTools.Method(typeof(CardDataFactory), "Create", (Type[])null, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(EMonsterType));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.RemoveInstruction().InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				});
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("OnPressChangeRarityButton")]
		[HarmonyPostfix]
		private static void OnPressChangeRarityButtonPostfix(WorkbenchUIScreen __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			EplRuntimeData.Services.CardRaritySelectService.OpenScreen(__instance.m_CurrentCardExpansionType);
		}

		[HarmonyPatch("OnCardExpansionUpdated")]
		[HarmonyPostfix]
		private static void OnCardExpansionUpdatedPostfix(WorkbenchUIScreen __instance, CEventPlayer_OnCardExpansionSelectScreenUpdated evt)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			__instance.OnRarityLimitUpdated(new CEventPlayer_OnCardRaritySelectScreenUpdated(-1));
		}
	}
	[HarmonyPatch(typeof(Worker))]
	internal class WorkerPatches
	{
		[HarmonyPatch("LoadWorkerSaveData")]
		[HarmonyPostfix]
		private static void LoadWorkerSaveDataPostfix(Worker __instance)
		{
			SyncEnabledList(__instance);
		}

		private static void SyncEnabledList(Worker worker)
		{
			List<bool> cardPackItemTypeEnabledList = worker.GetCardPackItemTypeEnabledList();
			if (cardPackItemTypeEnabledList == null)
			{
				return;
			}
			int count = worker.m_CardPackItemTypeList.Count;
			if (count != 0)
			{
				while (cardPackItemTypeEnabledList.Count < count)
				{
					cardPackItemTypeEnabledList.Add(item: true);
				}
				while (cardPackItemTypeEnabledList.Count > count)
				{
					cardPackItemTypeEnabledList.RemoveAt(cardPackItemTypeEnabledList.Count - 1);
				}
			}
		}
	}
	[HarmonyPatch(typeof(WorkerSetPackOpenerTypeOptionScreen))]
	internal class WorkerSetPackOpenerTypeOptionScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyPrefix]
		private static void OpenScreenPrefix(WorkerSetPackOpenerTypeOptionScreen __instance)
		{
			EplRuntimeData.Services.WorkerPackOpenerScreenService.OpenScreen(__instance);
		}

		[HarmonyPatch("OpenScreen")]
		[HarmonyPostfix]
		private static void OpenScreenPostfix()
		{
			EplRuntimeData.Services.WorkerPackOpenerScreenService.LoadEplPackIcons();
			EplRuntimeData.Services.WorkerPackOpenerScreenService.ResetScroll();
		}
	}
}
namespace EnhancedPrefabLoader.Core.Packs.PackGenerators
{
	internal class AllRandomPackGenerator : IPackGenerator
	{
		[CompilerGenerated]
		private CardGenerationData <generationData>P;

		public AllRandomPackGenerator(CardGenerationData generationData)
		{
			<generationData>P = generationData;
			base..ctor();
		}

		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			if (!<generationData>P.CanHaveDuplicates)
			{
				return cardPool.Shuffle().Take(7).ToList();
			}
			List<MonsterData> list = new List<MonsterData>();
			for (int i = 0; i < 7; i++)
			{
				int index = Random.Range(0, cardPool.Count);
				list.Add(cardPool[index]);
			}
			return list;
		}
	}
	internal class GodPackGenerator : IPackGenerator
	{
		[CompilerGenerated]
		private CardGenerationData <generationData>P;

		public GodPackGenerator(CardGenerationData generationData)
		{
			<generationData>P = generationData;
			base..ctor();
		}

		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			//IL_0108: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ERarity, float> validWeights = <generationData>P.GodGenerationWeights.Where((KeyValuePair<ERarity, float> kvp) => kvp.Value > 0f).ToDictionary((KeyValuePair<ERarity, float> kvp) => kvp.Key, (KeyValuePair<ERarity, float> kvp) => kvp.Value);
			Dictionary<ERarity, List<MonsterData>> dictionary = (from c in cardPool
				where validWeights.ContainsKey(c.Rarity)
				group c by c.Rarity).ToDictionary((IGrouping<ERarity, MonsterData> g) => g.Key, (IGrouping<ERarity, MonsterData> g) => g.ToList());
			List<MonsterData> list = new List<MonsterData>();
			for (int i = 0; i < 7; i++)
			{
				ERarity key = RandomUtils.Weighted(validWeights);
				List<MonsterData> list2 = dictionary[key];
				int index = Random.Range(0, list2.Count);
				list.Add(list2[index]);
			}
			return list;
		}
	}
	internal class GuaranteedSlotPackGenerator : IPackGenerator
	{
		[CompilerGenerated]
		private CardGenerationData <generationData>P;

		public GuaranteedSlotPackGenerator(CardGenerationData generationData)
		{
			<generationData>P = generationData;
			base..ctor();
		}

		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			List<MonsterData> list = new List<MonsterData>();
			Dictionary<ERarity, List<MonsterData>> cardsByRarity = (from c in cardPool
				group c by c.Rarity).ToDictionary((IGrouping<ERarity, MonsterData> g) => g.Key, (IGrouping<ERarity, MonsterData> g) => g.ToList());
			foreach (KeyValuePair<PackSlot, Dictionary<ERarity, float>> packSlotWeight in <generationData>P.PackSlotWeights)
			{
				packSlotWeight.Deconstruct(out var _, out var value);
				ERarity key2 = RandomUtils.Weighted(value.Where((KeyValuePair<ERarity, float> kvp) => cardsByRarity.ContainsKey(kvp.Key)).ToDictionary((KeyValuePair<ERarity, float> kvp) => kvp.Key, (KeyValuePair<ERarity, float> kvp) => kvp.Value));
				int index = Random.Range(0, cardsByRarity[key2].Count);
				list.Add(cardsByRarity[key2][index]);
				if (!<generationData>P.CanHaveDuplicates)
				{
					cardsByRarity[key2].SwapAndRemove(index);
					if (cardsByRarity[key2].Count == 0)
					{
						cardsByRarity.Remove(key2);
					}
				}
			}
			return list;
		}
	}
	public enum PackGenerationStrategy
	{
		Guaranteed = 1,
		AllRandomWeighted,
		AllRandom,
		GodPack
	}
	internal static class PackGeneratorFactory
	{
		internal static IPackGenerator For(PackGenerationStrategy strategy, CardGenerationData generationData)
		{
			return (IPackGenerator)(strategy switch
			{
				PackGenerationStrategy.AllRandom => new AllRandomPackGenerator(generationData), 
				PackGenerationStrategy.AllRandomWeighted => new WeightedAllRandomPackGenerator(generationData), 
				PackGenerationStrategy.Guaranteed => new GuaranteedSlotPackGenerator(generationData), 
				PackGenerationStrategy.GodPack => new GodPackGenerator(generationData), 
				_ => new AllRandomPackGenerator(generationData), 
			});
		}
	}
	internal class WeightedAllRandomPackGenerator : IPackGenerator
	{
		[CompilerGenerated]
		private CardGenerationData <generationData>P;

		public WeightedAllRandomPackGenerator(CardGenerationData generationData)
		{
			<generationData>P = generationData;
			base..ctor();
		}

		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			//IL_0108: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ERarity, float> validWeights = <generationData>P.NormalGenerationWeights.Where((KeyValuePair<ERarity, float> kvp) => kvp.Value > 0f).ToDictionary((KeyValuePair<ERarity, float> kvp) => kvp.Key, (KeyValuePair<ERarity, float> kvp) => kvp.Value);
			Dictionary<ERarity, List<MonsterData>> dictionary = (from c in cardPool
				where validWeights.ContainsKey(c.Rarity)
				group c by c.Rarity).ToDictionary((IGrouping<ERarity, MonsterData> g) => g.Key, (IGrouping<ERarity, MonsterData> g) => g.ToList());
			List<MonsterData> list = new List<MonsterData>();
			for (int i = 0; i < 7; i++)
			{
				ERarity key = RandomUtils.Weighted(validWeights);
				List<MonsterData> list2 = dictionary[key];
				int index = Random.Range(0, list2.Count);
				list.Add(list2[index]);
				if (!<generationData>P.CanHaveDuplicates)
				{
					list2.SwapAndRemove(index);
					if (list2.Count == 0)
					{
						validWeights.Remove(key);
					}
				}
			}
			return list;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Models.SaveData
{
	[Serializable]
	internal class CardExpansionSaveData : EplBaseSaveData, IResettable, IPriceResettable, IPostLoadNormalizer
	{
		public List<int> CardCountList { get; set; } = new List<int>();


		public List<MarketPrice> CardMarketPriceList { get; set; } = new List<MarketPrice>();


		public List<float> CardPriceList { get; set; } = new List<float>();


		public List<List<float>> GradedCardPriceList { get; set; } = new List<List<float>>();


		public List<bool> IsCardCollectedList { get; set; } = new List<bool>();


		public CardExpansionSaveData(int numCards)
		{
			CardCountList = Enumerable.Repeat(0, Math.Max(0, numCards)).ToList();
			CardMarketPriceList = Enumerable.Range(0, Math.Max(0, numCards)).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())).ToList();
			List<float> list = new List<float>();
			foreach (int item2 in Enumerable.Repeat(0, Math.Max(0, numCards)))
			{
				list.Add(item2);
			}
			CardPriceList = list;
			IsCardCollectedList = Enumerable.Repeat(element: false, Math.Max(0, numCards)).ToList();
			GradedCardPriceList = new List<List<float>>();
			for (int i = 0; i < numCards; i++)
			{
				list = new List<float>();
				foreach (int item3 in Enumerable.Repeat(0, 10))
				{
					list.Add(item3);
				}
				List<float> item = list;
				GradedCardPriceList.Add(item);
			}
		}

		public void Reset()
		{
			CardCountList = (from _ in Enumerable.Range(0, CardCountList.Count)
				select 0).ToList();
			CardMarketPriceList = Enumerable.Range(0, CardMarketPriceList.Count).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())).ToList();
			List<float> list = new List<float>();
			foreach (int item2 in from _ in Enumerable.Range(0, CardPriceList.Count)
				select 0)
			{
				list.Add(item2);
			}
			CardPriceList = list;
			IsCardCollectedList = (from _ in Enumerable.Range(0, IsCardCollectedList.Count)
				select false).ToList();
			GradedCardPriceList = new List<List<float>>();
			for (int i = 0; i < IsCardCollectedList.Count; i++)
			{
				list = new List<float>();
				foreach (int item3 in Enumerable.Repeat(0, 10))
				{
					list.Add(item3);
				}
				List<float> item = list;
				GradedCardPriceList.Add(item);
			}
		}

		public void NormalizeAfterLoad(string key)
		{
			//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_0020: Unknown result type (might be due to invalid IL or missing references)
			ECardExpansionType key2 = Enum.Parse<ECardExpansionType>(key.Split(':')[1]);
			ModCardExpansionData modCardExpansionData = EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData[key2];
			int num = ((!modCardExpansionData.HasRandomFoils) ? 1 : 2);
			int num2 = modCardExpansionData.Cards.Count * num;
			List<int> cardCountList = CardCountList;
			List<int> list = new List<int>();
			list.AddRange(Enumerable.Repeat(0, Math.Max(0, num2 - CardCountList.Count)));
			cardCountList.AddRange(new <>z__ReadOnlyList<int>(list));
			List<MarketPrice> cardMarketPriceList = CardMarketPriceList;
			List<MarketPrice> list2 = new List<MarketPrice>();
			list2.AddRange(Enumerable.Range(0, Math.Max(0, num2 - CardMarketPriceList.Count)).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())));
			cardMarketPriceList.AddRange(new <>z__ReadOnlyList<MarketPrice>(list2));
			List<float> cardPriceList = CardPriceList;
			List<float> list3 = new List<float>();
			foreach (int item2 in Enumerable.Repeat(0, Math.Max(0, num2 - CardPriceList.Count)))
			{
				list3.Add(item2);
			}
			cardPriceList.AddRange(new <>z__ReadOnlyList<float>(list3));
			List<bool> isCardCollectedList = IsCardCollectedList;
			List<bool> list4 = new List<bool>();
			list4.AddRange(Enumerable.Repeat(element: false, Math.Max(0, num2 - IsCardCollectedList.Count)));
			isCardCollectedList.AddRange(new <>z__ReadOnlyList<bool>(list4));
			for (int i = 0; i < num2 - GradedCardPriceList.Count; i++)
			{
				list3 = new List<float>();
				foreach (int item3 in Enumerable.Repeat(0, 10))
				{
					list3.Add(item3);
				}
				List<float> item = list3;
				GradedCardPriceList.Add(item);
			}
		}

		public void ResetPrices()
		{
			CardMarketPriceList = Enumerable.Range(0, CardMarketPriceList.Count).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())).ToList();
			List<float> list = new List<float>();
			foreach (int item in from _ in Enumerable.Range(0, CardPriceList.Count)
				select 0)
			{
				list.Add(item);
			}
			CardPriceList = list;
			GradedCardPriceList = new List<List<float>>();
		}
	}
	[Serializable]
	internal class DecoSaveData : EplBaseSaveData, IResettable
	{
		public bool IsUnlocked { get; set; }

		public int ItemCount { get; set; }

		public void Reset()
		{
			IsUnlocked = false;
			ItemCount = 0;
		}
	}
	internal class EplBaseSaveData
	{
	}
	public interface IPostLoadNormalizer
	{
		void NormalizeAfterLoad(string key);
	}
	public interface IPriceResettable
	{
		void ResetPrices();
	}
	public interface IResettable
	{
		void Reset();
	}
	[Serializable]
	internal class ItemSaveData : EplBaseSaveData, IResettable, IPriceResettable
	{
		[JsonProperty("IsUnlocked")]
		public bool IsBigBoxUnlocked { get; set; }

		public bool IsSmallBoxUnlocked { get; set; }

		public float ItemPriceChangePercent { get; set; }

		public float ItemPrice { get; set; }

		public float GeneratedCostPrice { get; set; }

		public float GeneratedMarketPrice { get; set; }

		public float AverageItemCost { get; set; }

		public int CurrentItemCount { get; set; }

		public FloatList ItemPriceChangeHistory { get; set; } = new FloatList();


		public void Reset()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			IsBigBoxUnlocked = false;
			IsSmallBoxUnlocked = false;
			ItemPriceChangePercent = 0f;
			ItemPrice = 0f;
			GeneratedCostPrice = 0f;
			GeneratedMarketPrice = 0f;
			AverageItemCost = 0f;
			CurrentItemCount = 0;
			ItemPriceChangeHistory = new FloatList();
		}

		public void ResetPrices()
		{
			ItemPriceChangePercent = 0f;
			ItemPrice = 0f;
			GeneratedCostPrice = 0f;
			GeneratedMarketPrice = 0f;
			AverageItemCost = 0f;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Models.Runtime
{
	internal class CardGenerationData
	{
		internal bool CanHaveDuplicates { get; set; }

		internal bool CanHaveGodPack { get; set; }

		internal float GodPackPercentage { get; set; }

		internal IPackGenerator PackGenerator { get; set; }

		internal IPackGenerator? GodPackGenerator { get; set; }

		internal ECardExpansionType Expansion { get; set; }

		internal ECollectionPackType PackType { get; set; }

		internal Dictionary<ERarity, float> NormalGenerationWeights { get; set; } = new Dictionary<ERarity, float>();


		internal Dictionary<ERarity, float> GodGenerationWeights { get; set; } = new Dictionary<ERarity, float>();


		internal SortedDictionary<PackSlot, Dictionary<ERarity, float>> PackSlotWeights { get; set; } = new SortedDictionary<PackSlot, Dictionary<ERarity, float>>();

	}
	internal class CustomShopData
	{
		internal string PhoneAppId { get; set; } = string.Empty;


		internal string AppDisplayName { get; set; } = string.Empty;


		internal string AppIcon { get; set; } = string.Empty;


		internal string AppInnerBGImage { get; set; } = string.Empty;


		internal string AppOuterBGImage { get; set; } = string.Empty;


		internal StreamingAsset<Sprite>? SiteLogo { get; set; }

		internal StreamingAsset<Sprite>? SiteHeader { get; set; }

		internal StreamingAsset<Sprite>? SiteBackground { get; set; }

		internal List<RestockData> TCG { get; } = new List<RestockData>();


		internal List<RestockData> Accessories { get; } = new List<RestockData>();


		internal List<RestockData> Figurines { get; } = new List<RestockData>();

	}
	internal class ModCardData
	{
		internal bool IsFoil { get; set; }

		internal MonsterData MonsterData { get; set; }

		internal StreamingAsset<Texture>? Cardback { get; set; }

		internal StreamingAsset<Sprite> Icon { get; set; }

		internal StreamingAsset<Sprite>? FoilMask { get; set; }

		internal ECardExpansionType ExpansionType { get; set; }

		internal ECardBorderType BorderType { get; set; }

		public static implicit operator CardData(ModCardData data)
		{
			//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_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_0016: 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_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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			return new CardData
			{
				monsterType = data.MonsterData.MonsterType,
				isFoil = data.IsFoil,
				borderType = data.BorderType,
				expansionType = data.ExpansionType
			};
		}
	}
	internal class ModCardExpansionData
	{
		internal string Name { get; set; } = string.Empty;


		internal string MenuCategory { get; set; } = string.Empty;


		internal bool HasRandomFoils { get; set; }

		internal float FoilChance { get; set; }

		internal StreamingAsset<Texture> CardBack { get; set; }

		internal StreamingAsset<Sprite> FoilMask { get; set; }

		internal List<ERarity> Rarities { get; set; } = new List<ERarity>();


		internal Dictionary<EMonsterType, ModCardData> Cards { get; set; } = new Dictionary<EMonsterType, ModCardData>();


		internal Dictionary<EMonsterType, ECardBorderType> CardBorderMap { get; set; } = new Dictionary<EMonsterType, ECardBorderType>();


		internal int TradeUnlockLevel { get; set; }

		internal ICardPriceGenerator CardPriceGenerator { get; set; }

		internal ICardExpGenerator CardExpGenerator { get; set; }

		internal List<Material> PlayCardMaterials { get; set; } = new List<Material>();

	}
	internal class ModDecoData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal DecoData BaseDecoData { get; set; }

		internal DecoPurchaseData BasePurchaseData { get; set; }
	}
	internal class ModFurniturePurchaseData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal ObjectData BaseObjectData { get; set; }

		internal FurniturePurchaseData BaseFurniturePurchaseData { get; set; }
	}
	internal class ModItemData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal ItemData BaseItemData { get; set; }
	}
	internal class ModRestockData
	{
		internal string? PhoneAppId { get; set; }

		internal ItemFlags ItemFlags { get; set; }

		internal RestockData RestockData { get; set; }
	}
	internal class ModShopDecoData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal StreamingAsset<Texture> MainTexture { get; set; }

		internal StreamingAsset<Texture>? RoughnessMap { get; set; }

		internal StreamingAsset<Texture>? NormalMap { get; set; }

		internal ShopDecoData ShopDecoData { get; set; }
	}
}
namespace EnhancedPrefabLoader.Core.LoadingPipeline
{
	internal class BundleAssetsPreloader : IEnumerator
	{
		internal class BundleAssets
		{
			internal Dictionary<string, GameObject> GameObjects { get; } = new Dictionary<string, GameObject>();


			internal Dictionary<string, Material> Materials { get; } = new Dictionary<string, Material>();


			internal Dictionary<string, Mesh> Meshes { get; } = new Dictionary<string, Mesh>();


			internal Dictionary<string, Texture> Textures { get; } = new Dictionary<string, Texture>();

		}

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

			private object <>2__current;

			public BundleDescriptor descriptor;

			public BundleManager.BundleHandle handle;

			public BundleAssets assets;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = BundleAssetsPreloader.LoadAllAsync<GameObject>(descriptor.Name, handle, assets.GameObjects);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = BundleAssetsPreloader.LoadAllAsync<Material>(descriptor.Name, handle, assets.Materials);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = BundleAssetsPreloader.LoadAllByName<Mesh>(descriptor.Name, descriptor.MeshNames, handle, assets.Meshes);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <LoadAllAsync>d__13<T> : IEnumerator<object>, IEnumerator, IDisposable where T : notnull, Object
		{
			private int <>1__state;

			private object <>2__current;

			public BundleManager.BundleHandle handle;

			public string name;

			public Dictionary<string, T> gameObjects;

			private AssetBundleRequest <request>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<request>5__2 = handle.LoadAllAsync<T>();
					if (<request>5__2 == null)
					{
						ModLogger.Error($"Failed to load assets of type {typeof(T)} from bundle {name}", "LoadAllAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleAssetsPreloader.cs");
						return false;
					}
					<>2__current = <request>5__2;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					foreach (T item in <request>5__2.allAssets.OfType<T>())
					{
						gameObjects[((Object)item).name] = item;
					}
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <LoadAllByName>d__12<T> : IEnumerator<object>, IEnumerator, IDisposable where T : notnull, Object
		{
			private int <>1__state;

			private object <>2__current;

			public HashSet<string> assetNames;

			public BundleManager.BundleHandle handle;

			public string name;

			public Dictionary<string, T> assets;

			private HashSet<string>.Enumerator <>7__wrap1;

			private string <assetName>5__3;

			private AssetBundleRequest <request>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = default(HashSet<string>.Enumerator);
				<assetName>5__3 = null;
				<request>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = assetNames.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
					{
						<>1__state = -3;
						Object asset = <request>5__4.asset;
						T val = (T)(object)((asset is T) ? asset : null);
						if (val != null)
						{
							assets[<assetName>5__3] = val;
						}
						<request>5__4 = null;
						<assetName>5__3 = null;
						break;
					}
					}
					if (<>7__wrap1.MoveNext())
					{
						<assetName>5__3 = <>7__wrap1.Current;
						<request>5__4 = handle.LoadAssetAsync<T>(<assetName>5__3);
						if (<request>5__4 == null)
						{
							ModLogger.Error($"Failed to load asset {<assetName>5__3} of type {typeof(T)} from bundle {name}", "LoadAllByName", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleAssetsPreloader.cs");
							result = false;
							<>m__Finally1();
						}
						else
						{
							<>2__current = <request>5__4;
							<>1__state = 1;
							result = true;
						}
					}
					else
					{
						<>m__Finally1();
						<>7__wrap1 = default(HashSet<string>.Enumerator);
						result = false;
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

		private readonly IEnumerator inner;

		internal BundleAssets Result { get; private set; }

		public object Current => inner.Current;

		private BundleAssetsPreloader(IEnumerator inner, BundleAssets bundleAssets)
		{
			this.inner = inner;
			Result = bundleAssets;
		}

		public bool MoveNext()
		{
			return inner.MoveNext();
		}

		public void Reset()
		{
			inner.Reset();
		}

		internal static BundleAssetsPreloader LoadFromAsync(BundleDescriptor descriptor, BundleManager.BundleHandle handle)
		{
			BundleAssets bundleAssets = new BundleAssets();
			return new BundleAssetsPreloader(Load(descriptor, handle, bundleAssets), bundleAssets);
		}

		[IteratorStateMachine(typeof(<Load>d__11))]
		private static IEnumerator Load(BundleDescriptor descriptor, BundleManager.BundleHandle handle, BundleAssets assets)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Load>d__11(0)
			{
				descriptor = descriptor,
				handle = handle,
				assets = assets
			};
		}

		[IteratorStateMachine(typeof(<LoadAllByName>d__12<>))]
		private static IEnumerator LoadAllByName<T>(string name, HashSet<string> assetNames, BundleManager.BundleHandle handle, Dictionary<string, T> assets) where T : Object
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAllByName>d__12<T>(0)
			{
				name = name,
				assetNames = assetNames,
				handle = handle,
				assets = assets
			};
		}

		[IteratorStateMachine(typeof(<LoadAllAsync>d__13<>))]
		private static IEnumerator LoadAllAsync<T>(string name, BundleManager.BundleHandle handle, Dictionary<string, T> gameObjects) where T : Object
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAllAsync>d__13<T>(0)
			{
				name = name,
				handle = handle,
				gameObjects = gameObjects
			};
		}
	}
	internal class BundleLoadingManager
	{
		[CompilerGenerated]
		private sealed class <LoadBundlesAsync>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public BundleLoadingManager <>4__this;

			public string basePath;

			private int <totalBundles>5__2;

			private int <processedBundles>5__3;

			private List<string>.Enumerator <>7__wrap3;

			private BundleInfo <bundleInfo>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap3 = default(List<string>.Enumerator);
				<bundleInfo>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Expected O, but got Unknown
				try
				{
					int num = <>1__state;
					BundleLoadingManager bundleLoadingManager = <>4__this;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						<bundleInfo>5__5.IsLoaded = true;
						goto IL_01b3;
					}
					<>1__state = -1;
					if (EplRuntimeData.IsBundleLoadingComplete)
					{
						bundleLoadingManager.LoadingProgress = 1f;
						bundleLoadingManager.isLoadingComplete = true;
						return false;
					}
					List<string> allJsonFilesIn = FileHelper.GetAllJsonFilesIn(basePath, "*_prefabloader");
					<totalBundles>5__2 = allJsonFilesIn.Count;
					<processedBundles>5__3 = 0;
					<>7__wrap3 = allJsonFilesIn.GetEnumerator();
					<>1__state = -3;
					goto IL_01ff;
					IL_01b3:
					EplRuntimeData.Assets.BundleRegistry.RegisterBundle(<bundleInfo>5__5);
					<processedBundles>5__3++;
					if (<totalBundles>5__2 > 0)
					{
						bundleLoadingManager.LoadingProgress = (float)<processedBundles>5__3 / (float)<totalBundles>5__2;
					}
					<bundleInfo>5__5 = null;
					goto IL_01ff;
					IL_01ff:
					string current;
					BundleDescriptor bundleDescriptor;
					while (true)
					{
						if (<>7__wrap3.MoveNext())
						{
							current = <>7__wrap3.Current;
							try
							{
								bundleDescriptor = JsonConvert.DeserializeObject<BundleDescriptor>(File.ReadAllText(current), new JsonSerializerSettings
								{
									MetadataPropertyHandling = (MetadataPropertyHandling)2
								});
							}
							catch (Exception ex)
							{
								ModLogger.Error("Issues loading jsonfile: " + ex.Message, "LoadBundlesAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleLoadingManager.cs");
								continue;
							}
							if (bundleDescriptor != null)
							{
								break;
							}
							ModLogger.Error("File deserialized to null: " + current, "LoadBundlesAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleLoadingManager.cs");
							continue;
						}
						<>m__Finally1();
						<>7__wrap3 = default(List<string>.Enumerator);
						foreach (List<(int, EItemType)> value in EplRuntimeData.Assets.ItemLibrary.BulkBoxes.Values)
						{
							value.Sort(((int MinPrice, EItemType ItemType) a, (int MinPrice, EItemType ItemType) b) => b.MinPrice.CompareTo(a.MinPrice));
						}
						EplRuntimeData.Assets.ItemLibrary.RestockEntries.Sort((ModRestockData a, ModRestockData b) => a.RestockData.licenseShopLevelRequired.CompareTo(b.RestockData.licenseShopLevelRequired));
						bundleLoadingManager.isLoadingComplete = true;
						EplRuntimeData.Events.FireOnBundleLoadingComplete();
						return false;
					}
					string? directoryName = Path.GetDirectoryName(current);
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(current);
					string bundlePath = Path.Combine(directoryName, fileNameWithoutExtension);
					<bundleInfo>5__5 = new BundleInfo
					{
						JsonPath = current,
						BundlePath = bundlePath,
						Name = bundleDescriptor.Name,
						BundleId = bundleDescriptor.BundleId
					};
					bundleLoadingManager.sanitizerService.Sanitize(bundleDescriptor, <bundleInfo>5__5);
					bundleLoadingManager.validationService.Validate(bundleDescriptor, <bundleInfo>5__5);
					if (<bundleInfo>5__5.IsValid)
					{
						<>2__current = bundleLoadingManager.processingService.ProcessAsync(bundleDescriptor, <bundleInfo>5__5);
						<>1__state = 1;
						return true;
					}
					goto IL_01b3;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap3).Dispose();
			}

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

		private readonly SanitizerService sanitizerService = new SanitizerService();

		private readonly ValidationService validationService = new ValidationService();

		private readonly ProcessingService processingService = new ProcessingService();

		public bool isLoadingComplete;

		public float LoadingProgress { get; private set; }

		[IteratorStateMachine(typeof(<LoadBundlesAsync>d__8))]
		internal IEnumerator LoadBundlesAsync(string basePath)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadBundlesAsync>d__8(0)
			{
				<>4__this = this,
				basePath = basePath
			};
		}
	}
	internal class LoadingScreenMessageService
	{
		[CompilerGenerated]
		private sealed class <CycleMessages>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LoadingScreenMessageService <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				LoadingScreenMessageService loadingScreenMessageService = <>4__this;
				int index;
				Localize? localize;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_002d;
				case 1:
					<>1__state = -1;
					goto IL_0060;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					{
						<>1__state = -1;
						goto IL_002d;
					}
					IL_002d:
					if (loadingScreenMessageService.textMeshPro != null)
					{
						<>2__current = loadingScreenMessageService.FadeText(1f, 0f, 2f);
						<>1__state = 1;
						return true;
					}
					goto IL_0060;
					IL_0060:
					if (loadingScreenMessageService.loadingMessages.Count == 0)
					{
						loadingScreenMessageService.loadingMessages = BuildMessageList();
					}
					index = Random.Range(0, loadingScreenMessageService.loadingMessages.Count);
					localize = loadingScreenMessageService.localize;
					if (localize != null)
					{
						localize.Term = loadingScreenMessageService.loadingMessages[index];
					}
					loadingScreenMessageService.loadingMessages.SwapAndRemove(index);
					if (loadingScreenMessageService.textMeshPro != null)
					{
						<>2__current = loadingScreenMessageService.FadeText(0f, 1f, 2f);
						<>1__state = 2;
						return true;
					}
					break;
				}
				<>2__current = null;
				<>1__state = 3;
				return true;
			}

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

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

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

			private object <>2__current;

			public LoadingScreenMessageService <>4__this;

			public float startAlpha;

			public float endAlpha;

			public float duration;

			private float <elapsed>5__2;

			private Color <color>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//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_0083: 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 num = <>1__state;
				LoadingScreenMessageService loadingScreenMessageService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsed>5__2 = 0f;
					<color>5__3 = ((Graphic)loadingScreenMessageService.textMeshPro).color;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 < duration)
				{
					<elapsed>5__2 += Time.deltaTime;
					float a = Mathf.Lerp(startAlpha, endAlpha, <elapsed>5__2 / duration);
					<color>5__3.a = a;
					((Graphic)loadingScreenMessageService.textMeshPro).color = <color>5__3;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<color>5__3.a = endAlpha;
				((Graphic)loadingScreenMessageService.textMeshPro).color = <color>5__3;
				return false;
			}

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

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

		private Coroutine? activeRoutine;

		private Localize? localize;

		private TextMeshProUGUI? textMeshPro;

		private List<string> loadingMessages = new List<string>();

		public void Initialize()
		{
			Transform val = ((Component)CSingleton<LoadingScreen>.Instance).transform.Find("ScreenGrp/AnimGrp/Text");
			localize = ((Component)val).GetComponent<Localize>();
			textMeshPro = ((Component)val).GetComponent<TextMeshProUGUI>();
			loadingMessages = BuildMessageList();
		}

		private static List<string> BuildMessageList()
		{
			return new List<string>(57)
			{
				"Rigging the booster pack RNG...", "Randomizing your binder sorting...", "Refusing to read the IKEA instructions...", "Resealing packs after removing rares...", "Calculating exactly how much you've spent on cardboard...", "Reminding players that deodorant is not optional...", "Adjusting card prices based on a single Reddit post...", "Un-sticking a customer from the entrance door...", "Alphabetizing the commons... again...", "Convincing customers that 'Near Mint' is a state of mind...",
				"Simulating the smell of a competitive local tournament...", "Scanning for customers trying to pay in loose change and buttons...", "Calculating the odds of a customer actually using the trash can...", "Debating whether a 9.5 is 'Basically a 10' or 'Basically a 1'...", "Pretending that bulk commons are 'premium inventory'...", "Setting up the 'Kids Only' tournament that's 90% adults...", "Explaining that water damage doesn't count as 'natural weathering'...", "Polishing the display case no one ever buys from...", "Restocking energy drinks for the Friday Night Magic grinders...", "Teaching new players that 'proxy' isn't a swear word...",
				"Explaining why we don't accept Monopoly money...", "Counting how many times someone's touched a card without buying it...", "Preparing the 'I know what I have' customer speech...", "Hiding the valuable cards from the guy who 'just wants to look'...", "Sweeping up crushed Doritos from under the gaming tables...", "Resetting the 'Days Since Last Rules Argument' counter to zero...", "Listening to someone explain their 'unbeatable' deck for 20 minutes...", "Nodding along while someone explains card value from 2003...", "Pretending to care about your pulls from a pack you opened in store...", "Calculating trade-in value: 'Best I can do is $3 store credit'...",
				"Stocking sleeves that will be out of stock in 4 minutes...", "Reorganizing singles that customers dumped back in the wrong box...", "Preparing the 'We're not a daycare' announcement...", "Checking if that's a legitimate grading or just a guy with a sharpie...", "Explaining that 'vintage' means old, not valuable...", "Pretending we haven't memorized every regular's usual order...", "Straightening the playmat display for the hundredth time today...", "Updating the tournament bracket that's already wrong...", "Practicing the 'Sorry, we're out of stock' face...", "Arranging deck boxes by color because someone will complain if we don't...",
				"Calculating how many packs until someone pulls something good...", "Preparing the 'Store credit only' policy speech...", "Watching someone shuffle the same deck for 10 minutes...", "Explaining why opened product can't be returned...", "Setting up chairs for an event that starts in 3 hours...", "Answering 'Do you buy cards?' for the 50th time today...", "Ignoring 42 redundant compiler warnings...", "Translating 'Developer Spaghetti' into 'Player Features'...", "Replacing 'Bugs' with 'Surprise Mechanics'...", "Feeding the hamster that powers the loading bar...",
				"Checking if the mod is still compatible with the base game...", "Distracting the player with funny text so they don't notice the lag...", "Fixing one bug, creating seventeen new ones...", "Discovering our mod conflicts with itself somehow...", "Duct taping our mod onto the existing duct tape...", "Asking ChatGPT for more loading screen messages...", "As seen on Real Civil Engineer..."
			};
		}

		public void Start(MonoBehaviour host)
		{
			if (activeRoutine != null)
			{
				ModLogger.Error("Message rotator has already been started.", "Start", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\LoadingScreenMessageService.cs");
			}
			else
			{
				activeRoutine = host.StartCoroutine(CycleMessages());
			}
		}

		public void Stop(MonoBehaviour host)
		{
			if (activeRoutine != null)
			{
				host.StopCoroutine(activeRoutine);
				activeRoutine = null;
			}
		}

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

		[IteratorStateMachine(typeof(<FadeText>d__9))]
		private IEnumerator FadeText(float startAlpha, float endAlpha, float duration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeText>d__9(0)
			{
				<>4__this = this,
				startAlpha = startAlpha,
				endAlpha = endAlpha,
				duration = duration
			};
		}
	}
	internal class ProcessingService
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0
		{
			public ProcessingService <>4__this;

			public BundleDescriptor descriptor;

			public BundleInfo bundleInfo;

			public BundleAssetsPreloader.BundleAssets assets;

			internal void <ProcessAsync>b__0()
			{
				<>4__this.cardExpansionProcessor.Process(descriptor.CardExpansions, bundleInfo, assets);
			}

			internal void <ProcessAsync>b__1()
			{
				<>4__this.prefabProcessor.Process(descriptor.Prefabs, bundleInfo, assets);
			}

			internal void <ProcessAsync>b__2()
			{
				<>4__this.ProcessShops(descriptor.CustomShops, bundleInfo, assets);
			}

			internal void <ProcessAsync>b__3()
			{
				<>4__this.itemProcessor.Process(descriptor.Items, bundleInfo, assets);
			}
		}

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

			private object <>2__current;

			public ProcessingService <>4__this;

			public BundleDescriptor descriptor;

			public BundleInfo bundleInfo;

			private <>c__DisplayClass3_0 <>8__1;

			private BundleManager.BundleHandle <bundleHandle>5__2;

			private BundleAssetsPreloader <assetRequest>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<bundleHandle>5__2 = null;
				<assetRequest>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				ProcessingService processingService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass3_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.descriptor = descriptor;
					<>8__1.bundleInfo = bundleInfo;
					processingService.ProcessAssemblies(<>8__1.descriptor.Assemblies, <>8__1.bundleInfo);
					<bundleHandle>5__2 = EplRuntimeData.Services.BundleManager.GetOrOpen(<>8__1.bundleInfo.BundlePath);
					<>2__current = <bundleHandle>5__2.WaitForLoadAsync();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (<bundleHandle>5__2.HasError)
					{
						<>8__1.bundleInfo.errors.Add("Bundle failed to open " + <>8__1.bundleInfo.BundlePath);
						ModLogger.Error("Bundle failed to open " + <>8__1.bundleInfo.BundlePath, "ProcessAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
						<>8__1.bundleInfo.IsValid = false;
						return false;
					}
					<assetRequest>5__3 = BundleAssetsPreloader.LoadFromAsync(<>8__1.descriptor, <bundleHandle>5__2);
					<>2__current = <assetRequest>5__3;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>8__1.assets = <assetRequest>5__3.Result;
					RunStage("CardExpansions Processing", delegate
					{
						<>8__1.<>4__this.cardExpansionProcessor.Process(<>8__1.descriptor.CardExpansions, <>8__1.bundleInfo, <>8__1.assets);
					}, <>8__1.bundleInfo);
					RunStage("Prefabs Processing", delegate
					{
						<>8__1.<>4__this.prefabProcessor.Process(<>8__1.descriptor.Prefabs, <>8__1.bundleInfo, <>8__1.assets);
					}, <>8__1.bundleInfo);
					RunStage("Shops Processing", delegate
					{
						<>8__1.<>4__this.ProcessShops(<>8__1.descriptor.CustomShops, <>8__1.bundleInfo, <>8__1.assets);
					}, <>8__1.bundleInfo);
					RunStage("Items Processing", delegate
					{
						<>8__1.<>4__this.itemProcessor.Process(<>8__1.descriptor.Items, <>8__1.bundleInfo, <>8__1.assets);
					}, <>8__1.bundleInfo);
					return false;
				}
			}

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

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

		private readonly CardExpansionProcessor cardExpansionProcessor = new CardExpansionProcessor();

		private readonly ItemProcessor itemProcessor = new ItemProcessor();

		private readonly PrefabProcessor prefabProcessor = new PrefabProcessor();

		[IteratorStateMachine(typeof(<ProcessAsync>d__3))]
		internal IEnumerator ProcessAsync(BundleDescriptor descriptor, BundleInfo bundleInfo)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProcessAsync>d__3(0)
			{
				<>4__this = this,
				descriptor = descriptor,
				bundleInfo = bundleInfo
			};
		}

		private static void RunStage(string stageName, Action stage, BundleInfo bundleInfo)
		{
			try
			{
				stage();
			}
			catch (Exception ex)
			{
				bundleInfo.errors.Add(stageName + " stage failed: " + ex.GetType().Name + ": " + ex.Message);
				ModLogger.Error("[" + bundleInfo.Name + "] " + stageName + " stage failed: " + ex.GetType().Name + ": " + ex.Message + "\n" + ex.StackTrace, "RunStage", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
			}
		}

		private void ProcessAssemblies(List<string> assemblies, BundleInfo bundleInfo)
		{
			foreach (string assembly in assemblies)
			{
				string directoryName = Path.GetDirectoryName(bundleInfo.BundlePath);
				string text = Path.Combine(directoryName, assembly);
				if (!File.Exists(text))
				{
					bundleInfo.errors.Add(assembly + " not found in directory " + directoryName);
					ModLogger.Error(assembly + " not found in directory " + directoryName, "ProcessAssemblies", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
					continue;
				}
				try
				{
					EplRuntimeData.Assemblies.Add(Assembly.LoadFrom(text));
				}
				catch (Exception ex)
				{
					bundleInfo.errors.Add("Failed to load " + text + ": " + ex.Message);
					ModLogger.Error("Failed to load " + text + ": " + ex.Message, "ProcessAssemblies", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
				}
			}
		}

		private void ProcessShops(List<CustomShopInfo> customShops, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			foreach (CustomShopInfo item in customShops.Where((CustomShopInfo s) => s.IsValid))
			{
				EplRuntimeData.Assets.ShopLibrary.CustomShops[item.PhoneAppId] = new CustomShopData
				{
					PhoneAppId = item.PhoneAppId,
					AppDisplayName = item.AppDisplayName,
					AppIcon = item.AppIcon,
					AppInnerBGImage = item.AppInnerBGImage,
					AppOuterBGImage = item.AppOuterBGImage,
					SiteLogo = (string.IsNullOrWhiteSpace(item.SiteLogo) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SiteLogo)),
					SiteHeader = (string.IsNullOrWhiteSpace(item.SiteHeader) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SiteHeader)),
					SiteBackground = (string.IsNullOrWhiteSpace(item.SiteBackground) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SiteBackground))
				};
			}
		}
	}
	internal class SanitizerService
	{
		internal void Sanitize(BundleDescriptor descriptor, BundleInfo bundleInfo)
		{
			if (string.IsNullOrWhiteSpace(bundleInfo.Name))
			{
				bundleInfo.Name = Path.GetFileNameWithoutExtension(bundleInfo.BundlePath);
			}
			if (string.IsNullOrWhiteSpace(bundleInfo.BundleId))
			{
				bundleInfo.BundleId = bundleInfo.Name;
			}
			foreach (PrefabInfo prefab in descriptor.Prefabs)
			{
				prefab.ObjectType = StringExtensions.Sanitize(prefab.ObjectType);
				prefab.DecoObject = StringExtensions.Sanitize(prefab.DecoObject);
				prefab.DecoType = StringExtensions.Sanitize(prefab.DecoType);
			}
			foreach (CardExpansionInfo cardExpansion in descriptor.CardExpansions)
			{
				cardExpansion.CardExpansion = StringExtensions.Sanitize(cardExpansion.CardExpansion);
				if (string.IsNullOrWhiteSpace(cardExpansion.CardPriceStrategy))
				{
					cardExpansion.CardPriceStrategy = "Default";
				}
				cardExpansion.CardPriceStrategy = StringExtensions.Sanitize(cardExpansion.CardPriceStrategy);
				if (cardExpansion.HasRandomFoils && cardExpansion.FoilChance == 0f)
				{
					cardExpansion.FoilChance = 0.025f;
				}
				for (int i = 0; i < cardExpansion.Rarities.Count; i++)
				{
					cardExpansion.Rarities[i] = StringExtensions.Sanitize(cardExpansion.Rarities[i]);
				}
				foreach (CardInfo card in cardExpansion.Cards)
				{
					card.Rarity = StringExtensions.Sanitize(card.Rarity);
					card.BorderType = StringExtensions.Sanitize(card.BorderType);
					card.ElementType = StringExtensions.Sanitize(card.ElementType);
				}
			}
			foreach (ItemInfo item in descriptor.Items)
			{
				if (!item.HasBigBox && !item.HasSmallBox)
				{
					item.HasSmallBox = true;
					item.SmallBoxHideTillUnlocked = item.BigBoxHideTillUnlocked;
					item.SmallBoxLicensePrice = item.BigBoxLicensePrice;
					item.SmallBoxLicenseLevelRequirement = item.BigBoxLicenseLevelRequirement;
					item.SmallBoxIgnoreDoubleImage = item.BigBoxIgnoreDoubleImage;
					item.BigBoxHideTillUnlocked = false;
					item.BigBoxLicensePrice = 0f;
					item.BigBoxLicenseLevelRequirement = 0;
					item.BigBoxIgnoreDoubleImage = false;
				}
				item.CardExpansion = StringExtensions.Sanitize(item.CardExpansion);
				item.FollowItemPrice = StringExtensions.Sanitize(item.FollowItemPrice);
				item.ItemCategory = StringExtensions.Sanitize(item.ItemCategory);
				item.ItemType = StringExtensions.Sanitize(item.ItemType);
				item.PackType = StringExtensions.Sanitize(item.PackType);
				item.SpawnsPackType = StringExtensions.Sanitize(item.SpawnsPackType);
				item.MeshToUse = StringExtensions.Sanitize(item.MeshToUse);
				foreach (RarityWeightInfo generationWeight in item.GenerationWeights)
				{
					generationWeight.Rarity = StringExtensions.Sanitize(generationWeight.Rarity);
				}
				item.NormalWeights = item.NormalWeights.ToDictionary<KeyValuePair<string, float>, string, float>((KeyValuePair<string, float> kvp) => StringExtensions.Sanitize(kvp.Key), (KeyValuePair<string, float> kvp) => kvp.Value);
				item.GodWeights = item.GodWeights.ToDictionary<KeyValuePair<string, float>, string, float>((KeyValuePair<string, float> kvp) => StringExtensions.Sanitize(kvp.Key), (KeyValuePair<string, float> kvp) => kvp.Value);
				item.SlotWeights = item.SlotWeights.ToDictionary<KeyValuePair<string, Dictionary<string, float>>, string, Dictionary<string, float>>((KeyValuePair<string, Dictionary<string, float>> kvp) => StringExtensions.Sanitize(kvp.Key), (KeyValuePair<string, Dictionary<string, float>> kvp) => kvp.Value.ToDictionary((KeyValuePair<string, float> inner) => StringExtensions.Sanitize(inner.Key), (KeyValuePair<string, float> inner) => inner.Value));
				if (!item.IsCardPack || string.IsNullOrWhiteSpace(item.CardExpansion))
				{
					continue;
				}
				CardExpansionInfo cardExpansionInfo = descriptor.CardExpansions.FirstOrDefault((CardExpansionInfo e) => e.CardExpansion == item.CardExpansion);
				if (cardExpansionInfo == null)
				{
					continue;
				}
				if (item.GenerationWeights.Count == 0)
				{
					foreach (string item2 in cardExpansionInfo.Rarities.Where((string r) => !string.IsNullOrWhiteSpace(r)))
					{
						item.NormalWeights.TryAdd(item2, 0f);
						item.GodWeights.TryAdd(item2, 0f);
						foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
						{
							slotWeight.Value.TryAdd(item2, 0f);
						}
					}
				}
				ZeroUnsupportedRarityWeights(item, cardExpansionInfo, bundleInfo);
			}
		}

		private void ZeroUnsupportedRarityWeights(ItemInfo item, CardExpansionInfo expansion, BundleInfo bundleInfo)
		{
			HashSet<string> hashSet = new HashSet<string>(expansion.Cards.Select((CardInfo c) => c.Rarity));
			HashSet<string> hashSet2 = new HashSet<string>();
			foreach (string item2 in item.NormalWeights.Keys.ToList())
			{
				if (item.NormalWeights[item2] > 0f && !hashSet.Contains(item2))
				{
					item.NormalWeights[item2] = 0f;
					hashSet2.Add(item2);
				}
			}
			foreach (string item3 in item.GodWeights.Keys.ToList())
			{
				if (item.GodWeights[item3] > 0f && !hashSet.Contains(item3))
				{
					item.GodWeights[item3] = 0f;
					hashSet2.Add(item3);
				}
			}
			foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
			{
				foreach (string item4 in slotWeight.Value.Keys.ToList())
				{
					if (slotWeight.Value[item4] > 0f && !hashSet.Contains(item4))
					{
						slotWeight.Value[item4] = 0f;
						hashSet2.Add(item4);
					}
				}
			}
			foreach (RarityWeightInfo generationWeight in item.GenerationWeights)
			{
				if (!hashSet.Contains(generationWeight.Rarity) && (generationWeight.NormalWeight > 0f || generationWeight.GodPackWeight > 0f))
				{
					generationWeight.NormalWeight = 0f;
					generationWeight.GodPackWeight = 0f;
					hashSet2.Add(generationWeight.Rarity);
				}
			}
			foreach (string item5 in hashSet2)
			{
				string text = item.Name + " has weight assigned to rarity " + item5 + " but expansion " + expansion.Name + " has no cards with that rarity. Weight has been set to 0.";
				bundleInfo.warnings.Add(text);
				ModLogger.Warning(text, "ZeroUnsupportedRarityWeights", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\SanitizerService.cs");
			}
		}
	}
	internal class ValidationService
	{
		private readonly PrefabValidator prefabValidator = new PrefabValidator();

		private readonly CardExpansionValidator cardExpansionValidator = new CardExpansionValidator();

		private readonly ItemValidator itemValidator = new ItemValidator();

		internal void Validate(BundleDescriptor descriptor, BundleInfo bundleInfo)
		{
			if (!File.Exists(bundleInfo.BundlePath))
			{
				bundleInfo.errors.Add("No asset bundle found for " + descriptor.Name);
				ModLogger.Error("No asset bundle found for " + descriptor.Name, "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ValidationService.cs");
				bundleInfo.IsValid = false;
			}
			prefabValidator.Validate(descriptor.Prefabs, bundleInfo);
			cardExpansionValidator.Validate(descriptor.CardExpansions, bundleInfo);
			itemValidator.Validate(descriptor.Items, descriptor.CardExpansions, bundleInfo);
			ValidateCustomShops(descriptor.CustomShops, bundleInfo);
		}

		internal void ValidateCustomShops(List<CustomShopInfo> customShops, BundleInfo bundleInfo)
		{
			foreach (CustomShopInfo customShop in customShops)
			{
				if (string.IsNullOrWhiteSpace(customShop.PhoneAppId))
				{
					bundleInfo.errors.Add(bundleInfo.Name + " has a phone app specified with no phone app id.");
					ModLogger.Error(bundleInfo.Name + " has a phone app specified with no phone app id.", "ValidateCustomShops", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ValidationService.cs");
					customShop.IsValid = false;
				}
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.LoadingPipeline.Validators
{
	internal class CardExpansionValidator
	{
		internal void Validate(List<CardExpansionInfo> cardExpansions, BundleInfo bundleInfo)
		{
			foreach (CardExpansionInfo cardExpansion in cardExpansions)
			{
				if (string.IsNullOrWhiteSpace(cardExpansion.Name))
				{
					bundleInfo.errors.Add("A card expansion in " + bundleInfo.Name + " is missing a Name and will not be processed");
					ModLogger.Error("A card expansion in " + bundleInfo.Name + " is missing a Name and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
				}
				if (string.IsNullOrWhiteSpace(cardExpansion.FoilMask))
				{
					bundleInfo.warnings.Add(cardExpansion.Name + " is missing a foil mask");
					ModLogger.Warning(cardExpansion.Name + " is missing a foil mask", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
				}
				if (string.IsNullOrWhiteSpace(cardExpansion.Cardback))
				{
					bundleInfo.warnings.Add(cardExpansion.Name + " is missing a card back");
					ModLogger.Warning(cardExpansion.Name + " is missing a card back", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
				}
				if (!Enum.TryParse<ECardExpansionType>(cardExpansion.CardExpansion, out ECardExpansionType _))
				{
					bundleInfo.errors.Add(cardExpansion.Name + " has an invalid expansion type and will not be processed");
					ModLogger.Error(cardExpansion.Name + " has an invalid expansion type and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
				}
				ERarity result2;
				if (cardExpansion.Rarities.Count == 0)
				{
					bundleInfo.errors.Add(cardExpansion.Name + " has no rarities asigned to it and will not be processed.");
					ModLogger.Error(cardExpansion.Name + " has no rarities asigned to it and will not be processed.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
				}
				else
				{
					foreach (string rarity in cardExpansion.Rarities)
					{
						if (!Enum.TryParse<ERarity>(rarity, out result2))
						{
							bundleInfo.errors.Add("The rarity " + rarity + " in " + cardExpansion.Name + " is invalid");
							ModLogger.Error("The rarity " + rarity + " in " + cardExpansion.Name + " is invalid", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
							cardExpansion.IsValid = false;
						}
					}
				}
				if (cardExpansion.Cards.Count == 0)
				{
					bundleInfo.errors.Add(cardExpansion.Name + " has no cards assigned to it and will not be processed.");
					ModLogger.Error(cardExpansion.Name + " has no cards assigned to it and will not be processed.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
					continue;
				}
				foreach (CardInfo card in cardExpansion.Cards)
				{
					if (string.IsNullOrWhiteSpace(card.Name))
					{
						bundleInfo.errors.Add("A card in " + cardExpansion.Name + " is missing a name. Expansion will not be processed");
						ModLogger.Error("A card in " + cardExpansion.Name + " is missing a name. Expansion will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
					if (string.IsNullOrWhiteSpace(card.Sprite))
					{
						bundleInfo.warnings.Add(card.Name + " in expansion " + cardExpansion.Name + " is missing a sprite");
						ModLogger.Warning(card.Name + " in expansion " + cardExpansion.Name + " is missing a sprite", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					}
					if (!Enum.TryParse<ERarity>(card.Rarity, out result2) || !cardExpansion.Rarities.Contains(card.Rarity))
					{
						bundleInfo.errors.Add(card.Name + " in expansion " + cardExpansion.Name + " has an invalid rarity. Expansion will not be processed");
						ModLogger.Error(card.Name + " in expansion " + cardExpansion.Name + " has an invalid rarity. Expansion will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
					if (!Enum.TryParse<ECardBorderType>(card.BorderType, out ECardBorderType _))
					{
						bundleInfo.errors.Add(card.Name + " in expansion " + cardExpansion.Name + " has an invalid border type. Expansion will not be processed");
						ModLogger.Error(card.Name + " in expansion " + cardExpansion.Name + " has an invalid border type. Expansion will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
					if (!Enum.TryParse<EElementIndex>(card.ElementType, out EElementIndex _))
					{
						bundleInfo.errors.Add(card.Name + " in expansion " + cardExpansion.Name + " has an invalid element type. Expansion will not be processed");
						ModLogger.Error(card.Name + " in expansion " + cardExpansion.Name + " has an invalid element type. Expansion will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
				}
			}
		}
	}
	internal class ItemValidator
	{
		internal void Validate(List<ItemInfo> items, List<CardExpansionInfo> expansions, BundleInfo bundleInfo)
		{
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Invalid comparison between Unknown and I4
			foreach (ItemInfo item2 in items)
			{
				if (string.IsNullOrWhiteSpace(item2.Name))
				{
					bundleInfo.errors.Add("An item in " + bundleInfo.Name + " is missing a name and will not be processed");
					ModLogger.Error("An item in " + bundleInfo.Name + " is missing a name and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (string.IsNullOrWhiteSpace(item2.SpriteName))
				{
					bundleInfo.warnings.Add(item2.Name + " is missing a sprite");
					ModLogger.Warning(item2.Name + " is missing a sprite", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				}
				if (!Enum.TryParse<EItemType>(item2.ItemType, out EItemType result))
				{
					bundleInfo.errors.Add(item2.Name + " has an invalid item type and will not be processed");
					ModLogger.Error(item2.Name + " has an invalid item type and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (!Enum.TryParse<EItemCategory>(item2.ItemCategory, out EItemCategory result2))
				{
					bundleInfo.errors.Add(item2.Name + " has an invalid item category and will not be processed");
					ModLogger.Error(item2.Name + " has an invalid item category and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (!item2.AddItemAsAccessory && !item2.AddItemAsBoardGame && !item2.AddItemAsFigurine && (int)result2 != 1)
				{
					bundleInfo.warnings.Add(item2.Name + " has no shop categories assigned and will not appear in any shop tab");
					ModLogger.Warning(item2.Name + " has no shop categories assigned and will not appear in any shop tab", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				}
				if (!string.IsNullOrWhiteSpace(item2.FollowItemPrice) && !item2.FollowItemPrice.Equals("None", StringComparison.OrdinalIgnoreCase) && !Enum.TryParse<EItemType>(item2.FollowItemPrice, out result))
				{
					bundleInfo.errors.Add(item2.Name + " specifies an invalid item type " + item2.FollowItemPrice + " for follow item price and will not be processed");
					ModLogger.Error(item2.Name + " specifies an invalid item type " + item2.FollowItemPrice + " for follow item price and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (item2.PriceAffectedBy.Count > 0)
				{
					foreach (string item3 in item2.PriceAffectedBy)
					{
						if (!Enum.TryParse<EPriceChangeType>(item3, out EPriceChangeType _))
						{
							bundleInfo.errors.Add(item2.Name + " specifies an invalid price affected by type " + item3 + " for price affected by and will not be processed");
							ModLogger.Error(item2.Name + " specifies an invalid price affected by type " + item3 + " for price affected by and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
							item2.IsValid = false;
						}
					}
				}
				if (item2.UsesBaseGameMesh && !Enum.TryParse<EItemType>(item2.MeshToUse, out result))
				{
					bundleInfo.errors.Add(item2.Name + " specifies an invalid item type " + item2.MeshToUse + " for mesh to use and will not be processed");
					ModLogger.Error(item2.Name + " specifies an invalid item type " + item2.MeshToUse + " for mesh to use and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (item2.IsCardBox && !Enum.TryParse<EItemType>(item2.SpawnsPackType, out result))
				{
					bundleInfo.errors.Add(item2.Name + " specifies an invalid spawn pack type " + item2.SpawnsPackType + " and will not be processed");
					ModLogger.Error(item2.Name + " specifies an invalid spawn pack type " + item2.SpawnsPackType + " and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (!item2.IsCardPack)
				{
					continue;
				}
				if (!Enum.TryParse<ECardExpansionType>(item2.CardExpansion, out ECardExpansionType _))
				{
					bundleInfo.errors.Add(item2.Name + " is declard to be a pack for an invalid expansion type " + item2.CardExpansion + " and will not be processed.");
					ModLogger.Error(item2.Name + " is declard to be a pack for an invalid expansion type " + item2.CardExpansion + " and will not be processed.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				else
				{
					CardExpansionInfo cardExpansionInfo = expansions.FirstOrDefault((CardExpansionInfo e) => e.CardExpansion == item2.CardExpansion);
					if (cardExpansionInfo == null || !cardExpansionInfo.IsValid)
					{
						bundleInfo.errors.Add(item2.Name + " references expansion " + item2.CardExpansion + " which was not processed and will not be processed");
						ModLogger.Error(item2.Name + " references expansion " + item2.CardExpansion + " which was not processed and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
						item2.IsValid = false;
					}
				}
				if (!Enum.TryParse<ECollectionPackType>(item2.PackType, out ECollectionPackType _))
				{
					bundleInfo.errors.Add(item2.Name + " has an invalid pack type declard and will not be processed.");
					ModLogger.Error(item2.Name + " has an invalid pack type declard and will not be processed.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (!Enum.TryParse<PackGenerationStrategy>(item2.PackGenerationStrategy, out var result6))
				{
					bundleInfo.errors.Add(item2.Name + " has an invalid pack generation strategy declard and will not be processed.");
					ModLogger.Error(item2.Name + " has an invalid pack generation strategy declard and will not be processed.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
					continue;
				}
				bool flag = ((item2.NormalWeights.Count > 0) ? item2.NormalWeights.Values.All((float w) => w <= 0f) : item2.GenerationWeights.TrueForAll((RarityWeightInfo w) => w.NormalWeight <= 0f));
				if (result6 == PackGenerationStrategy.AllRandomWeighted && flag)
				{
					bundleInfo.errors.Add(item2.Name + " has a pack generation strategy that requires at least 1 normal weight to be greater than 0. Item does not meet this and will not be processed");
					ModLogger.Error(item2.Name + " has a pack generation strategy that requires at least 1 normal weight to be greater than 0. Item does not meet this and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				bool flag2 = ((item2.GodWeights.Count > 0) ? item2.GodWeights.Values.All((float w) => w <= 0f) : item2.GenerationWeights.TrueForAll((RarityWeightInfo w) => w.GodPackWeight <= 0f));
				if (item2.CanHaveGodPacks && flag2)
				{
					bundleInfo.errors.Add(item2.Name + " can have god packs and requires at least 1 god pack weight to be greater than 0. Item does not meet this and will not be processed");
					ModLogger.Error(item2.Name + " can have god packs and requires at least 1 god pack weight to be greater than 0. Item does not meet this and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
				if (result6 != PackGenerationStrategy.Guaranteed || item2.SlotWeights.Count <= 0)
				{
					continue;
				}
				foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item2.SlotWeights)
				{
					if (slotWeight.Value.Count == 0)
					{
						bundleInfo.errors.Add(item2.Name + " has slot " + slotWeight.Key + " with no rarities assigned and will not be processed");
						ModLogger.Error(item2.Name + " has slot " + slotWeight.Key + " with no rarities assigned and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
						item2.IsValid = false;
					}
				}
			}
			foreach (ItemInfo item in items.Where((ItemInfo i) => i.IsValid && i.IsCardBox))
			{
				ItemInfo itemInfo = items.FirstOrDefault((ItemInfo i) => i.IsCardPack && i.ItemType == item.SpawnsPackType);
				if (itemInfo == null || !itemInfo.IsValid)
				{
					bundleInfo.errors.Add(item.Name + " spawns pack " + item.SpawnsPackType + " which was not processed and will not be processed");
					ModLogger.Error(item.Name + " spawns pack " + item.SpawnsPackType + " which was not processed and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
			}
		}
	}
	internal class PrefabValidator
	{
		internal void Validate(List<PrefabInfo> prefabs, BundleInfo bundleInfo)
		{
			foreach (PrefabInfo prefab in prefabs)
			{
				if (string.IsNullOrWhiteSpace(prefab.Name))
				{
					bundleInfo.errors.Add("A prefab in " + bundleInfo.Name + " is missing a Name and will not be processed");
					ModLogger.Error("A prefab in " + bundleInfo.Name + " is missing a Name and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					prefab.IsValid = false;
				}
				if (string.IsNullOrWhiteSpace(prefab.SpriteName))
				{
					bundleInfo.warnings.Add(prefab.Name + " does not specify a sprite");
					ModLogger.Warning(prefab.Name + " does not specify a sprite", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
				}
				if (!prefab.AddItemToFurnitureShop && !prefab.IsDecoObject && !prefab.IsDecoWallTexture && !prefab.IsDecoFloorTexture && !prefab.IsDecoCeilingTexture)
				{
					bundleInfo.warnings.Add(prefab.Name + " does not specify if it is a Deco or Furniture item and will not be placed in any shop");
					ModLogger.Warning(prefab.Name + " does not specify if it is a Deco or Furniture item and will not be placed in any shop", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
				}
				if (prefab.IsDecoWallTexture || prefab.IsDecoFloorTexture || prefab.IsDecoCeilingTexture)
				{
					if (string.IsNullOrWhiteSpace(prefab.NormalMap))
					{
						bundleInfo.warnings.Add(prefab.Name + " is missing a normal map.");
						ModLogger.Warning(prefab.Name + " is missing a normal map.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					}
					if (string.IsNullOrWhiteSpace(prefab.RoughnessMap))
					{
						bundleInfo.warnings.Add(prefab.Name + " is missing a roughness map.");
						ModLogger.Warning(prefab.Name + " is missing a roughness map.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					}
					if (string.IsNullOrWhiteSpace(prefab.Texture))
					{
						bundleInfo.warnings.Add(prefab.Name + " is missing a texture.");
						ModLogger.Warning(prefab.Name + " is missing a texture.", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					}
				}
				if (prefab.IsDecoObject)
				{
					if (!Enum.TryParse<EDecoObject>(prefab.DecoObject, out EDecoObject _))
					{
						bundleInfo.errors.Add(prefab.Name + " has an invalid Deco Object value set and will not be processed");
						ModLogger.Error(prefab.Name + " has an invalid Deco Object value set and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
						prefab.IsValid = false;
					}
					if (!Enum.TryParse<EDecoType>(prefab.DecoType, out EDecoType _))
					{
						bundleInfo.errors.Add(prefab.Name + " has an invalid Deco Type value set and will not be processed");
						ModLogger.Error(prefab.Name + " has an invalid Deco Type value set and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
						prefab.IsValid = false;
					}
				}
				if (prefab.AddItemToFurnitureShop && !Enum.TryParse<EObjectType>(prefab.ObjectType, out EObjectType _))
				{
					bundleInfo.errors.Add(prefab.Name + " has an invalid Object type set and will not be processed");
					ModLogger.Error(prefab.Name + " has an invalid Object type set and will not be processed", "Validate", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					prefab.IsValid = false;
				}
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.LoadingPipeline.Processors
{
	internal class CardExpansionProcessor
	{
		internal void Process(List<CardExpansionInfo> cardExpansions, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			BundleAssetsPreloader.BundleAssets assets2 = assets;
			foreach (CardExpansionInfo item2 in cardExpansions.Where((CardExpansionInfo ce) => ce.IsValid))
			{
				Dictionary<EMonsterType, ModCardData> dictionary = new Dictionary<EMonsterType, ModCardData>();
				ECardExpansionType val = Enum.Parse<ECardExpansionType>(item2.CardExpansion);
				foreach (var item3 in item2.Cards.Select((CardInfo card, int index) => (card, index)))
				{
					CardInfo item = item3.Item1;
					EMonsterType val2 = (EMonsterType)(item3.Item2 + 1);
					dictionary[val2] = new ModCardData
					{
						Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.Sprite),
						FoilMask = (string.IsNullOrWhiteSpace(item.FoilMask) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.FoilMask)),
						Cardback = (string.IsNullOrWhiteSpace(item.Cardback) ? null : new StreamingAsset<Texture>(bundleInfo.BundlePath, item.Cardback)),
						IsFoil = item.IsFoil,
						ExpansionType = val,
						BorderType = Enum.Parse<ECardBorderType>(item.BorderType),
						MonsterData = new MonsterData
						{
							Name = item.Name,
							ElementIndex = Enum.Parse<EElementIndex>(item.ElementType),
							Rarity = Enum.Parse<ERarity>(item.Rarity),
							MonsterType = val2,
							NextEvolution = (EMonsterType)0,
							PreviousEvolution = (EMonsterType)0,
							Description = "xxx yyy"
						}
					};
				}
				List<ERarity> rarities = item2.Rarities.Select((string r) => Enum.Parse<ERarity>(r)).ToList();
				CardPriceGenerationStrategy strategy = Enum.Parse<CardPriceGenerationStrategy>(item2.CardPriceStrategy);
				EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData[val] = new ModCardExpansionData
				{
					Name = item2.Name,
					MenuCategory = item2.MenuCategory,
					HasRandomFoils = item2.HasRandomFoils,
					FoilChance = item2.FoilChance,
					Cards = dictionary,
					Rarities = rarities,
					CardBack = new StreamingAsset<Texture>(bundleInfo.BundlePath, item2.Cardback),
					FoilMask = new StreamingAsset<Sprite>(bundleInfo.BundlePath, item2.FoilMask),
					TradeUnlockLevel = item2.TradeUnlockLevel,
					CardPriceGenerator = CardPriceGeneratorFactory.For(strategy, item2),
					CardExpGenerator = (ICardExpGenerator)(object)new CardExpGenerator(),
					PlayCardMaterials = (from m in item2.PlayCardMaterials.Where(assets2.Materials.ContainsKey)
						select assets2.Materials[m]).ToList()
				};
				bundleInfo.expansionTypes.Add(val);
				int numCards = dictionary.Count * ((!item2.HasRandomFoils) ? 1 : 2);
				EplRuntimeData.Services.SaveDataManager.RegisterSaveData<ECardExpansionType, CardExpansionSaveData>(bundleInfo.BundleId, val, new CardExpansionSaveData(numCards));
			}
		}
	}
	internal class ItemProcessor
	{
		internal void Process(List<ItemInfo> items, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemInfo item in items.Where((ItemInfo i) => i.IsValid))
			{
				ItemMeshData val = new ItemMeshData();
				EItemType key = Enum.Parse<EItemType>(item.ItemType);
				ProcessItemMeshes(item, assets.Meshes, val);
				ProcessItemMaterials(item, assets.Materials, val);
				EplRuntimeData.Assets.ItemLibrary.ItemMeshData[key] = val;
				ProcessItem(item, bundleInfo);
			}
		}

		private void ProcessItemMeshes(ItemInfo item, Dictionary<string, Mesh> meshes, ItemMeshData itemMeshData)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			ItemMeshData itemMeshData2 = itemMeshData;
			if (item.UsesBaseGameMesh)
			{
				EItemType baseItemType = Enum.Parse<EItemType>(item.MeshToUse);
				EItemType itemType = Enum.Parse<EItemType>(item.ItemType);
				EplRuntimeData.Events.OnInventoryBaseAwake += delegate
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_001a: Expected I4, but got Unknown
					//IL_004d: 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_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_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_00b2: 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)
					ItemMeshData val = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ItemMeshDataList[(int)baseItemType];
					itemMeshData2.mesh = val.mesh;
					itemMeshData2.meshSecondary = val.meshSecondary;
					if (EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value3))
					{
						ItemData itemData = InventoryBase.GetItemData(baseItemType);
						value3.BaseItemData.colliderPosOffset = itemData.colliderPosOffset;
						value3.BaseItemData.colliderScale = itemData.colliderScale;
						value3.BaseItemData.posYOffsetInBox = itemData.posYOffsetInBox;
						value3.BaseItemData.scaleOffsetInBox = itemData.scaleOffsetInBox;
						value3.BaseItemData.itemDimension = itemData.itemDimension;
						value3.BaseItemData.isTallItem = itemData.isTallItem;
					}
				};
			}
			else
			{
				if (meshes.TryGetValue(item.Mesh, out Mesh value))
				{
					itemMeshData2.mesh = value;
				}
				if (!string.IsNullOrWhiteSpace(item.MeshSecondary) && meshes.TryGetValue(item.MeshSecondary, out Mesh value2))
				{
					itemMeshData2.meshSecondary = value2;
				}
			}
		}

		private void ProcessItemMaterials(ItemInfo item, Dictionary<string, Material> materials, ItemMeshData itemMeshData)
		{
			ItemMeshData itemMeshData2 = itemMeshData;
			if (materials.TryGetValue(item.Material, out Material value))
			{
				CreateLightingAwareMaterial(value, delegate(Material m)
				{
					itemMeshData2.material = m;
				});
			}
			if (materials.TryGetValue(item.MaterialSecondary, out Material value2))
			{
				CreateLightingAwareMaterial(value2, delegate(Material m)
				{
					itemMeshData2.materialSecondary = m;
				});
			}
			ItemMeshData val = itemMeshData2;
			if (val.materialList == null)
			{
				val.materialList = new List<Material>();
			}
			foreach (string material in item.MaterialList)
			{
				if (materials.TryGetValue(material, out Material value3))
				{
					CreateLightingAwareMaterial(value3, delegate(Material m)
					{
						itemMeshData2.materialList.Add(m);
					});
				}
			}
		}

		private void CreateLightingAwareMaterial(Material source, Action<Material> assign)
		{
			Material source2 = source;
			Action<Material> assign2 = assign;
			EplRuntimeData.Events.OnInventoryBaseAwake += delegate
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				Material material = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ItemMeshDataList[0].material;
				Material clone = new Material(material);
				clone.CopyPropertiesFromMaterial(material);
				string[] texturePropertyNames = source2.GetTexturePropertyNames();
				foreach (string text in texturePropertyNames)
				{
					if (clone.HasProperty(text))
					{
						clone.SetTexture(text, source2.GetTexture(text));
					}
				}
				assign2(clone);
				EplRuntimeData.Events.OnLightManagerAwake += delegate
				{
					//IL_0034: 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)
					CSingleton<LightManager>.Instance.m_ItemMatList.Add(clone);
					clone.SetColor("_Color", new Color(0.885f, 0.885f, 0.885f, 1f));
					CSingleton<LightManager>.Instance.m_ItemMatOriginalColorList.Add(clone.GetColor("_Color"));
				};
			};
		}

		private void ProcessItem(ItemInfo item, BundleInfo bundleInfo)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			//IL_0621: Unknown result type (might be due to invalid IL or missing references)
			//IL_062f: Expected O, but got Unknown
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_072a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0736: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0742: Unknown result type (might be due to invalid IL or missing references)
			//IL_0747: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Unknown result type (might be due to invalid IL or missing references)
			//IL_076a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0776: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0687: Unknown result type (might be due to invalid IL or missing references)
			//IL_068e: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06be: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Expected O, but got Unknown
			//IL_0795: Unknown result type (might be due to invalid IL or missing references)
			//IL_079a: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0790: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0801: Unknown result type (might be due to invalid IL or missing references)
			//IL_0806: Unknown result type (might be due to invalid IL or missing references)
			//IL_080d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0812: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a9: Expected O, but got Unknown
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Invalid comparison between Unknown and I4
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_091b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0935: Unknown result type (might be due to invalid IL or missing references)
			//IL_0952: Unknown result type (might be due to invalid IL or missing references)
			//IL_090a: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Invalid comparison between Unknown and I4
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			EItemType itemType = Enum.Parse<EItemType>(item.ItemType);
			if (item.IsCardBox)
			{
				EItemType value = Enum.Parse<EItemType>(item.SpawnsPackType);
				EplRuntimeData.Assets.LookupLibrary.SpawnPackLookup[itemType] = value;
			}
			if (item.IsBulkBox)
			{
				ECardExpansionType key = Enum.Parse<ECardExpansionType>(item.CardExpansion);
				EplRuntimeData.Assets.ItemLibrary.BulkBoxes.GetOrAdd(key, (ECardExpansionType _) => new List<(int, EItemType)>()).Add((item.MinValue, itemType));
			}
			if (item.IsCardPack)
			{
				PackGenerationStrategy strategy = Enum.Parse<PackGenerationStrategy>(item.PackGenerationStrategy);
				ECardExpansionType val = Enum.Parse<ECardExpansionType>(item.CardExpansion);
				ECollectionPackType val2 = Enum.Parse<ECollectionPackType>(item.PackType);
				Dictionary<ERarity, float> dictionary = ((item.NormalWeights.Count > 0) ? item.NormalWeights.ToDictionary<KeyValuePair<string, float>, ERarity, float>((KeyValuePair<string, float> kvp) => Enum.Parse<ERarity>(kvp.Key), (KeyValuePair<string, float> kvp) => kvp.Value) : item.GenerationWeights.ToDictionary((RarityWeightInfo gw) => Enum.Parse<ERarity>(gw.Rarity), (RarityWeightInfo gw) => gw.NormalWeight));
				Dictionary<ERarity, float> godGenerationWeights = ((item.GodWeights.Count > 0) ? item.GodWeights.ToDictionary<KeyValuePair<string, float>, ERarity, float>((KeyValuePair<string, float> kvp) => Enum.Parse<ERarity>(kvp.Key), (KeyValuePair<string, float> kvp) => kvp.Value) : item.GenerationWeights.ToDictionary((RarityWeightInfo gw) => Enum.Parse<ERarity>(gw.Rarity), (RarityWeightInfo gw) => gw.GodPackWeight));
				SortedDictionary<PackSlot, Dictionary<ERarity, float>> sortedDictionary = new SortedDictionary<PackSlot, Dictionary<ERarity, float>>();
				if (item.SlotWeights.Count > 0)
				{
					foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
					{
						PackSlot val3 = Enum.Parse<PackSlot>(slotWeight.Key);
						Dictionary<ERarity, float> value2 = slotWeight.Value.ToDictionary((KeyValuePair<string, float> kvp) => Enum.Parse<ERarity>(kvp.Key), (KeyValuePair<string, float> kvp) => kvp.Value);
						foreach (PackSlot value7 in Enum.GetValues(typeof(PackSlot)))
						{
							if ((int)value7 != 0 && (int)value7 != 255 && (val3 & value7) != 0)
							{
								sortedDictionary[value7] = value2;
							}
						}
					}
				}
				else
				{
					foreach (PackSlot value8 in Enum.GetValues(typeof(PackSlot)))
					{
						if ((int)value8 == 0 || (int)value8 == 255)
						{
							continue;
						}
						Dictionary<ERarity, float> dictionary2 = new Dictionary<ERarity, float>();
						foreach (RarityWeightInfo generationWeight in item.GenerationWeights)
						{
							if (!string.IsNullOrWhiteSpace(generationWeight.GuaranteedSlots) && Enum.TryParse<PackSlot>(generationWeight.GuaranteedSlots, out PackSlot result) && (result & value8) != 0)
							{
								dictionary2[Enum.Parse<ERarity>(generationWeight.Rarity)] = generationWeight.NormalWeight;
							}
						}
						sortedDictionary[value8] = ((dictionary2.Count > 0) ? dictionary2 : dictionary);
					}
				}
				CardGenerationData cardGenerationData = new CardGenerationData
				{
					Expansion = val,
					PackType = val2,
					CanHaveDuplicates = item.CanHaveDuplicates,
					CanHaveGodPack = item.CanHaveGodPacks,
					GodPackPercentage = item.GodPackPercentage,
					NormalGenerationWeights = dictionary,
					GodGenerationWeights = godGenerationWeights,
					PackSlotWeights = sortedDictionary
				};
				cardGenerationData.PackGenerator = PackGeneratorFactory.For(strategy, cardGenerationData);
				cardGenerationData.GodPackGenerator = PackGeneratorFactory.For(PackGenerationStrategy.GodPack, cardGenerationData);
				EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup[itemType] = cardGenerationData;
				EplRuntimeData.Assets.LookupLibrary.ExpansionLookup[val2] = val;
				if (!EplRuntimeData.Assets.LookupLibrary.ExpansionItemLookup.TryGetValue(val, out List<EItemType> value3))
				{
					value3 = new List<EItemType>();
					EplRuntimeData.Assets.LookupLibrary.ExpansionItemLookup[val] = value3;
				}
				value3.Add(itemType);
			}
			ItemFlags itemFlags = ((item.IsCardBox || item.IsCardPack) ? ItemFlags.TCG : ((item.AddItemAsBoardGame ? ItemFlags.BoardGame : ItemFlags.None) | (item.AddItemAsAccessory ? ItemFlags.Accessory : ItemFlags.None) | (item.AddItemAsFigurine ? ItemFlags.Figurine : ItemFlags.None)));
			if (!EplRuntimeData.Assets.LookupLibrary.RestockDataLookup.TryGetValue(itemType, out List<RestockData> value4))
			{
				value4 = new List<RestockData>();
				EplRuntimeData.Assets.LookupLibrary.RestockDataLookup[itemType] = value4;
			}
			if (!string.IsNullOrWhiteSpace(item.PhoneAppId) && EplRuntimeData.Assets.ShopLibrary.CustomShops.TryGetValue(item.PhoneAppId, out CustomShopData value5))
			{
				EplRuntimeData.Assets.ShopLibrary.ItemShopLookup.TryAdd(itemType, value5);
			}
			if (item.HasSmallBox)
			{
				RestockData val6 = new RestockData
				{
					name = item.Name,
					isBigBox = false,
					licenseShopLevelRequired = item.SmallBoxLicenseLevelRequirement,
					licensePrice = item.SmallBoxLicensePrice,
					itemType = itemType,
					isHideItemUntilUnlocked = item.SmallBoxHideTillUnlocked,
					ignoreDoubleImage = item.SmallBoxIgnoreDoubleImage
				};
				value4.Add(val6);
				EplRuntimeData.Assets.ItemLibrary.RestockEntries.Add(new ModRestockData
				{
					ItemFlags = itemFlags,
					PhoneAppId = item.PhoneAppId,
					RestockData = val6
				});
			}
			if (item.HasBigBox)
			{
				RestockData val7 = new RestockData
				{
					name = item.Name,
					isBigBox = true,
					licenseShopLevelRequired = item.BigBoxLicenseLevelRequirement,
					licensePrice = item.BigBoxLicensePrice,
					itemType = itemType,
					isHideItemUntilUnlocked = item.BigBoxHideTillUnlocked,
					ignoreDoubleImage = item.BigBoxIgnoreDoubleImage
				};
				value4.Add(val7);
				EplRuntimeData.Assets.ItemLibrary.RestockEntries.Add(new ModRestockData
				{
					ItemFlags = itemFlags,
					PhoneAppId = item.PhoneAppId,
					RestockData = val7
				});
			}
			ModItemData value6 = new ModItemData
			{
				Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SpriteName),
				BaseItemData = new ItemData
				{
					name = item.Name,
					category = Enum.Parse<EItemCategory>(item.ItemCategory),
					iconScale = 1f,
					baseCost = item.BaseCost,
					marketPriceMaxPercent = item.MaxMarketPricePercent,
					marketPriceMinPercent = item.MinMarketPricePercent,
					boxFollowItemPrice = (EItemType)((!item.IsCardBox || !item.AutoSetBoxPrice) ? (-1) : ((int)Enum.Parse<EItemType>(item.SpawnsPackType))),
					isNotBoosterPack = !item.IsCardPack,
					isTallItem = item.IsTallItem,
					isHideItemUntilUnlocked = (item.BigBoxHideTillUnlocked || item.SmallBoxHideTillUnlocked),
					posYOffsetInBox = item.InBoxOffsetY,
					scaleOffsetInBox = item.InBoxOffsetScale,
					itemDimension = item.ItemDeminsion.ToUnityVector(),
					colliderPosOffset = item.CollidorPosOffset.ToUnityVector(),
					colliderScale = item.ColliderScale.ToUnityVector(),
					affectedPriceChangeType = ((from x in item.PriceAffectedBy?.Select((string price) => StringExtensions.TryParseToEnum<EPriceChangeType>(price))
						where x.HasValue
						select x.Value).ToList() ?? new List<EPriceChangeType>())
				}
			};
			if (!string.IsNullOrWhiteSpace(item.FollowItemPrice) && !item.FollowItemPrice.Equals("None", StringComparison.OrdinalIgnoreCase))
			{
				EItemType baseItemType = Enum.Parse<EItemType>(item.FollowItemPrice);
				EplRuntimeData.Events.OnRestockManagerAwake += delegate
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					ModItemData modItemData = EplRuntimeData.Assets.ItemLibrary.ItemData[itemType];
					ItemData itemData = InventoryBase.GetItemData(baseItemType);
					modItemData.BaseItemData.baseCost = itemData.baseCost;
					modItemData.BaseItemData.marketPriceMaxPercent = itemData.marketPriceMaxPercent;
					modItemData.BaseItemData.marketPriceMinPercent = itemData.marketPriceMinPercent;
				};
			}
			if (item.IsSprayCan)
			{
				EplRuntimeData.Assets.ItemLibrary.SprayCanList.Add(itemType);
			}
			bundleInfo.itemTypes.Add(itemType);
			EplRuntimeData.Assets.ItemLibrary.ItemData[itemType] = value6;
			EplRuntimeData.Services.SaveDataManager.RegisterSaveData<EItemType, ItemSaveData>(bundleInfo.BundleId, itemType, new ItemSaveData());
		}
	}
	internal class PrefabProcessor
	{
		internal void Process(List<PrefabInfo> prefabs, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			foreach (PrefabInfo item in prefabs.Where((PrefabInfo p) => p.IsValid))
			{
				if (item.AddItemToFurnitureShop)
				{
					ProcessFurniture(item, bundleInfo, assets);
				}
				if (item.IsDecoObject || item.IsDecoCeilingTexture || item.IsDecoWallTexture || item.IsDecoFloorTexture)
				{
					ProcessDeco(item, bundleInfo, assets);
				}
			}
		}

		private void ProcessFurniture(PrefabInfo prefab, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//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_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_00a0: 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_00b8: 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_00c5: 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_00d0: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0126: 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)
			GameObject orDefault = assets.GameObjects.GetOrDefault(prefab.PrefabName);
			if (orDefault == null)
			{
				bundleInfo.errors.Add("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name);
				ModLogger.Error("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name, "ProcessFurniture", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Processors\\PrefabProcessor.cs");
				return;
			}
			EObjectType val = Enum.Parse<EObjectType>(prefab.ObjectType);
			ModFurniturePurchaseData value = new ModFurniturePurchaseData
			{
				Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, prefab.SpriteName),
				BaseFurniturePurchaseData = new FurniturePurchaseData
				{
					name = prefab.Name,
					description = prefab.Description,
					levelRequirement = prefab.LevelRequirement,
					price = prefab.Price,
					objectType = val
				},
				BaseObjectData = new ObjectData
				{
					name = prefab.Name,
					objectType = val,
					spawnPrefab = orDefault.GetComponent<InteractableObject>(),
					decoBonus = prefab.DecoBonus
				}
			};
			ProcessVideoClips(orDefault, prefab.VideoClips, prefab.Name, bundleInfo.BundlePath);
			bundleInfo.furnitureTypes.Add(val);
			EplRuntimeData.Assets.FurnitureLibrary.FurnitureData[val] = value;
		}

		private void ProcessDeco(PrefabInfo prefab, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//IL_008e: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c1: Expected O, but got Unknown
			//IL_00c2: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			if (prefab.IsDecoObject)
			{
				GameObject orDefault = assets.GameObjects.GetOrDefault(prefab.PrefabName);
				if (orDefault == null)
				{
					bundleInfo.errors.Add("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name);
					ModLogger.Error("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name, "ProcessDeco", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Processors\\PrefabProcessor.cs");
					return;
				}
				ModDecoData value = new ModDecoData
				{
					Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, prefab.SpriteName),
					BaseDecoData = new DecoData
					{
						name = prefab.Name,
						decoType = Enum.Parse<EDecoType>(prefab.DecoType),
						spawnPrefab = orDefault.GetComponent<InteractableObject>()
					},
					BasePurchaseData = new DecoPurchaseData
					{
						name = prefab.Name,
						mainNameText = prefab.Name,
						levelRequirement = prefab.LevelRequirement,
						price = prefab.Price
					}
				};
				ProcessVideoClips(orDefault, prefab.VideoClips, prefab.Name, bundleInfo.BundlePath);
				EDecoObject val = Enum.Parse<EDecoObject>(prefab.DecoObject);
				bundleInfo.decoObjects.Add(val);
				EplRuntimeData.Assets.DecoLibrary.DecoObjectData[val] = value;
				EplRuntimeData.Services.SaveDataManager.RegisterSaveData<EDecoObject, DecoSaveData>(bundleInfo.BundleId, val, new DecoSaveData());
				return;
			}
			ModShopDecoData item = new ModShopDecoData
			{
				Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, prefab.SpriteName),
				MainTexture = new StreamingAsset<Texture>(bundleInfo.BundlePath, prefab.Texture),
				RoughnessMap = (string.IsNullOrWhiteSpace(prefab.RoughnessMap) ? null : new StreamingAsset<Texture>(bundleInfo.BundlePath, prefab.RoughnessMap)),
				NormalMap = (string.IsNullOrWhiteSpace(prefab.NormalMap) ? null : new StreamingAsset<Texture>(bundleInfo.BundlePath, prefab.NormalMap)),
				ShopDecoData = new ShopDecoData
				{
					name = prefab.Name,
					mainNameText = prefab.Name,
					price = prefab.Price,
					color = prefab.Color.ToUnityColor(),
					smoothness = prefab.Smoothness
				}
			};
			DecoFlags val2;
			if (prefab.IsDecoWallTexture)
			{
				bundleInfo.wallTextures.Add(prefab.Name);
				EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData.Add(item);
				SaveDataService saveDataManager = EplRuntimeData.Services.SaveDataManager;
				string bundleId = bundleInfo.BundleId;
				val2 = (DecoFlags)2;
				saveDataManager.RegisterSaveData(bundleId, ((object)(DecoFlags)(ref val2)).ToString(), bundleInfo.Name, new DecoSaveData());
			}
			if (prefab.IsDecoFloorTexture)
			{
				bundleInfo.floorTextures.Add(prefab.Name);
				EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData.Add(item);
				SaveDataService saveDataManager2 = EplRuntimeData.Services.SaveDataManager;
				string bundleId2 = bundleInfo.BundleId;
				val2 = (DecoFlags)1;
				saveDataManager2.RegisterSaveData(bundleId2, ((object)(DecoFlags)(ref val2)).ToString(), bundleInfo.Name, new DecoSaveData());
			}
			if (prefab.IsDecoCeilingTexture)
			{
				bundleInfo.ceilingTextures.Add(prefab.Name);
				EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData.Add(item);
				SaveDataService saveDataManager3 = EplRuntimeData.Services.SaveDataManager;
				string bundleId3 = bundleInfo.BundleId;
				val2 = (DecoFlags)3;
				saveDataManager3.RegisterSaveData(bundleId3, ((object)(DecoFlags)(ref val2)).ToString(), bundleInfo.Name, new DecoSaveData());
			}
		}

		private void ProcessVideoClips(GameObject gameObject, List<VideoClipInfo> videoClips, string name, string bundlePath)
		{
			foreach (VideoClipInfo videoClip in videoClips)
			{
				VideoPlayer val = ((IEnumerable<VideoPlayer>)gameObject.GetComponentsInChildren<VideoPlayer>(true)).FirstOrDefault((Func<VideoPlayer, bool>)((VideoPlayer v) => ((Object)v).name == videoClip.VideoPlayerName));
				if (val == null)
				{
					ModLogger.Warning("Video player " + videoClip.VideoPlayerName + " not found on prefab " + name, "ProcessVideoClips", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Processors\\PrefabProcessor.cs");
					continue;
				}
				val.source = (VideoSource)1;
				val.url = "file:///" + Path.Combine(Path.GetDirectoryName(bundlePath), videoClip.Name).Replace("\\", "/");
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.InterceptorHandlers
{
	public abstract class BaseListHandler<T> : ListInterceptorHandler<T>
	{
		protected HashSet<string> AcceptedFieldNames { get; private set; } = new HashSet<string>();


		public override bool ShouldHandleCall(string fieldName)
		{
			return AcceptedFieldNames.Contains(fieldName);
		}
	}
	[InterceptorHandler]
	public class CardPackItemTypeListHandler : BaseListHandler<EItemType>
	{
		public CardPackItemTypeListHandler()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_CardPackItemTypeList");
		}

		public override int Count(List<EItemType> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.Count;
		}

		public override EItemType GetItem(List<EItemType> list, int index, string fieldName)
		{
			//IL_0060: 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)
			if (index >= list.Count)
			{
				int num = index - list.Count;
				Dictionary<EItemType, CardGenerationData> generationDataLookup = EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup;
				if (num >= generationDataLookup.Count)
				{
					return (EItemType)(-1);
				}
				return generationDataLookup.Keys.OrderBy((EItemType k) => (int)k).ElementAt(num);
			}
			return list[index];
		}

		public override bool Contains(List<EItemType> list, EItemType value, string fieldName)
		{
			//IL_0001: 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)
			if (!list.Contains(value))
			{
				return EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.ContainsKey(value);
			}
			return true;
		}
	}
	[InterceptorHandler]
	public class CardSpriteListHandler : BaseListHandler<Sprite>
	{
		public CardSpriteListHandler()
		{
			base.AcceptedFieldNames.Add("MonsterData_ScriptableObject.m_CardBackImageList");
			base.AcceptedFieldNames.Add("MonsterData_ScriptableObject.m_CardFoilMaskImageList");
			base.AcceptedFieldNames.Add("CardUI.m_CardRaritySpriteList");
		}

		public override Sprite GetItem(List<Sprite> list, int index, string fieldName)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 7)
			{
				ECardExpansionType result = (ECardExpansionType)index;
				if (index < 200000)
				{
					((ECardExpansionType)7).TryGetNext<ECardExpansionType>(out result, index - 6);
				}
				if (!(fieldName == "MonsterData_ScriptableObject.m_CardBackImageList"))
				{
					if (fieldName == "MonsterData_ScriptableObject.m_CardFoilMaskImageList")
					{
						return null;
					}
					return null;
				}
				return list[0];
			}
			return list[index];
		}
	}
	[InterceptorHandler]
	public class CardUiSettingsListHandler : BaseListHandler<CardUISetting>
	{
		public CardUiSettingsListHandler()
		{
			base.AcceptedFieldNames.Add("MonsterData_ScriptableObject.m_CardUISettingList");
		}

		public override CardUISetting GetItem(List<CardUISetting> list, int index, string fieldName)
		{
			//IL_0005: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			if (index >= 7)
			{
				ECardExpansionType result = (ECardExpansionType)index;
				if (index < 200000)
				{
					((ECardExpansionType)7).TryGetNext<ECardExpansionType>(out result, index - 6);
				}
				return new CardUISetting
				{
					expansionType = result
				};
			}
			return list[index];
		}
	}
	[InterceptorHandler]
	public class DecoCeilingDataListHandler : BaseListHandler<ShopDecoData>
	{
		public DecoCeilingDataListHandler()
		{
			base.AcceptedFieldNames.Add("ShelfData_ScriptableObject.m_CeilingDecoDataList");
		}

		public override int Count(List<ShopDecoData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData.Count;
		}

		public override ShopDecoData GetItem(List<ShopDecoData> list, int index, string fieldName)
		{
			if (index >= list.Count)
			{
				index -= list.Count;
				return EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData[index].ShopDecoData;
			}
			return list[index];
		}

		public override void SetItem(List<ShopDecoData> list, int index, ShopDecoData value, string fieldName)
		{
			if (index >= list.Count)
			{
				index -= list.Count;
				EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData[index].ShopDecoData = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class DecoCountListHandler : BaseListHandler<int>
	{
		public DecoCountListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_DecorationInventoryList");
		}

		public override int Count(List<int> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count;
		}

		public override int GetItem(List<int> list, int index, string fieldName)
		{
			//IL_0009: 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)
			if (index >= 129)
			{
				EDecoObject result = (EDecoObject)index;
				if (index < 200000)
				{
					((EDecoObject)129).TryGetNext<EDecoObject>(out result, index - 128);
				}
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EDecoObject, DecoSaveData>(result, out DecoSaveData data) && data != null)
				{
					return data.ItemCount;
				}
				return 0;
			}
			return list[index];
		}

		public override void SetItem(List<int> list, int index, int value, string fieldName)
		{
			//IL_0009: 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)
			if (index >= 129)
			{
				EDecoObject result = (EDecoObject)index;
				if (index < 200000)
				{
					((EDecoObject)129).TryGetNext<EDecoObject>(out result, index - 128);
				}
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EDecoObject, DecoSaveData>(result, out DecoSaveData data) && data != null)
				{
					data.ItemCount = value;
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class DecoDataListHandler : BaseListHandler<DecoData>
	{
		public DecoDataListHandler()
		{
			base.AcceptedFieldNames.Add("ShelfData_ScriptableObject.m_DecoDataList");
		}

		public override int Count(List<DecoData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count;
		}

		public override DecoData GetItem(List<DecoData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			if (index >= 129)
			{
				EDecoObject result = (EDecoObject)index;
				if (index < 200000)
				{
					((EDecoObject)129).TryGetNext<EDecoObject>(out result, index - 128);
				}
				if (!EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(result, out ModDecoData value))
				{
					return new DecoData();
				}
				return value.BaseDecoData;
			}
			return list[index];
		}

		public override void SetItem(List<DecoData> list, int index, DecoData value, string fieldName)
		{
			//IL_0009: 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)
			if (index >= 129)
			{
				EDecoObject result = (EDecoObject)index;
				if (index < 200000)
				{
					((EDecoObject)129).TryGetNext<EDecoObject>(out result, index - 128);
				}
				EplRuntimeData.Assets.DecoLibrary.DecoObjectData[result].BaseDecoData = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class DecoFloorDataListHandler : BaseListHandler<ShopDecoData>
	{
		public DecoFloorDataListHandler()
		{
			base.AcceptedFieldNames.Add("ShelfData_ScriptableObject.m_FloorDecoDataList");
		}

		public override int Count(List<ShopDecoData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData.Count;
		}

		public override ShopDecoData GetItem(List<ShopDecoData> list, int index, string fieldName)
		{
			if (index >= list.Count)
			{
				index -= list.Count;
				return EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData[index].ShopDecoData;
			}
			return list[index];
		}

		public override void SetItem(List<ShopDecoData> list, int index, ShopDecoData value, string fieldName)
		{
			if (index >= list.Count)
			{
				index -= list.Count;
				EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData[index].ShopDecoData = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class DecoPurchaseDataListHandler : BaseListHandler<DecoPurchaseData>
	{
		public DecoPurchaseDataListHandler()
		{
			base.AcceptedFieldNames.Add("ShelfData_ScriptableObject.m_DecoPurchaseDataList");
		}

		public override int Count(List<DecoPurchaseData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count;
		}

		public override DecoPurchaseData GetItem(List<DecoPurchaseData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			if (index >= 129)
			{
				EDecoObject result = (EDecoObject)index;
				if (index < 200000)
				{
					((EDecoObject)129).TryGetNext<EDecoObject>(out result, index - 128);
				}
				if (!EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(result, out ModDecoData value))
				{
					return new DecoPurchaseData();
				}
				return value.BasePurchaseData;
			}
			return list[index];
		}

		public override void SetItem(List<DecoPurchaseData> list, int index, DecoPurchaseData value, string fieldName)
		{
			//IL_0009: 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)
			if (index >= 129)
			{
				EDecoObject result = (EDecoObject)index;
				if (index < 200000)
				{
					((EDecoObject)129).TryGetNext<EDecoObject>(out result, index - 128);
				}
				EplRuntimeData.Assets.DecoLibrary.DecoObjectData[result].BasePurchaseData = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class DecoWallDataListHandler : BaseListHandler<ShopDecoData>
	{
		public DecoWallDataListHandler()
		{
			base.AcceptedFieldNames.Add("ShelfData_ScriptableObject.m_WallDecoDataList");
		}

		public override int Count(List<ShopDecoData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData.Count;
		}

		public override ShopDecoData GetItem(List<ShopDecoData> list, int index, string fieldName)
		{
			if (index >= list.Count)
			{
				index -= list.Count;
				return EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData[index].ShopDecoData;
			}
			return list[index];
		}

		public override void SetItem(List<ShopDecoData> list, int index, ShopDecoData value, string fieldName)
		{
			if (index >= list.Count)
			{
				index -= list.Count;
				EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData[index].ShopDecoData = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ECollectionSortTypeListHandler : BaseListHandler<int>
	{
		public ECollectionSortTypeListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_CollectionSortingMethodIndexList");
		}

		public override int GetItem(List<int> list, int index, string fieldName)
		{
			//IL_0005: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 7)
			{
				ECardExpansionType result = (ECardExpansionType)index;
				if (index < 200000)
				{
					((ECardExpansionType)7).TryGetNext<ECardExpansionType>(out result, index - 6);
				}
				if (!EplRuntimeData.Assets.CardExpansionLibrary.CurrentExpansionToCurrentSort.TryGetValue(result, out var value))
				{
					value = 3;
					EplRuntimeData.Assets.CardExpansionLibrary.CurrentExpansionToCurrentSort[result] = value;
				}
				return value;
			}
			return list[index];
		}

		public override void SetItem(List<int> list, int index, int value, string fieldName)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 7)
			{
				ECardExpansionType result = (ECardExpansionType)index;
				if (index < 200000)
				{
					((ECardExpansionType)7).TryGetNext<ECardExpansionType>(out result, index - 6);
				}
				EplRuntimeData.Assets.CardExpansionLibrary.CurrentExpansionToCurrentSort[result] = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemCountListHandler : BaseListHandler<int>
	{
		public ItemCountListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_CurrentTotalItemCountList");
		}

		public override int Count(List<int> list, string fieldName)
		{
			return 129 + EplRuntimeData.Assets.ItemLibrary.ItemData.Count;
		}

		public override int GetItem(List<int> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 129)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data) && data != null)
				{
					return data.CurrentItemCount;
				}
				return 0;
			}
			return list[index];
		}

		public override void SetItem(List<int> list, int index, int value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 129)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data) && data != null)
				{
					data.CurrentItemCount = value;
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemDataListHandler : BaseListHandler<ItemData>
	{
		public ItemDataListHandler()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_ItemDataList");
		}

		public override int Count(List<ItemData> list, string fieldName)
		{
			return 129 + EplRuntimeData.Assets.ItemLibrary.ItemData.Count;
		}

		public override ItemData GetItem(List<ItemData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if (index >= 129)
			{
				EItemType key = ItemTypeResolver.Resolve(index);
				if (!EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(key, out ModItemData value))
				{
					return new ItemData
					{
						affectedPriceChangeType = new List<EPriceChangeType>()
					};
				}
				return value.BaseItemData;
			}
			return list[index];
		}
	}
	[InterceptorHandler]
	public class ItemMeshDataHandler : BaseListHandler<ItemMeshData>
	{
		public ItemMeshDataHandler()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_ItemMeshDataList");
		}

		public override int Count(List<ItemMeshData> list, string fieldName)
		{
			return 129 + EplRuntimeData.Assets.ItemLibrary.ItemMeshData.Count;
		}

		public override ItemMeshData GetItem(List<ItemMeshData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			if (index >= 129)
			{
				EItemType result = (EItemType)index;
				if (index < 200000)
				{
					((EItemType)129).TryGetNext<EItemType>(out result, index - 128);
				}
				if (!EplRuntimeData.Assets.ItemLibrary.ItemMeshData.TryGetValue(result, out ItemMeshData value))
				{
					return new ItemMeshData();
				}
				return value;
			}
			return list[index];
		}

		public override void SetItem(List<ItemMeshData> list, int index, ItemMeshData value, string fieldName)
		{
			//IL_0009: 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)
			if (index >= 129)
			{
				EItemType result = (EItemType)index;
				if (index < 200000)
				{
					((EItemType)129).TryGetNext<EItemType>(out result, index - 128);
				}
				EplRuntimeData.Assets.ItemLibrary.ItemMeshData[result] = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemPriceHistoryListHandler : BaseListHandler<FloatList>
	{
		public ItemPriceHistoryListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_ItemPricePercentPastChangeList");
		}

		public override int Count(List<FloatList> list, string fieldName)
		{
			return 129 + EplRuntimeData.Assets.ItemLibrary.ItemData.Count;
		}

		public override FloatList GetItem(List<FloatList> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_003d: Expected O, but got Unknown
			if (index >= 129)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data) && data != null)
				{
					ItemSaveData itemSaveData = data;
					FloatList val2;
					if (itemSaveData.ItemPriceChangeHistory == null)
					{
						FloatList val = new FloatList();
						val2 = val;
						itemSaveData.ItemPriceChangeHistory = val;
					}
					val2 = data.ItemPriceChangeHistory;
					if (val2.floatDataList == null)
					{
						val2.floatDataList = new List<float>();
					}
					return data.ItemPriceChangeHistory;
				}
				return null;
			}
			return list[index];
		}

		public override void SetItem(List<FloatList> list, int index, FloatList value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 129)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data) && data != null)
				{
					data.ItemPriceChangeHistory = value;
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemPriceListHandler : BaseListHandler<float>
	{
		public ItemPriceListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_GeneratedMarketPriceList");
			base.AcceptedFieldNames.Add("CPlayerData.m_GeneratedCostPriceList");
			base.AcceptedFieldNames.Add("CPlayerData.m_ItemPricePercentChangeList");
			base.AcceptedFieldNames.Add("CPlayerData.m_AverageItemCostList");
			base.AcceptedFieldNames.Add("CPlayerData.m_SetItemPriceList");
		}

		public override int Count(List<float> list, string fieldName)
		{
			return 129 + EplRuntimeData.Assets.ItemLibrary.ItemData.Count;
		}

		public override float GetItem(List<float> list, int index, string fieldName)
		{
			//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)
			if (index >= 129)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data))
				{
					if (fieldName.EndsWith("m_GeneratedMarketPriceList"))
					{
						return data.GeneratedMarketPrice;
					}
					if (fieldName.EndsWith("m_GeneratedCostPriceList"))
					{
						return data.GeneratedCostPrice;
					}
					if (fieldName.EndsWith("m_ItemPricePercentChangeList"))
					{
						return data.ItemPriceChangePercent;
					}
					if (fieldName.EndsWith("m_AverageItemCostList"))
					{
						return data.AverageItemCost;
					}
					if (fieldName.EndsWith("m_SetItemPriceList"))
					{
						return data.ItemPrice;
					}
					return 0f;
				}
			}
			return list[index];
		}

		public override void SetItem(List<float> list, int index, float value, string fieldName)
		{
			//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)
			if (index >= 129)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data))
				{
					if (fieldName.EndsWith("m_AverageItemCostList"))
					{
						data.AverageItemCost = value;
					}
					if (fieldName.EndsWith("m_SetItemPriceList"))
					{
						data.ItemPrice = value;
					}
					if (fieldName.EndsWith("m_GeneratedCostPriceList"))
					{
						data.GeneratedCostPrice = value;
					}
					if (fieldName.EndsWith("m_GeneratedMarketPriceList"))
					{
						data.GeneratedMarketPrice = value;
					}
					if (fieldName.EndsWith("m_ItemPricePercentChangeList"))
					{
						data.ItemPriceChangePercent = value;
					}
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemUnlockedListHandler : BaseListHandler<bool>
	{
		public ItemUnlockedListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_IsItemLicenseUnlocked");
		}

		public override int Count(List<bool> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count;
		}

		public override bool GetItem(List<bool> list, int index, string fieldName)
		{
			//IL_0052: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			int count = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList.Count;
			if (index >= count)
			{
				int num = index - count;
				if (num >= EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count)
				{
					return false;
				}
				ModRestockData modRestockData = EplRuntimeData.Assets.ItemLibrary.RestockEntries[num];
				EItemType itemType = modRestockData.RestockData.itemType;
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(itemType, out ItemSaveData data))
				{
					if (!modRestockData.RestockData.isBigBox)
					{
						return data.IsSmallBoxUnlocked;
					}
					return data.IsBigBoxUnlocked;
				}
				return false;
			}
			return list[index];
		}

		public override void SetItem(List<bool> list, int index, bool value, string fieldName)
		{
			//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_0061: Unknown result type (might be due to invalid IL or missing references)
			int count = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList.Count;
			if (index >= count)
			{
				int num = index - count;
				if (num >= EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count)
				{
					return;
				}
				ModRestockData modRestockData = EplRuntimeData.Assets.ItemLibrary.RestockEntries[num];
				EItemType itemType = modRestockData.RestockData.itemType;
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(itemType, out ItemSaveData data))
				{
					if (modRestockData.RestockData.isBigBox)
					{
						data.IsBigBoxUnlocked = value;
					}
					else
					{
						data.IsSmallBoxUnlocked = value;
					}
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class RestockDataListInterceptor : BaseListHandler<RestockData>
	{
		public RestockDataListInterceptor()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_RestockDataList");
		}

		public override int Count(List<RestockData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count;
		}

		public override RestockData GetItem(List<RestockData> list, int index, string fieldName)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (index >= list.Count)
			{
				index -= list.Count;
				if (index >= EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count)
				{
					return new RestockData();
				}
				return EplRuntimeData.Assets.ItemLibrary.RestockEntries[index].RestockData;
			}
			return list[index];
		}
	}
}
namespace EnhancedPrefabLoader.Core.ExternalBridges
{
	public class PhoneOverhaulBridge
	{
		private static PhoneOverhaulBridge instance;

		private const string phoneOverhaulGUID = "munch.PhoneOverhaul";

		private readonly MethodInfo? registerMethod;

		private readonly Type? appSpecType;

		private readonly object? registryInstanceObject;

		public static PhoneOverhaulBridge Instance => instance ?? (instance = new PhoneOverhaulBridge());

		public bool IsLoaded { get; private set; }

		private PhoneOverhaulBridge()
		{
			if (!Chainloader.PluginInfos.TryGetValue("munch.PhoneOverhaul", out var value))
			{
				ModLogger.Error("Phone Overhaul not found. Custom shops will not be created and custom items will go to the base game shop", ".ctor", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			Assembly assembly = ((object)value.Instance).GetType().Assembly;
			appSpecType = assembly.GetType("PhoneOverhaul.API.AppSpec");
			if ((object)appSpecType == null)
			{
				ModLogger.Error("Unable to find required class 'AppSpec'", ".ctor", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			Type type = assembly.GetType("PhoneOverhaul.API.PhoneOverhaulAPI");
			if ((object)type == null)
			{
				ModLogger.Error("Unable to find required class 'PhoneOverhaulAPI'.", ".ctor", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			PropertyInfo propertyInfo = AccessTools.Property(type, "Registry");
			if ((object)propertyInfo == null)
			{
				ModLogger.Error("Unable to find required property 'Registry'", ".ctor", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			registryInstanceObject = propertyInfo.GetValue(null);
			if (registryInstanceObject == null)
			{
				ModLogger.Error("PhoneOverhaul Registry instance is null.", ".ctor", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			registerMethod = AccessTools.Method(registryInstanceObject.GetType(), "Register", (Type[])null, (Type[])null);
			if ((object)registerMethod == null)
			{
				ModLogger.Error("Unable to find required method 'Register'", ".ctor", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
			}
			else
			{
				IsLoaded = true;
			}
		}

		public void RegisterApp(string appId, string displayName, string icon, string innerBackground, string outerBackground, Action onClick)
		{
			if (!IsLoaded)
			{
				ModLogger.Error("Required dependency mod Phone Overhaul is not install or there was an error in loading it.", "RegisterApp", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			try
			{
				object obj = Activator.CreateInstance(appSpecType);
				AccessTools.Field(appSpecType, "AppId").SetValue(obj, appId);
				AccessTools.Field(appSpecType, "DisplayName").SetValue(obj, displayName);
				AccessTools.Field(appSpecType, "Icon").SetValue(obj, icon);
				AccessTools.Field(appSpecType, "InnerBackground").SetValue(obj, innerBackground);
				AccessTools.Field(appSpecType, "OuterBackground").SetValue(obj, outerBackground);
				AccessTools.Field(appSpecType, "OnClick").SetValue(obj, onClick);
				registerMethod?.Invoke(registryInstanceObject, new object[1] { obj });
			}
			catch (Exception arg)
			{
				ModLogger.Error($"Failed to create new phone app {appId}: {arg}", "RegisterApp", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Extensions
{
	internal static class CardDataExtensions
	{
		public static bool IsEqual(this CardData cardData, CardData other)
		{
			//IL_000f: 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_001d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (cardData.isFoil == other.isFoil && cardData.expansionType == other.expansionType && cardData.monsterType == other.monsterType && cardData.borderType == other.borderType && cardData.isDestiny == other.isDestiny)
			{
				return cardData.cardGrade == other.cardGrade;
			}
			return false;
		}
	}
	internal static class EnumExtensions
	{
		public static bool TryGetNext<T>(this T value, out T result, int offset = 1) where T : struct, Enum
		{
			T[] array = (from T x in Enum.GetValues(typeof(T))
				orderby Convert.ToInt32(x)
				select x).ToArray();
			int num = Array.IndexOf(array, value) + offset;
			if (num >= 0 && num < array.Length)
			{
				result = array[num];
				return true;
			}
			result = default(T);
			return false;
		}

		public static T[] GetAllValues<T>(this T _) where T : struct, Enum
		{
			return (from T x in Enum.GetValues(typeof(T))
				orderby Convert.ToInt32(x)
				select x).ToArray();
		}
	}
	internal static class ImageExtensions
	{
		internal static void SetSprite(this Image image, FurniturePurchaseData data)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.TryGetValue(data.objectType, out ModFurniturePurchaseData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(image, value.Icon);
			}
			else
			{
				image.sprite = data.icon;
			}
		}

		internal static void SetSprite(this Image image, DecoPurchaseData data, EDecoObject decoObject)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(image, value.Icon);
			}
			else
			{
				image.sprite = data.icon;
			}
		}

		internal static void SetSprite(this Image image, ItemData data, EItemType itemType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(image, value.Icon);
			}
			else
			{
				image.sprite = data.icon;
			}
		}
	}
	internal static class ModelExtensions
	{
		public static Color ToUnityColor(this ColorData colorData)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			return new Color(colorData.R, colorData.G, colorData.B, colorData.A);
		}

		public static Vector3 ToUnityVector(this Vector3Data vectorData)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(vectorData.X, vectorData.Y, vectorData.Z);
		}
	}
}
namespace EnhancedPrefabLoader.Core.Events
{
	internal class EplEvents : IEplEvents
	{
		internal readonly ShopEvents ShopEvents = new ShopEvents();

		internal readonly ItemEvents ItemEvents = new ItemEvents();

		public IShopEvents Shops => (IShopEvents)(object)ShopEvents;

		public IItemEvents Items => (IItemEvents)(object)ItemEvents;

		private event Action? onInventoryBaseAwake;

		private event Action? onRestockManagerAwake;

		private event Action? onLightManagerAwake;

		private event Action? onBundleLoadingComplete;

		internal event Action? OnInventoryBaseAwake
		{
			add
			{
				onInventoryBaseAwake += value;
			}
			remove
			{
				onInventoryBaseAwake -= value;
			}
		}

		internal event Action? OnRestockManagerAwake
		{
			add
			{
				onRestockManagerAwake += value;
			}
			remove
			{
				onRestockManagerAwake -= value;
			}
		}

		internal event Action? OnLightManagerAwake
		{
			add
			{
				onLightManagerAwake += value;
			}
			remove
			{
				onLightManagerAwake -= value;
			}
		}

		public event Action OnBundleLoadingComplete
		{
			add
			{
				if (EplRuntimeData.IsBundleLoadingComplete)
				{
					value?.Invoke();
				}
				onBundleLoadingComplete += value;
			}
			remove
			{
				onBundleLoadingComplete -= value;
			}
		}

		internal void FireOnInventoryBaseAwake()
		{
			this.onInventoryBaseAwake?.Invoke();
			this.onInventoryBaseAwake = null;
		}

		internal void FireOnRestockManagerAwake()
		{
			this.onRestockManagerAwake?.Invoke();
			this.onRestockManagerAwake = null;
		}

		internal void FireOnLightManagerAwake()
		{
			this.onLightManagerAwake?.Invoke();
			this.onLightManagerAwake = null;
		}

		internal void FireOnBundleLoadingComplete()
		{
			EplRuntimeData.IsBundleLoadingComplete = true;
			this.onBundleLoadingComplete?.Invoke();
		}
	}
	internal class ItemEvents : IItemEvents
	{
		public event Action<PackGenerationEventArgs>? OnBeforePackGenerated;

		internal void FireBeforePackGenerated(PackGenerationEventArgs args)
		{
			this.OnBeforePackGenerated?.Invoke(args);
		}
	}
	internal class ShopEvents : IShopEvents
	{
		public event Action? OnShopsReady;

		internal void FireShopsReady()
		{
			this.OnShopsReady?.Invoke();
		}
	}
}
namespace EnhancedPrefabLoader.Core.Components
{
	public class FlowLayoutGroup : LayoutGroup
	{
		public float SpacingX { get; set; } = 30f;


		public float SpacingY { get; set; } = -45f;


		public float ChildWidth { get; set; } = 325f;


		public float ChildHeight { get; set; } = 184.5f;


		public bool CenterContent { get; set; } = true;


		public List<Transform> Children { get; private set; } = new List<Transform>();


		public int ItemsPerRow
		{
			get
			{
				//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)
				Rect rect = ((LayoutGroup)this).rectTransform.rect;
				float num = ((Rect)(ref rect)).width - (float)((LayoutGroup)this).padding.left - (float)((LayoutGroup)this).padding.right;
				return Mathf.Max(1, Mathf.FloorToInt((num + SpacingX) / (ChildWidth + SpacingX)));
			}
		}

		public static GameObject Create(Transform parent, bool isScrollable)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_00e5: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			GameObject val = new GameObject("FlowLayoutGroup", new Type[5]
			{
				typeof(RectTransform),
				typeof(ScrollRect),
				typeof(ScrollRectAutoScroller),
				typeof(Image),
				typeof(RectMask2D)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			Image component2 = ((Component)component).GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)component2).raycastTarget = true;
			GameObject val2 = new GameObject("FlowContent", new Type[2]
			{
				typeof(RectTransform),
				typeof(FlowLayoutGroup)
			});
			RectTransform component3 = val2.GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component, false);
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(0f, 0f);
			((LayoutGroup)val2.GetComponent<FlowLayoutGroup>()).padding = new RectOffset(10, 10, 0, 0);
			ScrollRect component4 = val.GetComponent<ScrollRect>();
			component4.content = component3;
			component4.viewport = component;
			component4.horizontal = false;
			component4.vertical = isScrollable;
			component4.movementType = (MovementType)2;
			component4.scrollSensitivity = 20f;
			component4.inertia = true;
			component4.decelerationRate = 0.135f;
			return val;
		}

		public override void CalculateLayoutInputHorizontal()
		{
			((LayoutGroup)this).CalculateLayoutInputHorizontal();
			ArrangeChildren();
		}

		public override void CalculateLayoutInputVertical()
		{
			ArrangeChildren();
		}

		public Transform AddFromTemplate(Transform template)
		{
			//IL_0030: 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_005c: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			Transform val = Object.Instantiate<Transform>(template, ((Component)this).transform);
			((Component)val).gameObject.SetActive(true);
			((Object)val).name = ((Object)template).name + "_CLONE";
			val.localPosition = Vector3.zero;
			val.localScale = Vector3.one;
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			if (component != null)
			{
				component.sizeDelta = new Vector2(ChildWidth, ChildHeight);
				component.pivot = new Vector2(0f, 1f);
				component.anchoredPosition = new Vector2(0f, 1f);
			}
			Children.Add(((Component)val).transform);
			return ((Component)val).transform;
		}

		public void AdoptExisting(Transform child)
		{
			//IL_0022: 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)
			child.SetParent(((Component)this).transform, false);
			RectTransform component = ((Component)child).GetComponent<RectTransform>();
			if (component != null)
			{
				component.pivot = new Vector2(0f, 1f);
				component.anchoredPosition = new Vector2(0f, 1f);
			}
			Children.Add(child);
		}

		public void ClearChildren()
		{
			Children.Clear();
			for (int num = ((Component)this).transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Component)this).transform.GetChild(num)).gameObject);
			}
		}

		public override void SetLayoutHorizontal()
		{
		}

		public override void SetLayoutVertical()
		{
		}

		private void ArrangeChildren()
		{
			//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_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = ((LayoutGroup)this).rectTransform.rect;
			float num = ((Rect)(ref rect)).width - (float)((LayoutGroup)this).padding.left - (float)((LayoutGroup)this).padding.right;
			float num2 = ((LayoutGroup)this).padding.top;
			List<List<RectTransform>> list = new List<List<RectTransform>>();
			List<RectTransform> list2 = new List<RectTransform>();
			float num3 = 0f;
			foreach (RectTransform rectChild in ((LayoutGroup)this).rectChildren)
			{
				if (((Component)rectChild).gameObject.activeSelf)
				{
					if (num3 + ChildWidth > num && list2.Count > 0)
					{
						list.Add(list2);
						list2 = new List<RectTransform>();
						num3 = 0f;
					}
					list2.Add(rectChild);
					num3 += ChildWidth + SpacingX;
				}
			}
			if (list2.Count > 0)
			{
				list.Add(list2);
			}
			foreach (List<RectTransform> item in list)
			{
				float num4 = (float)item.Count * ChildWidth + (float)(item.Count - 1) * SpacingX;
				float num5 = ((LayoutGroup)this).padding.left;
				if (CenterContent)
				{
					num5 = (float)((LayoutGroup)this).padding.left + (num - num4) / 2f;
				}
				float num6 = num5;
				foreach (RectTransform item2 in item)
				{
					((LayoutGroup)this).SetChildAlongAxis(item2, 0, num6, ChildWidth);
					((LayoutGroup)this).SetChildAlongAxis(item2, 1, num2, ChildHeight);
					num6 += ChildWidth + SpacingX;
				}
				num2 += ChildHeight + SpacingY;
			}
			float num7 = num2 - SpacingY + (float)((LayoutGroup)this).padding.bottom;
			Vector2 sizeDelta = ((LayoutGroup)this).rectTransform.sizeDelta;
			((LayoutGroup)this).rectTransform.sizeDelta = new Vector2(sizeDelta.x, num7);
			((LayoutGroup)this).SetLayoutInputForAxis(num7, num7, -1f, 1);
		}
	}
	public class ModdedCardUI : MonoBehaviour
	{
		private bool isInitialized;

		private CardUI cardUI;

		private GameObject? foilMask;

		private Transform foilGrpParent;

		private Vector2 centerFrameImageAnchorPos;

		private Vector2 centerFrameImageOffsetMin;

		private Vector2 centerFrameImageOffsetMax;

		private Vector2 centerFrameMaskOffsetMin;

		private Vector2 centerFrameMaskOffsetMax;

		public bool IsDirty { get; set; }

		public void Initialize(CardUI cardUI)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (!isInitialized)
			{
				this.cardUI = cardUI;
				Transform transform = ((Component)this.cardUI.m_CenterFrameImage).transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				centerFrameImageAnchorPos = val.anchoredPosition;
				centerFrameImageOffsetMin = val.offsetMin;
				centerFrameImageOffsetMax = val.offsetMax;
				Transform transform2 = this.cardUI.m_CenterFrameMaskGrp.transform;
				RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				centerFrameMaskOffsetMin = val2.offsetMin;
				centerFrameMaskOffsetMax = val2.offsetMax;
				foilGrpParent = cardUI.m_FoilGrp.transform.parent;
				CreateFoilMask();
				isInitialized = true;
			}
		}

		public void ApplyModdedCardSpecs(Sprite? cardMask, StreamingAsset<Sprite> cardFoilMask)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: 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_0182: 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_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			if (IsDirty)
			{
				RestoreDefaults(cardUI.GetCardData());
				IsDirty = false;
			}
			GameObject? obj = foilMask;
			if (obj != null)
			{
				StreamingAssetExtensions.SetSpriteAsync(obj.GetComponent<Image>(), cardFoilMask);
			}
			Transform transform = cardUI.m_CenterFoilGlitter.transform;
			GameObject? obj2 = foilMask;
			transform.SetParent((obj2 != null) ? obj2.transform : null, false);
			Transform transform2 = cardUI.m_FoilGrp.transform;
			GameObject? obj3 = foilMask;
			transform2.SetParent((obj3 != null) ? obj3.transform : null, false);
			cardUI.m_EvoAndArtistNameGrp.SetActive(false);
			cardUI.m_StatGrp.SetActive(false);
			((Component)cardUI.m_RarityImage).gameObject.SetActive(false);
			((Component)cardUI.m_FirstEditionText).gameObject.SetActive(false);
			((Component)cardUI.m_NumberText).gameObject.SetActive(false);
			((Component)cardUI.m_MonsterNameText).gameObject.SetActive(false);
			Transform transform3 = ((Component)cardUI.m_CenterFrameImage).transform;
			Transform obj4 = ((transform3 is RectTransform) ? transform3 : null);
			if (obj4 != null)
			{
				((RectTransform)obj4).anchoredPosition = Vector2.zero;
			}
			if (obj4 != null)
			{
				((RectTransform)obj4).offsetMax = new Vector2(-22f, 206f);
			}
			if (obj4 != null)
			{
				((RectTransform)obj4).offsetMin = new Vector2(14f, -206f);
			}
			Transform transform4 = cardUI.m_CenterFrameMaskGrp.transform;
			Transform obj5 = ((transform4 is RectTransform) ? transform4 : null);
			if (obj5 != null)
			{
				((RectTransform)obj5).offsetMax = new Vector2(0.25f, 0.1f);
			}
			if (obj5 != null)
			{
				((RectTransform)obj5).offsetMin = new Vector2(0f, 0.95f);
			}
			Transform parent = ((Component)cardUI.m_CardBGImage).transform.parent;
			Transform obj6 = ((parent is RectTransform) ? parent : null);
			if (obj6 != null)
			{
				((RectTransform)obj6).offsetMax = new Vector2(-10f, -10f);
			}
			if (obj6 != null)
			{
				((RectTransform)obj6).offsetMin = new Vector2(10f, 10f);
			}
			cardUI.m_CenterFrameMaskImage.sprite = cardMask;
			cardUI.m_CenterFoilGlitter.SetActive(EplRuntimeData.Config.SparkleFoilEnabled);
		}

		public void RestoreDefaults(CardData cardData)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Invalid comparison between Unknown and I4
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Invalid comparison between Unknown and I4
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Invalid comparison between Unknown and I4
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Invalid comparison between Unknown and I4
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Invalid comparison between Unknown and I4
			cardUI.m_FoilGrp.transform.SetParent(foilGrpParent, false);
			cardUI.m_CenterFoilGlitter.transform.SetParent(cardUI.m_CenterFrameMaskGrp.transform, false);
			Transform transform = cardUI.m_CenterFrameMaskGrp.transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			if (obj != null)
			{
				((RectTransform)obj).offsetMin = centerFrameMaskOffsetMin;
			}
			if (obj != null)
			{
				((RectTransform)obj).offsetMax = centerFrameMaskOffsetMax;
			}
			Transform transform2 = ((Component)cardUI.m_CenterFrameImage).transform;
			Transform obj2 = ((transform2 is RectTransform) ? transform2 : null);
			if (obj2 != null)
			{
				((RectTransform)obj2).anchoredPosition = centerFrameImageAnchorPos;
			}
			if (obj2 != null)
			{
				((RectTransform)obj2).offsetMax = centerFrameImageOffsetMax;
			}
			if (obj2 != null)
			{
				((RectTransform)obj2).offsetMin = centerFrameImageOffsetMin;
			}
			Transform parent = ((Component)cardUI.m_CardBGImage).transform.parent;
			Transform obj3 = ((parent is RectTransform) ? parent : null);
			if (obj3 != null)
			{
				((RectTransform)obj3).offsetMax = Vector2.zero;
			}
			if (obj3 != null)
			{
				((RectTransform)obj3).offsetMin = Vector2.zero;
			}
			cardUI.m_EvoAndArtistNameGrp.SetActive((int)cardData.expansionType != 2);
			cardUI.m_StatGrp.SetActive(true);
			((Component)cardUI.m_RarityImage).gameObject.SetActive((int)cardData.expansionType != 2);
			((Component)cardUI.m_FirstEditionText).gameObject.SetActive((int)cardData.expansionType != 2);
			((Component)cardUI.m_NumberText).gameObject.SetActive((int)cardData.expansionType != 2);
			((Component)cardUI.m_MonsterNameText).gameObject.SetActive((int)cardData.borderType != 5);
		}

		private void CreateFoilMask()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0074: 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_0090: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_0163: 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)
			foilMask = new GameObject("FoilMask", new Type[1] { typeof(RectTransform) });
			Transform transform = foilMask.transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val != null)
			{
				((Transform)val).SetParent(cardUI.m_CenterFrameMaskGrp.transform, false);
			}
			if (val != null)
			{
				((Transform)val).SetAsLastSibling();
			}
			Transform transform2 = cardUI.m_CenterFrameMaskGrp.transform;
			RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			if (val2 != null)
			{
				if (val != null)
				{
					val.anchorMin = Vector2.zero;
				}
				if (val != null)
				{
					val.anchorMax = Vector2.one;
				}
				if (val != null)
				{
					val.anchoredPosition = Vector2.zero;
				}
				if (val != null)
				{
					val.sizeDelta = Vector2.zero;
				}
				if (val != null)
				{
					((Transform)val).localRotation = Quaternion.identity;
				}
				if (val != null)
				{
					((Transform)val).localScale = Vector3.one;
				}
				if (val != null)
				{
					val.pivot = val2.pivot;
				}
			}
			Mask obj = ((val != null) ? ((Component)val).gameObject.AddComponent<Mask>() : null);
			if (obj != null)
			{
				obj.showMaskGraphic = false;
			}
			Image component = cardUI.m_CenterFrameMaskGrp.GetComponent<Image>();
			if (component != null)
			{
				Image obj2 = ((val != null) ? ((Component)val).gameObject.AddComponent<Image>() : null);
				if (obj2 != null)
				{
					obj2.sprite = component.sprite;
				}
				if (obj2 != null)
				{
					((Graphic)obj2).color = ((Graphic)component).color;
				}
				if (obj2 != null)
				{
					((Graphic)obj2).material = ((Graphic)component).material;
				}
				if (obj2 != null)
				{
					((Graphic)obj2).raycastTarget = false;
				}
				if (obj2 != null)
				{
					obj2.type = component.type;
				}
				if (obj2 != null)
				{
					obj2.fillMethod = component.fillMethod;
				}
				if (obj2 != null)
				{
					obj2.fillAmount = component.fillAmount;
				}
			}
			else
			{
				ModLogger.Error("CenterFrameMask has no mask component", "CreateFoilMask", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Components\\ModdedCardUI.cs");
				Object.Destroy((Object)(object)foilMask);
				foilMask = null;
			}
		}
	}
	public class NestedMenu : MonoBehaviour
	{
		public class MenuEntry
		{
			public string Label = string.Empty;

			public UnityAction OnClick;

			public List<MenuEntry>? SubMenu;
		}

		private readonly Stack<List<MenuEntry>> menuHistory = new Stack<List<MenuEntry>>();

		private FlowLayoutGroup flowLayoutGroup;

		private Transform buttonTemplate;

		public NestedMenu Setup(FlowLayoutGroup flowLayoutGroup, Transform buttonTemplate)
		{
			this.flowLayoutGroup = flowLayoutGroup;
			this.buttonTemplate = buttonTemplate;
			return this;
		}

		public void OnOpen(List<MenuEntry> menuEntries, ControllerScreenUIExtension controllerExtension, bool saveLastEntry = false)
		{
			menuHistory.Clear();
			RefreshMenuEntries(menuEntries, controllerExtension, saveLastEntry);
		}

		private void RefreshMenuEntries(List<MenuEntry> menuEntries, ControllerScreenUIExtension controllerExtension, bool saveLastEntry)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			List<MenuEntry> menuEntries2 = menuEntries;
			ControllerScreenUIExtension controllerExtension2 = controllerExtension;
			flowLayoutGroup.ClearChildren();
			foreach (MenuEntry menuEntry in menuEntries2)
			{
				if (menuEntry.SubMenu != null)
				{
					AddNewMenuButton(menuEntry.Label ?? "", (UnityAction)delegate
					{
						menuHistory.Push(menuEntries2);
						RefreshMenuEntries(menuEntry.SubMenu, controllerExtension2, saveLastEntry);
					});
				}
				else
				{
					AddNewMenuButton(menuEntry.Label ?? "", menuEntry.OnClick);
				}
			}
			if (menuHistory.Count > 0)
			{
				AddNewMenuButton("Previous", (UnityAction)delegate
				{
					RefreshMenuEntries(menuHistory.Pop(), controllerExtension2, saveLastEntry);
				});
			}
			UpdateControllerNav(controllerExtension2, saveLastEntry);
			controllerExtension2.OnOpenScreen();
		}

		private void AddNewMenuButton(string label, UnityAction onClick)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = flowLayoutGroup.AddFromTemplate(buttonTemplate);
			Localize componentInChildren = ((Component)obj).GetComponentInChildren<Localize>(true);
			if (componentInChildren != null)
			{
				componentInChildren.SetTerm(label);
			}
			Button componentInChildren2 = ((Component)obj).GetComponentInChildren<Button>(true);
			if (componentInChildren2 != null)
			{
				componentInChildren2.onClick = new ButtonClickedEvent();
				if (onClick != null)
				{
					((UnityEvent)componentInChildren2.onClick).AddListener(onClick);
				}
				((Selectable)componentInChildren2).navigation = Navigation.defaultNavigation;
			}
		}

		private void UpdateControllerNav(ControllerScreenUIExtension controllerExtension, bool saveLastEntry)
		{
			ControllerScreenUIExtension controllerExtension2 = controllerExtension;
			int buttonsPerRow = flowLayoutGroup.ItemsPerRow;
			int num = (flowLayoutGroup.Children.Count + buttonsPerRow - 1) / buttonsPerRow;
			if (saveLastEntry)
			{
				num = Mathf.Max(num, 6);
			}
			List<ControllerButton> controllerButtons = flowLayoutGroup.Children.Select((Transform c) => ((Component)c).GetComponent<ControllerButton>()).ToList();
			List<ControllerBtnList> collection = Enumerable.Range(0, num).Select(delegate(int i)
			{
				//IL_0002: 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_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: 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_0075: 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)
				ControllerBtnList val = default(ControllerBtnList);
				val.rowList = new List<ControllerButton>();
				ControllerBtnList val2 = val;
				int count = i * buttonsPerRow;
				val2.rowList.AddRange(controllerButtons.Skip(count).Take(buttonsPerRow));
				if (saveLastEntry && i < controllerExtension2.m_ControllerBtnColumnList.Count)
				{
					ControllerBtnList val3 = controllerExtension2.m_ControllerBtnColumnList[Mathf.Clamp(i, 0, 5)];
					if (val3.rowList.Count > 0)
					{
						List<ControllerButton> rowList = val2.rowList;
						List<ControllerButton> rowList2 = val3.rowList;
						rowList.Add(rowList2[rowList2.Count - 1]);
					}
				}
				return val2;
			}).ToList();
			controllerExtension2.m_ControllerBtnColumnList.Clear();
			controllerExtension2.m_ControllerBtnColumnList.AddRange(collection);
			controllerExtension2.m_CtrlBtnXChangeMethodList.Clear();
			controllerExtension2.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			if (controllerButtons.Count > 0)
			{
				controllerExtension2.m_StartControllerButton = controllerButtons[0];
			}
		}
	}
	public class ScrollRectAutoScroller : MonoBehaviour
	{
		private ScrollRect scrollRect;

		private RectTransform viewportRect;

		private RectTransform contentRect;

		public float ControllerScrollSpeed { get; set; } = 800f;


		private void Start()
		{
			scrollRect = ((Component)this).GetComponent<ScrollRect>();
			viewportRect = scrollRect.viewport;
			contentRect = scrollRect.content;
		}

		private void Update()
		{
			if (HandleControllerInput())
			{
				return;
			}
			EventSystem current = EventSystem.current;
			GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
			if (!((Object)(object)val == (Object)null))
			{
				RectTransform component = val.GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null) && ((Transform)component).IsChildOf((Transform)(object)contentRect))
				{
					ScrollToRect(component);
				}
			}
		}

		private bool HandleControllerInput()
		{
			//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_0080: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (CSingleton<CGameManager>.Instance.m_DisableController || !CSingleton<InputManager>.Instance.m_IsControllerActive)
			{
				return false;
			}
			Gamepad currentGamepad = CSingleton<InputManager>.Instance.m_CurrentGamepad;
			if (((currentGamepad != null) ? currentGamepad.rightStick : null) == null)
			{
				return false;
			}
			float num = ((InputControl<float>)(object)((Vector2Control)currentGamepad.rightStick).y).ReadValue();
			if (Mathf.Abs(num) > 0.1f)
			{
				scrollRect.velocity = Vector2.zero;
				float num2 = num * ControllerScrollSpeed * Time.deltaTime;
				Vector2 anchoredPosition = contentRect.anchoredPosition;
				anchoredPosition.y -= num2;
				Rect rect = contentRect.rect;
				float height = ((Rect)(ref rect)).height;
				rect = viewportRect.rect;
				float height2 = ((Rect)(ref rect)).height;
				float num3 = Mathf.Max(0f, height - height2);
				anchoredPosition.y = Mathf.Clamp(anchoredPosition.y, 0f, num3);
				contentRect.anchoredPosition = anchoredPosition;
				return true;
			}
			return false;
		}

		private void ScrollToRect(RectTransform target)
		{
			//IL_005c: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			viewportRect.GetWorldCorners(array);
			Vector3[] array2 = (Vector3[])(object)new Vector3[4];
			target.GetWorldCorners(array2);
			if (array2[0].y < array[0].y)
			{
				float num = array[0].y - array2[0].y;
				RectTransform obj = contentRect;
				obj.anchoredPosition += new Vector2(0f, num);
			}
			else if (array2[1].y > array[1].y)
			{
				float num2 = array2[1].y - array[1].y;
				RectTransform obj2 = contentRect;
				obj2.anchoredPosition -= new Vector2(0f, num2);
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Cards
{
	internal static class CardDataFactory
	{
		internal static CardData Create(int cardIndex, ECardExpansionType expansionType, bool isDestiny, int cardGrade)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_005f: 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_006d: Expected O, but got Unknown
			EMonsterType monsterTypeFromCardSaveIndex = CPlayerData.GetMonsterTypeFromCardSaveIndex(cardIndex, expansionType);
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return new CardData
				{
					monsterType = monsterTypeFromCardSaveIndex,
					isFoil = (cardIndex % CPlayerData.GetCardAmountPerMonsterType(expansionType, true) >= CPlayerData.GetCardAmountPerMonsterType(expansionType, false)),
					borderType = (ECardBorderType)(cardIndex % CPlayerData.GetCardAmountPerMonsterType(expansionType, false)),
					isDestiny = isDestiny,
					expansionType = expansionType,
					cardGrade = cardGrade
				};
			}
			CardData val = value.Cards[monsterTypeFromCardSaveIndex];
			if (value.HasRandomFoils)
			{
				val.isFoil = (cardIndex & 1) == 1;
			}
			val.cardGrade = cardGrade;
			return val;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Cards.PriceGenerators
{
	internal enum CardPriceGenerationStrategy
	{
		Default = 1,
		RarityDriven
	}
	internal static class CardPriceGeneratorFactory
	{
		internal static ICardPriceGenerator For(CardPriceGenerationStrategy strategy, CardExpansionInfo expansion)
		{
			return (ICardPriceGenerator)(strategy switch
			{
				CardPriceGenerationStrategy.Default => new DefaultCardPriceGenerator(expansion.DefaultBorderMultiplierBase, expansion.DefaultFoilMultiplier), 
				CardPriceGenerationStrategy.RarityDriven => new RarityDrivenCardPriceGenerator(expansion.RarityDrivenFloor, expansion.RarityDrivenStepSize, expansion.RarityDrivenBorderMultiplierBase, expansion.RarityDrivenFoilMultiplier), 
				_ => new DefaultCardPriceGenerator(expansion.DefaultBorderMultiplierBase, expansion.DefaultFoilMultiplier), 
			});
		}
	}
	internal class DefaultCardPriceGenerator : ICardPriceGenerator
	{
		[CompilerGenerated]
		private float <borderMultiplierBase>P;

		[CompilerGenerated]
		private float <foilMultiplier>P;

		public DefaultCardPriceGenerator(float borderMultiplierBase, float foilMultiplier)
		{
			<borderMultiplierBase>P = borderMultiplierBase;
			<foilMultiplier>P = foilMultiplier;
			base..ctor();
		}

		public float GenerateCardMarketPrice(ECardExpansionType expansionType, EMonsterType monsterType, ECardBorderType borderType, ERarity rarity, List<ERarity> expansionRarities, bool isFoil)
		{
			//IL_0015: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			int count = expansionRarities.Count;
			float num = ((count > 1) ? ((float)expansionRarities.IndexOf(rarity) / (float)(count - 1)) : 0.5f);
			float num2 = Mathf.Pow(<borderMultiplierBase>P, (float)borderType);
			float num3 = 1f + Mathf.Pow(num, 1.6f) * 4f;
			float num4 = 1f + num * 1f;
			float num5 = (isFoil ? <foilMultiplier>P : 1f);
			float num6 = Random.Range(Mathf.Lerp(0.2f, 0.85f, (float)borderType / 5f), 1.15f);
			return num4 * num2 * num3 * num5 * num6;
		}
	}
	internal class RarityDrivenCardPriceGenerator : ICardPriceGenerator
	{
		[CompilerGenerated]
		private float <floor>P;

		[CompilerGenerated]
		private float <stepSize>P;

		[CompilerGenerated]
		private float <borderMultiplierBase>P;

		[CompilerGenerated]
		private float <foilMultiplier>P;

		public RarityDrivenCardPriceGenerator(float floor, float stepSize, float borderMultiplierBase, float foilMultiplier)
		{
			<floor>P = floor;
			<stepSize>P = stepSize;
			<borderMultiplierBase>P = borderMultiplierBase;
			<foilMultiplier>P = foilMultiplier;
			base..ctor();
		}

		public float GenerateCardMarketPrice(ECardExpansionType expansionType, EMonsterType monsterType, ECardBorderType borderType, ERarity rarity, List<ERarity> expansionRarities, bool isFoil)
		{
			//IL_0002: 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)
			int num = expansionRarities.IndexOf(rarity);
			float num2 = <floor>P + (float)num * <stepSize>P;
			float num3 = Mathf.Pow(<borderMultiplierBase>P, (float)borderType);
			float num4 = (isFoil ? <foilMultiplier>P : 1f);
			float num5 = Random.Range(Mathf.Lerp(0.05f, 0.7f, (float)num / 20f), 1.3f);
			return num2 * num3 * num4 * num5;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Cards.ExpGenerators
{
	internal class CardExpGenerator : ICardExpGenerator
	{
		public float CalculateExp(CardData cardData)
		{
			float num = Mathf.Max(0.01f, CPlayerData.GetCardMarketPrice(cardData));
			return Mathf.Clamp((num < 10f) ? Mathf.RoundToInt(Mathf.Lerp(2f, 10f, num / 10f)) : Mathf.RoundToInt(10f + (Mathf.Log10(num) - 1f) * 47.1831f), 2, 150);
		}
	}
}
namespace EnhancedPrefabLoader.Core.Assets
{
	internal class CardExpansionLibrary : ICardExpansionLibrary
	{
		internal Dictionary<ECardExpansionType, ModCardExpansionData> CardExpansionData { get; set; } = new Dictionary<ECardExpansionType, ModCardExpansionData>();


		internal Dictionary<ECardExpansionType, int> CurrentExpansionToCurrentSort { get; set; } = new Dictionary<ECardExpansionType, int>();


		public StreamingAsset<Texture>? GetCardExpansionCardBack(ECardExpansionType cardExpansionType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return null;
			}
			return value.CardBack;
		}

		public StreamingAsset<Sprite>? GetCardExpansionFoilMask(ECardExpansionType cardExpansionType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return null;
			}
			return value.FoilMask;
		}

		public StreamingAsset<Sprite>? GetCardFoilMask(ECardExpansionType cardExpansionType, EMonsterType monsterType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value) && value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return value2.FoilMask ?? value.FoilMask;
			}
			return null;
		}

		public StreamingAsset<Texture>? GetCardBack(ECardExpansionType cardExpansionType, EMonsterType monsterType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value) && value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return value2.Cardback ?? value.CardBack;
			}
			return null;
		}

		public StreamingAsset<Sprite>? GetCardSprite(ECardExpansionType cardExpansionType, EMonsterType monsterType)
		{
			//IL_0006: 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)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return null;
			}
			if (!value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return null;
			}
			return value2.Icon;
		}

		public IReadOnlyDictionary<EMonsterType, StreamingAsset<Sprite>> GetCardSprites(ECardExpansionType cardExpansionType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return new Dictionary<EMonsterType, StreamingAsset<Sprite>>();
			}
			return value.Cards.ToDictionary<KeyValuePair<EMonsterType, ModCardData>, EMonsterType, StreamingAsset<Sprite>>((KeyValuePair<EMonsterType, ModCardData> kvp) => kvp.Key, (KeyValuePair<EMonsterType, ModCardData> kvp) => kvp.Value.Icon);
		}

		public MonsterData GetMonsterData(CardData cardData)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			if (CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				if (value.Cards.TryGetValue(cardData.monsterType, out ModCardData value2))
				{
					return value2.MonsterData;
				}
				return InventoryBase.GetMonsterData(cardData.monsterType);
			}
			return InventoryBase.GetMonsterData(cardData.monsterType);
		}

		public MonsterData GetMonsterData(ECardExpansionType expansionType, EMonsterType monsterType)
		{
			//IL_0006: 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_0016: 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 (CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				if (value.Cards.TryGetValue(monsterType, out ModCardData value2))
				{
					return value2.MonsterData;
				}
				return InventoryBase.GetMonsterData(monsterType);
			}
			return InventoryBase.GetMonsterData(monsterType);
		}

		public bool IsCardFoil(ECardExpansionType expansionType, EMonsterType monsterType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value) || value.HasRandomFoils)
			{
				return false;
			}
			if (value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return value2.IsFoil;
			}
			return false;
		}

		public bool IsCardExpansionUnlocked(ECardExpansionType expansionType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionItemLookup.TryGetValue(expansionType, out List<EItemType> value))
			{
				return false;
			}
			foreach (EItemType item in value)
			{
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(item, out ItemSaveData data) && (data.IsBigBoxUnlocked || data.IsSmallBoxUnlocked))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal class DecoLibrary : IDecoLibrary
	{
		internal int? firstInsertedWallTexture;

		internal int? firstInsertedCeilingTexture;

		internal int? firstInsertedFloorTexture;

		internal Dictionary<EDecoObject, ModDecoData> DecoObjectData { get; set; } = new Dictionary<EDecoObject, ModDecoData>();


		internal List<ModShopDecoData> DecoWallTextureData { get; set; } = new List<ModShopDecoData>();


		internal List<ModShopDecoData> DecoFloorTextureData { get; set; } = new List<ModShopDecoData>();


		internal List<ModShopDecoData> DecoCeilingTextureData { get; set; } = new List<ModShopDecoData>();


		public StreamingAsset<Sprite>? GetIcon(EDecoObject decoObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				return null;
			}
			return value.Icon;
		}

		public IReadOnlyDictionary<EDecoObject, StreamingAsset<Sprite>> GetIcons()
		{
			return DecoObjectData.ToDictionary<KeyValuePair<EDecoObject, ModDecoData>, EDecoObject, StreamingAsset<Sprite>>((KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Key, (KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Value.Icon);
		}

		public InteractableObject? GetPrefab(EDecoObject decoObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				return null;
			}
			return value.BaseDecoData.spawnPrefab;
		}

		public IReadOnlyDictionary<EDecoObject, InteractableObject> GetPrefabs()
		{
			return DecoObjectData.ToDictionary<KeyValuePair<EDecoObject, ModDecoData>, EDecoObject, InteractableObject>((KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Key, (KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Value.BaseDecoData.spawnPrefab);
		}

		public int GetLevelRequirement(EDecoObject decoObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				throw new ArgumentException($"{decoObject} is not a registered decoration object.");
			}
			return value.BasePurchaseData.levelRequirement;
		}
	}
	internal class EplAssets : IEplAssets
	{
		internal CardExpansionLibrary CardExpansionLibrary { get; set; } = new CardExpansionLibrary();


		internal DecoLibrary DecoLibrary { get; set; } = new DecoLibrary();


		internal FurnitureLibrary FurnitureLibrary { get; set; } = new FurnitureLibrary();


		internal ItemLibrary ItemLibrary { get; set; } = new ItemLibrary();


		internal ShopLibrary ShopLibrary { get; set; } = new ShopLibrary();


		internal LookupLibrary LookupLibrary { get; set; } = new LookupLibrary();


		internal BundleRegistry BundleRegistry { get; set; }

		public ICardExpansionLibrary CardExpansions => (ICardExpansionLibrary)(object)CardExpansionLibrary;

		public IFurnitureLibrary Furniture => (IFurnitureLibrary)(object)FurnitureLibrary;

		public IItemLibrary Items => (IItemLibrary)(object)ItemLibrary;

		public IDecoLibrary Deco => (IDecoLibrary)(object)DecoLibrary;

		public IShopLibrary Shops => (IShopLibrary)(object)ShopLibrary;

		public EplAssets(BundleRegistry bundleRegistry)
		{
			BundleRegistry = bundleRegistry;
			base..ctor();
		}
	}
	internal class FurnitureLibrary : IFurnitureLibrary
	{
		internal Dictionary<EObjectType, ModFurniturePurchaseData> FurnitureData { get; set; } = new Dictionary<EObjectType, ModFurniturePurchaseData>();


		public StreamingAsset<Sprite>? GetIcon(EObjectType objectType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				return null;
			}
			return value.Icon;
		}

		public IReadOnlyDictionary<EObjectType, StreamingAsset<Sprite>> GetIcons()
		{
			return FurnitureData.ToDictionary<KeyValuePair<EObjectType, ModFurniturePurchaseData>, EObjectType, StreamingAsset<Sprite>>((KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Key, (KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Value.Icon);
		}

		public InteractableObject? GetPrefab(EObjectType objectType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				return null;
			}
			return value.BaseObjectData.spawnPrefab;
		}

		public IReadOnlyDictionary<EObjectType, InteractableObject> GetPrefabs()
		{
			return FurnitureData.ToDictionary<KeyValuePair<EObjectType, ModFurniturePurchaseData>, EObjectType, InteractableObject>((KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Key, (KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Value.BaseObjectData.spawnPrefab);
		}

		public int GetLevelRequirement(EObjectType objectType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				throw new ArgumentException($"{objectType} is not a registered furniture object.");
			}
			return value.BaseFurniturePurchaseData.levelRequirement;
		}
	}
	internal class ItemLibrary : IItemLibrary
	{
		internal Dictionary<ECardExpansionType, List<(int MinPrice, EItemType ItemType)>> BulkBoxes { get; set; } = new Dictionary<ECardExpansionType, List<(int, EItemType)>>();


		internal Dictionary<EItemType, ModItemData> ItemData { get; set; } = new Dictionary<EItemType, ModItemData>();


		internal Dictionary<EItemType, ItemMeshData> ItemMeshData { get; set; } = new Dictionary<EItemType, ItemMeshData>();


		internal List<ModRestockData> RestockEntries { get; set; } = new List<ModRestockData>();


		internal List<EItemType> SprayCanList { get; set; } = new List<EItemType>();


		internal Dictionary<string, IItemPriceGenerator> ItemPriceGenerators { get; set; } = new Dictionary<string, IItemPriceGenerator>();


		public StreamingAsset<Sprite>? GetIcon(EItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemData.TryGetValue(itemType, out ModItemData value))
			{
				return null;
			}
			return value.Icon;
		}

		public IReadOnlyDictionary<EItemType, StreamingAsset<Sprite>> GetIcons()
		{
			return ItemData.ToDictionary<KeyValuePair<EItemType, ModItemData>, EItemType, StreamingAsset<Sprite>>((KeyValuePair<EItemType, ModItemData> kvp) => kvp.Key, (KeyValuePair<EItemType, ModItemData> kvp) => kvp.Value.Icon);
		}

		public ItemMeshData? GetItemMeshData(EItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemMeshData.TryGetValue(itemType, out ItemMeshData value))
			{
				return null;
			}
			return value;
		}

		public IReadOnlyDictionary<EItemType, ItemMeshData> GetAllItemMeshData()
		{
			return ItemMeshData;
		}

		public EItemType GetBulkBox(ECardExpansionType expansionType, int priceCutoff)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			if (BulkBoxes.TryGetValue(expansionType, out List<(int, EItemType)> value))
			{
				foreach (var (num, result) in value)
				{
					if (priceCutoff > num)
					{
						return result;
					}
				}
			}
			return (EItemType)(-1);
		}

		public IReadOnlyDictionary<ECardExpansionType, List<(int MinPrice, EItemType ItemType)>> GetBulkBoxes()
		{
			return BulkBoxes;
		}

		public PackWeightData GetPackWeights(EItemType pack)
		{
			//IL_000f: 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_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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			Dictionary<PackSlot, IReadOnlyDictionary<ERarity, float>> dictionary = new Dictionary<PackSlot, IReadOnlyDictionary<ERarity, float>>();
			foreach (KeyValuePair<PackSlot, Dictionary<ERarity, float>> packSlotWeight in value.PackSlotWeights)
			{
				packSlotWeight.Deconstruct(out var key, out var value2);
				PackSlot key2 = key;
				Dictionary<ERarity, float> dictionary2 = value2;
				dictionary[key2] = new ReadOnlyDictionary<ERarity, float>(new Dictionary<ERarity, float>(dictionary2));
			}
			return new PackWeightData
			{
				NormalWeights = new ReadOnlyDictionary<ERarity, float>(new Dictionary<ERarity, float>(value.NormalGenerationWeights)),
				GodWeights = new ReadOnlyDictionary<ERarity, float>(new Dictionary<ERarity, float>(value.GodGenerationWeights)),
				SlotWeights = new ReadOnlyDictionary<PackSlot, IReadOnlyDictionary<ERarity, float>>(dictionary)
			};
		}
	}
	internal class LookupLibrary
	{
		internal Dictionary<EItemType, EItemType> SpawnPackLookup { get; set; } = new Dictionary<EItemType, EItemType>();


		internal Dictionary<EItemType, CardGenerationData> GenerationDataLookup { get; set; } = new Dictionary<EItemType, CardGenerationData>();


		internal Dictionary<ECollectionPackType, ECardExpansionType> ExpansionLookup { get; set; } = new Dictionary<ECollectionPackType, ECardExpansionType>();


		internal Dictionary<EItemType, List<RestockData>> RestockDataLookup { get; set; } = new Dictionary<EItemType, List<RestockData>>();


		internal Dictionary<ECardExpansionType, List<EItemType>> ExpansionItemLookup { get; set; } = new Dictionary<ECardExpansionType, List<EItemType>>();

	}
	internal class ShopLibrary : IShopLibrary
	{
		internal Dictionary<string, CustomShopData> CustomShops { get; set; } = new Dictionary<string, CustomShopData>();


		internal Dictionary<EItemType, CustomShopData> ItemShopLookup { get; set; } = new Dictionary<EItemType, CustomShopData>();


		public List<string> GetPhoneAppIds()
		{
			return CustomShops.Keys.ToList();
		}

		public ShopData? GetShopDataFor(string appId)
		{
			//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_0021: 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_003e: 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_0057: Expected O, but got Unknown
			if (CustomShops.TryGetValue(appId, out CustomShopData value))
			{
				return new ShopData
				{
					PhoneAppId = value.PhoneAppId,
					AppDisplayName = value.AppDisplayName,
					TCG = value.TCG.AsReadOnly(),
					Accessories = value.Accessories,
					Figurines = value.Figurines
				};
			}
			return null;
		}

		public ItemShopInfo? GetShopInfoFor(EItemType itemType)
		{
			//IL_0006: 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_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_007d: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			if (!ItemShopLookup.TryGetValue(itemType, out CustomShopData value))
			{
				return null;
			}
			RestockData smallBox = null;
			RestockData bigBox = null;
			if (EplRuntimeData.Assets.LookupLibrary.RestockDataLookup.TryGetValue(itemType, out List<RestockData> value2))
			{
				foreach (RestockData item in value2)
				{
					if (item.isBigBox)
					{
						bigBox = item;
					}
					else
					{
						smallBox = item;
					}
				}
			}
			return new ItemShopInfo
			{
				PhoneAppId = value.PhoneAppId,
				AppDisplayName = value.AppDisplayName,
				SmallBox = smallBox,
				BigBox = bigBox
			};
		}
	}
	internal class StreamingAssetService : IAssetLoadBridge, IAssetRefTracker
	{
		private class LoadedAsset
		{
			public Object Asset { get; set; }

			public float CooldownTime { get; set; }

			public int RefCount { get; set; }

			public bool KeepAlive { get; set; }
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public Action<Object?> callback;

			internal void <LoadAssetAsync>b__0(Object? obj)
			{
				callback?.Invoke(obj);
			}
		}

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

			private object <>2__current;

			public StreamingAssetService <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				StreamingAssetService streamingAssetService = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					List<string> list = new List<string>();
					foreach (var (item, loadedAsset2) in streamingAssetService.loadedAssets)
					{
						if (loadedAsset2.RefCount == 0 && !loadedAsset2.KeepAlive && Time.realtimeSinceStartup - loadedAsset2.CooldownTime > 60f)
						{
							list.Add(item);
							Resources.UnloadAsset(loadedAsset2.Asset);
						}
					}
					foreach (string item2 in list)
					{
						streamingAssetService.loadedAssets.Remove(item2);
					}
				}
				else
				{
					<>1__state = -1;
				}
				<>2__current = (object)new WaitForSeconds(60f);
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Action<Object?> callback;

			public string bundlePath;

			public string assetName;

			public StreamingAssetService <>4__this;

			public Type type;

			public bool keepAlive;

			private <>c__DisplayClass5_0 <>8__1;

			private string <assetKey>5__2;

			private Object <loadedAsset>5__3;

			private BundleManager.BundleHandle <handle>5__4;

			private AssetBundleRequest <assetRequest>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<assetKey>5__2 = null;
				<loadedAsset>5__3 = null;
				<handle>5__4 = null;
				<assetRequest>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					int num = <>1__state;
					StreamingAssetService streamingAssetService = <>4__this;
					switch (num)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
					{
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass5_0();
						<>8__1.callback = callback;
						<assetKey>5__2 = bundlePath + "|" + assetName;
						List<Action<Object>> value2;
						if (streamingAssetService.loadedAssets.TryGetValue(<assetKey>5__2, out LoadedAsset value))
						{
							<>8__1.callback(value.Asset);
							result = false;
						}
						else if (streamingAssetService.pendingCallbacks.TryGetValue(<assetKey>5__2, out value2))
						{
							value2.Add(delegate(Object? obj)
							{
								<>8__1.callback?.Invoke(obj);
							});
							result = false;
						}
						else
						{
							streamingAssetService.pendingCallbacks[<assetKey>5__2] = new List<Action<Object>>();
							<loadedAsset>5__3 = null;
							<>1__state = -3;
							<handle>5__4 = EplRuntimeData.Services.BundleManager.GetOrOpen(bundlePath);
							<>2__current = <handle>5__4.WaitForLoadAsync();
							<>1__state = 1;
							result = true;
						}
						goto end_IL_0000;
					}
					case 1:
						<>1__state = -3;
						if (<handle>5__4.HasError)
						{
							ModLogger.Error("Bundle '" + bundlePath + "' failed to load.", "LoadAssetAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
							result = false;
							break;
						}
						<assetRequest>5__5 = <handle>5__4.LoadAssetAsync(assetName, type);
						if (<assetRequest>5__5 == null)
						{
							ModLogger.Error("LoadAssetAsync returned null for '" + assetName + "' from '" + bundlePath + "'", "LoadAssetAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
							result = false;
							break;
						}
						<>2__current = <assetRequest>5__5;
						<>1__state = 2;
						result = true;
						goto end_IL_0000;
					case 2:
						<>1__state = -3;
						<loadedAsset>5__3 = <assetRequest>5__5.asset;
						if (<loadedAsset>5__3 == null)
						{
							ModLogger.Error("Asset '" + assetName + "' loaded as null from '" + bundlePath + "'.", "LoadAssetAsync", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
							result = false;
							break;
						}
						streamingAssetService.loadedAssets[<assetKey>5__2] = new LoadedAsset
						{
							Asset = <loadedAsset>5__3,
							CooldownTime = Time.realtimeSinceStartup + 30f,
							KeepAlive = keepAlive
						};
						<handle>5__4 = null;
						<assetRequest>5__5 = null;
						<>m__Finally1();
						result = false;
						goto end_IL_0000;
					}
					<>m__Finally1();
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				StreamingAssetService streamingAssetService = <>4__this;
				<>8__1.callback?.Invoke(<loadedAsset>5__3);
				if (!streamingAssetService.pendingCallbacks.TryGetValue(<assetKey>5__2, out List<Action<Object>> value))
				{
					return;
				}
				foreach (Action<Object> item in value)
				{
					item?.Invoke(<loadedAsset>5__3);
				}
				streamingAssetService.pendingCallbacks.Remove(<assetKey>5__2);
			}

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

		private readonly Dictionary<string, LoadedAsset> loadedAssets = new Dictionary<string, LoadedAsset>();

		private readonly Dictionary<string, List<Action<Object?>>> pendingCallbacks = new Dictionary<string, List<Action<Object>>>();

		private Coroutine? cleanupCoroutine;

		public void StartLoadingCoroutine(string bundlePath, string assetName, bool keepAlive, Type type, Action<Object?> callback)
		{
			((MonoBehaviour)Plugin.Instance).StartCoroutine(LoadAssetAsync(bundlePath, assetName, keepAlive, type, callback));
		}

		internal void StartCleanupCoroutine()
		{
			if (cleanupCoroutine == null)
			{
				cleanupCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(CleanUpAsync());
			}
		}

		[IteratorStateMachine(typeof(<LoadAssetAsync>d__5))]
		internal IEnumerator LoadAssetAsync(string bundlePath, string assetName, bool keepAlive, Type type, Action<Object?> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAssetAsync>d__5(0)
			{
				<>4__this = this,
				bundlePath = bundlePath,
				assetName = assetName,
				keepAlive = keepAlive,
				type = type,
				callback = callback
			};
		}

		public void IncrementRef(string assetKey)
		{
			if (loadedAssets.TryGetValue(assetKey, out LoadedAsset value))
			{
				value.RefCount++;
			}
		}

		public void DecrementRef(string assetKey)
		{
			if (loadedAssets.TryGetValue(assetKey, out LoadedAsset value))
			{
				value.RefCount--;
				if (value.RefCount < 0)
				{
					ModLogger.Error("Ref count for '" + assetKey + "' went negative. A StreamingAsset may have been assigned outside of EPL extension methods.", "DecrementRef", "D:\\Projects\\EnhancedPrefabLoader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
					value.RefCount = 0;
				}
				if (value.RefCount == 0)
				{
					value.CooldownTime = Time.realtimeSinceStartup;
				}
			}
		}

		[IteratorStateMachine(typeof(<CleanUpAsync>d__8))]
		internal IEnumerator CleanUpAsync()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CleanUpAsync>d__8(0)
			{
				<>4__this = this
			};
		}
	}
	internal class StreamingAssetTracker : MonoBehaviour
	{
		private readonly ConditionalWeakTable<Image, string> imageTracker = new ConditionalWeakTable<Image, string>();

		private readonly ConditionalWeakTable<Material, Dictionary<string, string>> materialTracker = new ConditionalWeakTable<Material, Dictionary<string, string>>();

		internal void TrackImage(Image image, string assetKey)
		{
			if (imageTracker.TryGetValue(image, out string value))
			{
				EplRuntimeData.Services.StreamingAssetService.DecrementRef(value);
			}
			imageTracker.AddOrUpdate(image, assetKey);
			EplRuntimeData.Services.StreamingAssetService.IncrementRef(assetKey);
		}

		internal void TrackMaterial(Material material, string layer, string assetKey)
		{
			if (materialTracker.TryGetValue(material, out Dictionary<string, string> value) && value.TryGetValue(layer, out var value2))
			{
				EplRuntimeData.Services.StreamingAssetService.DecrementRef(value2);
			}
			materialTracker.GetOrCreateValue(material)[layer] = assetKey;
			EplRuntimeData.Services.StreamingAssetService.IncrementRef(assetKey);
		}

		private void OnDestroy()
		{
			foreach (var (_, assetKey) in (IEnumerable<KeyValuePair<Image, string>>)imageTracker)
			{
				EplRuntimeData.Services.StreamingAssetService.DecrementRef(assetKey);
			}
			foreach (KeyValuePair<Material, Dictionary<string, string>> item in (IEnumerable<KeyValuePair<Material, Dictionary<string, string>>>)materialTracker)
			{
				item.Deconstruct(out var _, out var value);
				foreach (string value2 in value.Values)
				{
					EplRuntimeData.Services.StreamingAssetService.DecrementRef(value2);
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}