using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using Cysharp.Threading.Tasks.CompilerServices;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using Extensions.Unity.ImageLoader;
using HarmonyLib;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Adventures;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Cards;
using LBoL.Core.Dialogs;
using LBoL.Core.GapOptions;
using LBoL.Core.SaveData;
using LBoL.Core.Stations;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Adventures;
using LBoL.EntityLib.Cards.Character.Reimu;
using LBoL.EntityLib.EnemyUnits.Character;
using LBoL.Presentation;
using LBoL.Presentation.Effect;
using LBoL.Presentation.Environments;
using LBoL.Presentation.I10N;
using LBoL.Presentation.UI;
using LBoL.Presentation.UI.ExtraWidgets;
using LBoL.Presentation.UI.Panels;
using LBoL.Presentation.UI.Widgets;
using LBoL.Presentation.Units;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.BattleModifiers.Actions;
using LBoLEntitySideloader.BattleModifiers.Args;
using LBoLEntitySideloader.CustomHandlers;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Entities.DynamicTemplates;
using LBoLEntitySideloader.Entities.MockConfigs;
using LBoLEntitySideloader.Entities.Patches;
using LBoLEntitySideloader.PersistentValues;
using LBoLEntitySideloader.ReflectionHelpers;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.TemplateGen;
using LBoLEntitySideloader.UIhelpers;
using LBoLEntitySideloader.Utils;
using LBoLEntitySideloader.Utils.ArrayExtensions;
using Mono.CSharp;
using MonoMod.Utils;
using ScriptEngine;
using Spine.Unity;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Networking;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Helpers;
using YamlDotNet.RepresentationModel;
using YamlDotNet.Serialization;
using Yarn;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("LBoL.Base")]
[assembly: IgnoresAccessChecksTo("LBoL.ConfigData")]
[assembly: IgnoresAccessChecksTo("LBoL.Core")]
[assembly: IgnoresAccessChecksTo("LBoL.EntityLib")]
[assembly: IgnoresAccessChecksTo("LBoL.Presentation")]
[assembly: IgnoresAccessChecksTo("Untitled.ConfigDataBuilder.Base")]
[assembly: AssemblyCompany("LBoL-Entity-Sideloader")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+fbe97b4a95487af070d4eacf7741bf6ac981110b")]
[assembly: AssemblyProduct("LBoL-Entity-Sideloader")]
[assembly: AssemblyTitle("LBoL-Entity-Sideloader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[HarmonyPatch(typeof(Library), "InternalEnumerateDisplayWords")]
public static class DuplicateTooltipFix
{
	private static bool Prefix(GameRunController gameRun, Keyword keyword, IEnumerable<string> initEffects, bool verbose, Keyword? exceptKeywords, ref IEnumerable<IDisplayWord> __result)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		__result = EnumerateDisplayFix(gameRun, keyword, initEffects, verbose, exceptKeywords);
		return false;
	}

	private static IEnumerable<IDisplayWord> EnumerateDisplayFix(GameRunController gameRun, Keyword keyword, IEnumerable<string> initEffects, bool verbose, Keyword? exceptKeywords)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		int counter = 0;
		HashSet<string> seenTypes = new HashSet<string>();
		Keyword traveledKeywords = (Keyword)0;
		Queue<IDisplayWord> queue = new Queue<IDisplayWord>();
		foreach (Keyword k in Keywords.EnumerateComponents(keyword))
		{
			KeywordDisplayWord dw = Keywords.GetDisplayWord(k);
			if (!dw.IsHidden && (!dw.IsVerbose || verbose))
			{
				queue.Enqueue((IDisplayWord)(object)dw);
			}
		}
		if (initEffects != null)
		{
			foreach (string text in initEffects.Distinct())
			{
				if (seenTypes.Add(text))
				{
					StatusEffect se = TypeFactory<StatusEffect>.CreateInstance(text);
					if (verbose || !se.Config.IsVerbose)
					{
						((GameEntity)se).GameRun = gameRun;
						queue.Enqueue((IDisplayWord)(object)se);
					}
				}
			}
		}
		while (queue.Count > 0)
		{
			int num = counter + 1;
			counter = num;
			if (num > 99)
			{
				throw new OverflowException("Too many references");
			}
			IDisplayWord front = queue.Dequeue();
			KeywordDisplayWord keywordDisplay = (KeywordDisplayWord)(object)((front is KeywordDisplayWord) ? front : null);
			if (keywordDisplay != null)
			{
				if (!exceptKeywords.HasValue || !((Enum)exceptKeywords.Value).HasFlag((Enum)(object)keywordDisplay.Keyword))
				{
					traveledKeywords |= keywordDisplay.Keyword;
					yield return front;
				}
				continue;
			}
			StatusEffect se2 = (StatusEffect)(object)((front is StatusEffect) ? front : null);
			if (se2 == null)
			{
				continue;
			}
			yield return front;
			foreach (Keyword subkeyword in Keywords.EnumerateComponents(se2.Config.Keywords))
			{
				if (!((Enum)traveledKeywords).HasFlag((Enum)(object)subkeyword))
				{
					traveledKeywords |= subkeyword;
					KeywordDisplayWord dw2 = Keywords.GetDisplayWord(subkeyword);
					if (!dw2.IsHidden && (!dw2.IsVerbose || verbose))
					{
						queue.Enqueue((IDisplayWord)(object)dw2);
					}
				}
			}
			foreach (string text2 in se2.Config.RelativeEffects)
			{
				if (seenTypes.Add(text2))
				{
					StatusEffect seChild = TypeFactory<StatusEffect>.CreateInstance(text2);
					if (verbose || !seChild.Config.IsVerbose)
					{
						((GameEntity)seChild).GameRun = gameRun;
						queue.Enqueue((IDisplayWord)(object)seChild);
					}
				}
			}
		}
	}
}
namespace Extensions.Unity.ImageLoader
{
	public static class ImageLoader
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0
		{
			public string url;

			public UnityWebRequest request;

			public bool ignoreImageNotFoundError;

			public bool finished;

			internal bool <LoadSprite>b__0()
			{
				return IsLoading(url);
			}

			internal async void <LoadSprite>b__1()
			{
				try
				{
					request = UnityWebRequestTexture.GetTexture(url);
					UnityWebRequestAsyncOperationAwaiter val = UnityAsyncExtensions.GetAwaiter(request.SendWebRequest());
					if (!((UnityWebRequestAsyncOperationAwaiter)(ref val)).IsCompleted)
					{
						await val;
						UnityWebRequestAsyncOperationAwaiter val2 = default(UnityWebRequestAsyncOperationAwaiter);
						val = val2;
					}
					((UnityWebRequestAsyncOperationAwaiter)(ref val)).GetResult();
				}
				catch (Exception ex)
				{
					Exception e = ex;
					if (!ignoreImageNotFoundError && settings.debugLevel <= DebugLevel.Exception)
					{
						Debug.LogException(e);
					}
				}
				finally
				{
					finished = true;
				}
			}

			internal bool <LoadSprite>b__2()
			{
				return finished;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass11_0
		{
			public string url;

			public Rect? rect;

			public Vector2? pivot;

			public int ppu;

			public SpriteMeshType spriteMeshType;

			public UnityWebRequest request;

			public bool ignoreImageNotFoundError;

			public bool finished;

			internal bool <LoadSpriteMemoryOptimized>b__0()
			{
				return IsLoading(url);
			}

			internal Sprite <LoadSpriteMemoryOptimized>b__1(Texture2D texture)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: 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 (!rect.HasValue)
				{
					rect = new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height);
				}
				if (!pivot.HasValue)
				{
					pivot = new Vector2(0.5f, 0.5f);
				}
				return Sprite.Create(texture, rect.Value, pivot.Value, (float)ppu, 0u, spriteMeshType);
			}

			internal async void <LoadSpriteMemoryOptimized>b__2()
			{
				try
				{
					request = new UnityWebRequest(url);
					request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
					UnityWebRequestAsyncOperationAwaiter val = UnityAsyncExtensions.GetAwaiter(request.SendWebRequest());
					if (!((UnityWebRequestAsyncOperationAwaiter)(ref val)).IsCompleted)
					{
						await val;
						UnityWebRequestAsyncOperationAwaiter val2 = default(UnityWebRequestAsyncOperationAwaiter);
						val = val2;
					}
					((UnityWebRequestAsyncOperationAwaiter)(ref val)).GetResult();
				}
				catch (Exception ex)
				{
					Exception e = ex;
					if (!ignoreImageNotFoundError && settings.debugLevel <= DebugLevel.Exception)
					{
						Debug.LogException(e);
					}
				}
				finally
				{
					finished = true;
				}
			}

			internal bool <LoadSpriteMemoryOptimized>b__3()
			{
				return finished;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass30_0
		{
			public Image image;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass30_1
		{
			public Sprite sprite;

			public <>c__DisplayClass30_0 CS$<>8__locals1;

			internal void <SetSprite>b__0()
			{
				if ((Object)(object)CS$<>8__locals1.image == (Object)null || ((UIBehaviour)CS$<>8__locals1.image).IsDestroyed() || object.Equals(((Component)CS$<>8__locals1.image).gameObject, null))
				{
					return;
				}
				try
				{
					CS$<>8__locals1.image.sprite = sprite;
				}
				catch (Exception ex)
				{
					if (settings.debugLevel <= DebugLevel.Exception)
					{
						Debug.LogException(ex);
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass35_0
		{
			public Image[] images;

			public Sprite sprite;

			internal void <SetSprite>b__0()
			{
				for (int i = 0; i < images.Length; i++)
				{
					try
					{
						if (!((Object)(object)images[i] == (Object)null) && !((UIBehaviour)images[i]).IsDestroyed() && !object.Equals(((Component)images[i]).gameObject, null))
						{
							images[i].sprite = sprite;
						}
					}
					catch (Exception ex)
					{
						if (settings.debugLevel <= DebugLevel.Exception)
						{
							Debug.LogException(ex);
						}
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass37_0
		{
			public SpriteRenderer spriteRenderer;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass37_1
		{
			public Sprite sprite;

			public <>c__DisplayClass37_0 CS$<>8__locals1;

			internal void <SetSprite>b__0()
			{
				if ((Object)(object)CS$<>8__locals1.spriteRenderer == (Object)null || object.Equals(((Component)CS$<>8__locals1.spriteRenderer).gameObject, null))
				{
					return;
				}
				try
				{
					CS$<>8__locals1.spriteRenderer.sprite = sprite;
				}
				catch (Exception ex)
				{
					if (settings.debugLevel <= DebugLevel.Exception)
					{
						Debug.LogException(ex);
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass42_0
		{
			public SpriteRenderer[] spriteRenderers;

			public Sprite sprite;

			internal void <SetSprite>b__0()
			{
				for (int i = 0; i < spriteRenderers.Length; i++)
				{
					try
					{
						if (!((Object)(object)spriteRenderers[i] == (Object)null) && !object.Equals(((Component)spriteRenderers[i]).gameObject, null))
						{
							spriteRenderers[i].sprite = sprite;
						}
					}
					catch (Exception ex)
					{
						if (settings.debugLevel <= DebugLevel.Exception)
						{
							Debug.LogException(ex);
						}
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <LoadSprite>d__10 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public string url;

			public Vector2 pivot;

			public TextureFormat textureFormat;

			public bool ignoreImageNotFoundError;

			private <>c__DisplayClass10_0 <>8__1;

			private Sprite <sprite>5__2;

			private Sprite <>s__3;

			private byte[] <cachedImage>5__4;

			private byte[] <>s__5;

			private Texture2D <texture>5__6;

			private Sprite <sprite>5__7;

			private Exception <e>5__8;

			private string <name>5__9;

			private Texture2D <tex>5__10;

			private Sprite <sprite>5__11;

			private Awaiter <>u__1;

			private Awaiter<Sprite> <>u__2;

			private TaskAwaiter<byte[]> <>u__3;

			private Awaiter <>u__4;

			private TaskAwaiter <>u__5;

			private void MoveNext()
			{
				//IL_050f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0514: Unknown result type (might be due to invalid IL or missing references)
				//IL_0518: Unknown result type (might be due to invalid IL or missing references)
				//IL_051d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_022f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_0552: Unknown result type (might be due to invalid IL or missing references)
				//IL_0557: Unknown result type (might be due to invalid IL or missing references)
				//IL_055f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0532: Unknown result type (might be due to invalid IL or missing references)
				//IL_0534: 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)
				//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_061b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0670: Unknown result type (might be due to invalid IL or missing references)
				//IL_0683: Unknown result type (might be due to invalid IL or missing references)
				//IL_020a: Unknown result type (might be due to invalid IL or missing references)
				//IL_020c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e0: Expected O, but got Unknown
				//IL_0365: Unknown result type (might be due to invalid IL or missing references)
				//IL_036a: Unknown result type (might be due to invalid IL or missing references)
				//IL_036e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0373: Unknown result type (might be due to invalid IL or missing references)
				//IL_0424: Unknown result type (might be due to invalid IL or missing references)
				//IL_042a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0388: Unknown result type (might be due to invalid IL or missing references)
				//IL_038a: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter val3;
					Awaiter<Sprite> val2;
					UniTask val4;
					Awaiter val;
					TaskAwaiter taskAwaiter;
					switch (num)
					{
					default:
						<>8__1 = new <>c__DisplayClass10_0();
						<>8__1.url = url;
						<>8__1.ignoreImageNotFoundError = ignoreImageNotFoundError;
						if (string.IsNullOrEmpty(<>8__1.url))
						{
							if (settings.debugLevel <= DebugLevel.Error)
							{
								Debug.LogError((object)"[ImageLoader] Empty url. Image could not be loaded!");
							}
							result = null;
						}
						else
						{
							if (!MemoryCacheContains(<>8__1.url))
							{
								goto IL_00fc;
							}
							<sprite>5__2 = LoadFromMemoryCache(<>8__1.url);
							if (!((Object)(object)<sprite>5__2 != (Object)null))
							{
								<sprite>5__2 = null;
								goto IL_00fc;
							}
							result = <sprite>5__2;
						}
						goto end_IL_0007;
					case 0:
						val3 = <>u__1;
						<>u__1 = default(Awaiter);
						num = (<>1__state = -1);
						goto IL_01c3;
					case 1:
						val2 = <>u__2;
						<>u__2 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0246;
					case 2:
					case 3:
						try
						{
							Awaiter val5;
							TaskAwaiter<byte[]> taskAwaiter2;
							if (num != 2)
							{
								if (num == 3)
								{
									val5 = <>u__4;
									<>u__4 = default(Awaiter);
									num = (<>1__state = -1);
									goto IL_03c4;
								}
								taskAwaiter2 = LoadDiskAsync(<>8__1.url).GetAwaiter();
								if (!taskAwaiter2.IsCompleted)
								{
									num = (<>1__state = 2);
									<>u__3 = taskAwaiter2;
									<LoadSprite>d__10 <LoadSprite>d__ = this;
									<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<byte[]>, <LoadSprite>d__10>(ref taskAwaiter2, ref <LoadSprite>d__);
									return;
								}
							}
							else
							{
								taskAwaiter2 = <>u__3;
								<>u__3 = default(TaskAwaiter<byte[]>);
								num = (<>1__state = -1);
							}
							<>s__5 = taskAwaiter2.GetResult();
							<cachedImage>5__4 = <>s__5;
							<>s__5 = null;
							if (<cachedImage>5__4 != null && <cachedImage>5__4.Length != 0)
							{
								SwitchToMainThreadAwaitable val6 = UniTask.SwitchToMainThread(default(CancellationToken));
								val5 = ((SwitchToMainThreadAwaitable)(ref val6)).GetAwaiter();
								if (!((Awaiter)(ref val5)).IsCompleted)
								{
									num = (<>1__state = 3);
									<>u__4 = val5;
									<LoadSprite>d__10 <LoadSprite>d__ = this;
									<>t__builder.AwaitUnsafeOnCompleted<Awaiter, <LoadSprite>d__10>(ref val5, ref <LoadSprite>d__);
									return;
								}
								goto IL_03c4;
							}
							goto IL_0488;
							IL_0488:
							<cachedImage>5__4 = null;
							goto end_IL_02a2;
							IL_03c4:
							((Awaiter)(ref val5)).GetResult();
							<texture>5__6 = new Texture2D(2, 2, textureFormat, true);
							if (!ImageConversion.LoadImage(<texture>5__6, <cachedImage>5__4))
							{
								<texture>5__6 = null;
								goto IL_0488;
							}
							<sprite>5__7 = Sprite.Create(<texture>5__6, new Rect(0f, 0f, (float)((Texture)<texture>5__6).width, (float)((Texture)<texture>5__6).height), pivot);
							if ((Object)(object)<sprite>5__7 != (Object)null)
							{
								SaveToMemoryCache(<>8__1.url, <sprite>5__7, replace: true);
							}
							RemoveLoading(<>8__1.url);
							result = <sprite>5__7;
							goto end_IL_0007;
							end_IL_02a2:;
						}
						catch (Exception ex)
						{
							<e>5__8 = ex;
							if (settings.debugLevel <= DebugLevel.Exception)
							{
								Debug.LogException(<e>5__8);
							}
						}
						<>8__1.request = null;
						<>8__1.finished = false;
						UniTask.Post((Action)async delegate
						{
							try
							{
								<>8__1.request = UnityWebRequestTexture.GetTexture(<>8__1.url);
								UnityWebRequestAsyncOperationAwaiter val7 = UnityAsyncExtensions.GetAwaiter(<>8__1.request.SendWebRequest());
								if (!((UnityWebRequestAsyncOperationAwaiter)(ref val7)).IsCompleted)
								{
									await val7;
									UnityWebRequestAsyncOperationAwaiter val8 = default(UnityWebRequestAsyncOperationAwaiter);
									val7 = val8;
								}
								((UnityWebRequestAsyncOperationAwaiter)(ref val7)).GetResult();
							}
							catch (Exception ex2)
							{
								Exception e = ex2;
								if (!<>8__1.ignoreImageNotFoundError && settings.debugLevel <= DebugLevel.Exception)
								{
									Debug.LogException(e);
								}
							}
							finally
							{
								<>8__1.finished = true;
							}
						}, (PlayerLoopTiming)8);
						val4 = UniTask.WaitUntil((Func<bool>)(() => <>8__1.finished), (PlayerLoopTiming)8, default(CancellationToken), false);
						val = ((UniTask)(ref val4)).GetAwaiter();
						if (!((Awaiter)(ref val)).IsCompleted)
						{
							num = (<>1__state = 4);
							<>u__1 = val;
							<LoadSprite>d__10 <LoadSprite>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter, <LoadSprite>d__10>(ref val, ref <LoadSprite>d__);
							return;
						}
						goto IL_056e;
					case 4:
						val = <>u__1;
						<>u__1 = default(Awaiter);
						num = (<>1__state = -1);
						goto IL_056e;
					case 5:
						{
							taskAwaiter = <>u__5;
							<>u__5 = default(TaskAwaiter);
							num = (<>1__state = -1);
							break;
						}
						IL_0246:
						<>s__3 = val2.GetResult();
						result = <>s__3;
						goto end_IL_0007;
						IL_01c3:
						((Awaiter)(ref val3)).GetResult();
						val2 = LoadSprite(<>8__1.url, textureFormat, <>8__1.ignoreImageNotFoundError).GetAwaiter();
						if (!val2.IsCompleted)
						{
							num = (<>1__state = 1);
							<>u__2 = val2;
							<LoadSprite>d__10 <LoadSprite>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadSprite>d__10>(ref val2, ref <LoadSprite>d__);
							return;
						}
						goto IL_0246;
						IL_00fc:
						if (IsLoading(<>8__1.url))
						{
							if (settings.debugLevel <= DebugLevel.Log)
							{
								Debug.Log((object)("[ImageLoader] Waiting while another task is loading the sprite url=" + <>8__1.url));
							}
							val4 = UniTask.WaitWhile((Func<bool>)(() => IsLoading(<>8__1.url)), (PlayerLoopTiming)8, default(CancellationToken), false);
							val3 = ((UniTask)(ref val4)).GetAwaiter();
							if (!((Awaiter)(ref val3)).IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val3;
								<LoadSprite>d__10 <LoadSprite>d__ = this;
								<>t__builder.AwaitUnsafeOnCompleted<Awaiter, <LoadSprite>d__10>(ref val3, ref <LoadSprite>d__);
								return;
							}
							goto IL_01c3;
						}
						AddLoading(<>8__1.url);
						if (settings.debugLevel <= DebugLevel.Log)
						{
							Debug.Log((object)("[ImageLoader] Loading new Sprite into memory url=" + <>8__1.url));
						}
						goto case 2;
						IL_056e:
						((Awaiter)(ref val)).GetResult();
						RemoveLoading(<>8__1.url);
						if (string.IsNullOrEmpty(<>8__1.request.error))
						{
							<name>5__9 = Path.GetFileNameWithoutExtension(<>8__1.url);
							<tex>5__10 = ((DownloadHandlerTexture)<>8__1.request.downloadHandler).texture;
							Debug.Log((object)$"LoadSprite: name={<name>5__9}, size={Utils.ToSize(<tex>5__10.GetRawTextureData().Length)}, mipmap={((Texture)<tex>5__10).mipmapCount}, format={<tex>5__10.format}, graphicsFormat={((Texture)<tex>5__10).graphicsFormat}, size={((Texture)<tex>5__10).width}x{((Texture)<tex>5__10).height}");
							<sprite>5__11 = ToSprite(<tex>5__10);
							taskAwaiter = SaveDiskAsync(<>8__1.url, <>8__1.request.downloadHandler.data).GetAwaiter();
							if (!taskAwaiter.IsCompleted)
							{
								num = (<>1__state = 5);
								<>u__5 = taskAwaiter;
								<LoadSprite>d__10 <LoadSprite>d__ = this;
								<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, <LoadSprite>d__10>(ref taskAwaiter, ref <LoadSprite>d__);
								return;
							}
							break;
						}
						if (settings.debugLevel <= DebugLevel.Error)
						{
							Debug.LogError((object)("[ImageLoader] " + <>8__1.request.error + ": url=" + <>8__1.url));
						}
						result = null;
						goto end_IL_0007;
					}
					taskAwaiter.GetResult();
					SaveToMemoryCache(<>8__1.url, <sprite>5__11, replace: true);
					result = <sprite>5__11;
					end_IL_0007:;
				}
				catch (Exception ex)
				{
					<>1__state = -2;
					<>8__1 = null;
					<>t__builder.SetException(ex);
					return;
				}
				<>1__state = -2;
				<>8__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadSpriteMemoryOptimized>d__11 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public string url;

			public int ppu;

			public GraphicsFormat finalGraphicsFormat;

			public int anisoLevel;

			public FilterMode filterMode;

			public SpriteMeshType spriteMeshType;

			public Vector2? pivot;

			public Rect? rect;

			public TextureFormat textureFormat;

			public bool ignoreImageNotFoundError;

			private <>c__DisplayClass11_0 <>8__1;

			private Func<Texture2D, Sprite> <createSprite>5__2;

			private Sprite <sprite>5__3;

			private Sprite <>s__4;

			private byte[] <cachedImage>5__5;

			private byte[] <>s__6;

			private Texture2D <texture>5__7;

			private Sprite <sprite>5__8;

			private Exception <e>5__9;

			private string <name>5__10;

			private Texture2D <compressedTexture>5__11;

			private Sprite <sprite>5__12;

			private Awaiter <>u__1;

			private Awaiter<Sprite> <>u__2;

			private TaskAwaiter<byte[]> <>u__3;

			private Awaiter <>u__4;

			private TaskAwaiter <>u__5;

			private void MoveNext()
			{
				//IL_0540: Unknown result type (might be due to invalid IL or missing references)
				//IL_0545: Unknown result type (might be due to invalid IL or missing references)
				//IL_0549: Unknown result type (might be due to invalid IL or missing references)
				//IL_054e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0583: Unknown result type (might be due to invalid IL or missing references)
				//IL_0588: Unknown result type (might be due to invalid IL or missing references)
				//IL_0590: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0563: Unknown result type (might be due to invalid IL or missing references)
				//IL_0565: Unknown result type (might be due to invalid IL or missing references)
				//IL_021b: Unknown result type (might be due to invalid IL or missing references)
				//IL_022b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0230: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				//IL_0653: Unknown result type (might be due to invalid IL or missing references)
				//IL_065f: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0250: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_06db: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0403: Unknown result type (might be due to invalid IL or missing references)
				//IL_0408: Unknown result type (might be due to invalid IL or missing references)
				//IL_0410: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_042b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0431: Unknown result type (might be due to invalid IL or missing references)
				//IL_043b: Expected O, but got Unknown
				//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter val3;
					Awaiter<Sprite> val2;
					UniTask val4;
					Awaiter val;
					TaskAwaiter taskAwaiter;
					switch (num)
					{
					default:
						<>8__1 = new <>c__DisplayClass11_0();
						<>8__1.url = url;
						<>8__1.rect = rect;
						<>8__1.pivot = pivot;
						<>8__1.ppu = ppu;
						<>8__1.spriteMeshType = spriteMeshType;
						<>8__1.ignoreImageNotFoundError = ignoreImageNotFoundError;
						if (string.IsNullOrEmpty(<>8__1.url))
						{
							if (settings.debugLevel <= DebugLevel.Error)
							{
								Debug.LogError((object)"[ImageLoader] Empty url. Image could not be loaded!");
							}
							result = null;
						}
						else
						{
							if (!MemoryCacheContains(<>8__1.url))
							{
								goto IL_0140;
							}
							<sprite>5__3 = LoadFromMemoryCache(<>8__1.url);
							if (!((Object)(object)<sprite>5__3 != (Object)null))
							{
								<sprite>5__3 = null;
								goto IL_0140;
							}
							result = <sprite>5__3;
						}
						goto end_IL_0007;
					case 0:
						val3 = <>u__1;
						<>u__1 = default(Awaiter);
						num = (<>1__state = -1);
						goto IL_0207;
					case 1:
						val2 = <>u__2;
						<>u__2 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_028a;
					case 2:
					case 3:
						try
						{
							Awaiter val5;
							TaskAwaiter<byte[]> taskAwaiter2;
							if (num != 2)
							{
								if (num == 3)
								{
									val5 = <>u__4;
									<>u__4 = default(Awaiter);
									num = (<>1__state = -1);
									goto IL_041f;
								}
								taskAwaiter2 = LoadDiskAsync(<>8__1.url).GetAwaiter();
								if (!taskAwaiter2.IsCompleted)
								{
									num = (<>1__state = 2);
									<>u__3 = taskAwaiter2;
									<LoadSpriteMemoryOptimized>d__11 <LoadSpriteMemoryOptimized>d__ = this;
									<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<byte[]>, <LoadSpriteMemoryOptimized>d__11>(ref taskAwaiter2, ref <LoadSpriteMemoryOptimized>d__);
									return;
								}
							}
							else
							{
								taskAwaiter2 = <>u__3;
								<>u__3 = default(TaskAwaiter<byte[]>);
								num = (<>1__state = -1);
							}
							<>s__6 = taskAwaiter2.GetResult();
							<cachedImage>5__5 = <>s__6;
							<>s__6 = null;
							if (<cachedImage>5__5 != null && <cachedImage>5__5.Length != 0)
							{
								SwitchToMainThreadAwaitable val6 = UniTask.SwitchToMainThread(default(CancellationToken));
								val5 = ((SwitchToMainThreadAwaitable)(ref val6)).GetAwaiter();
								if (!((Awaiter)(ref val5)).IsCompleted)
								{
									num = (<>1__state = 3);
									<>u__4 = val5;
									<LoadSpriteMemoryOptimized>d__11 <LoadSpriteMemoryOptimized>d__ = this;
									<>t__builder.AwaitUnsafeOnCompleted<Awaiter, <LoadSpriteMemoryOptimized>d__11>(ref val5, ref <LoadSpriteMemoryOptimized>d__);
									return;
								}
								goto IL_041f;
							}
							goto IL_04b9;
							IL_04b9:
							<cachedImage>5__5 = null;
							goto end_IL_02fd;
							IL_041f:
							((Awaiter)(ref val5)).GetResult();
							<texture>5__7 = new Texture2D(2, 2, textureFormat, true);
							if (!ImageConversion.LoadImage(<texture>5__7, <cachedImage>5__5))
							{
								<texture>5__7 = null;
								goto IL_04b9;
							}
							<sprite>5__8 = <createSprite>5__2(<texture>5__7);
							if ((Object)(object)<sprite>5__8 != (Object)null)
							{
								SaveToMemoryCache(<>8__1.url, <sprite>5__8, replace: true);
							}
							RemoveLoading(<>8__1.url);
							result = <sprite>5__8;
							goto end_IL_0007;
							end_IL_02fd:;
						}
						catch (Exception ex)
						{
							<e>5__9 = ex;
							if (settings.debugLevel <= DebugLevel.Exception)
							{
								Debug.LogException(<e>5__9);
							}
						}
						<>8__1.request = null;
						<>8__1.finished = false;
						UniTask.Post((Action)async delegate
						{
							try
							{
								<>8__1.request = new UnityWebRequest(<>8__1.url);
								<>8__1.request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
								UnityWebRequestAsyncOperationAwaiter val7 = UnityAsyncExtensions.GetAwaiter(<>8__1.request.SendWebRequest());
								if (!((UnityWebRequestAsyncOperationAwaiter)(ref val7)).IsCompleted)
								{
									await val7;
									UnityWebRequestAsyncOperationAwaiter val8 = default(UnityWebRequestAsyncOperationAwaiter);
									val7 = val8;
								}
								((UnityWebRequestAsyncOperationAwaiter)(ref val7)).GetResult();
							}
							catch (Exception ex2)
							{
								Exception e = ex2;
								if (!<>8__1.ignoreImageNotFoundError && settings.debugLevel <= DebugLevel.Exception)
								{
									Debug.LogException(e);
								}
							}
							finally
							{
								<>8__1.finished = true;
							}
						}, (PlayerLoopTiming)8);
						val4 = UniTask.WaitUntil((Func<bool>)(() => <>8__1.finished), (PlayerLoopTiming)8, default(CancellationToken), false);
						val = ((UniTask)(ref val4)).GetAwaiter();
						if (!((Awaiter)(ref val)).IsCompleted)
						{
							num = (<>1__state = 4);
							<>u__1 = val;
							<LoadSpriteMemoryOptimized>d__11 <LoadSpriteMemoryOptimized>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter, <LoadSpriteMemoryOptimized>d__11>(ref val, ref <LoadSpriteMemoryOptimized>d__);
							return;
						}
						goto IL_059f;
					case 4:
						val = <>u__1;
						<>u__1 = default(Awaiter);
						num = (<>1__state = -1);
						goto IL_059f;
					case 5:
						{
							taskAwaiter = <>u__5;
							<>u__5 = default(TaskAwaiter);
							num = (<>1__state = -1);
							break;
						}
						IL_028a:
						<>s__4 = val2.GetResult();
						result = <>s__4;
						goto end_IL_0007;
						IL_0207:
						((Awaiter)(ref val3)).GetResult();
						val2 = LoadSprite(<>8__1.url, textureFormat, <>8__1.ignoreImageNotFoundError).GetAwaiter();
						if (!val2.IsCompleted)
						{
							num = (<>1__state = 1);
							<>u__2 = val2;
							<LoadSpriteMemoryOptimized>d__11 <LoadSpriteMemoryOptimized>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadSpriteMemoryOptimized>d__11>(ref val2, ref <LoadSpriteMemoryOptimized>d__);
							return;
						}
						goto IL_028a;
						IL_0140:
						if (IsLoading(<>8__1.url))
						{
							if (settings.debugLevel <= DebugLevel.Log)
							{
								Debug.Log((object)("[ImageLoader] Waiting while another task is loading the sprite url=" + <>8__1.url));
							}
							val4 = UniTask.WaitWhile((Func<bool>)(() => IsLoading(<>8__1.url)), (PlayerLoopTiming)8, default(CancellationToken), false);
							val3 = ((UniTask)(ref val4)).GetAwaiter();
							if (!((Awaiter)(ref val3)).IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val3;
								<LoadSpriteMemoryOptimized>d__11 <LoadSpriteMemoryOptimized>d__ = this;
								<>t__builder.AwaitUnsafeOnCompleted<Awaiter, <LoadSpriteMemoryOptimized>d__11>(ref val3, ref <LoadSpriteMemoryOptimized>d__);
								return;
							}
							goto IL_0207;
						}
						AddLoading(<>8__1.url);
						<createSprite>5__2 = delegate(Texture2D texture)
						{
							//IL_002c: Unknown result type (might be due to invalid IL or missing references)
							//IL_006e: Unknown result type (might be due to invalid IL or missing references)
							//IL_0079: Unknown result type (might be due to invalid IL or missing references)
							//IL_0087: 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 (!<>8__1.rect.HasValue)
							{
								<>8__1.rect = new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height);
							}
							if (!<>8__1.pivot.HasValue)
							{
								<>8__1.pivot = new Vector2(0.5f, 0.5f);
							}
							return Sprite.Create(texture, <>8__1.rect.Value, <>8__1.pivot.Value, (float)<>8__1.ppu, 0u, <>8__1.spriteMeshType);
						};
						if (settings.debugLevel <= DebugLevel.Log)
						{
							Debug.Log((object)("[ImageLoader] Loading new Sprite into memory url=" + <>8__1.url));
						}
						goto case 2;
						IL_059f:
						((Awaiter)(ref val)).GetResult();
						RemoveLoading(<>8__1.url);
						if (string.IsNullOrEmpty(<>8__1.request.error))
						{
							<name>5__10 = Path.GetFileNameWithoutExtension(<>8__1.url);
							<compressedTexture>5__11 = Utils.CreateTexWithMipmaps(<>8__1.request.downloadHandler.data, shouldGenerateMipMaps: true, finalGraphicsFormat, anisoLevel, filterMode, <name>5__10);
							ManualLogSource obj = Log.LogDevExtra();
							if (obj != null)
							{
								obj.LogInfo((object)$"LoadSpriteMemoryOptimized: name={<name>5__10}, size={Utils.ToSize(<compressedTexture>5__11.GetRawTextureData().Length)}, mipmap={((Texture)<compressedTexture>5__11).mipmapCount}, format={<compressedTexture>5__11.format}, graphicsFormat={((Texture)<compressedTexture>5__11).graphicsFormat}, size={((Texture)<compressedTexture>5__11).width}x{((Texture)<compressedTexture>5__11).height}");
							}
							<sprite>5__12 = <createSprite>5__2(<compressedTexture>5__11);
							taskAwaiter = SaveDiskAsync(<>8__1.url, <>8__1.request.downloadHandler.data).GetAwaiter();
							if (!taskAwaiter.IsCompleted)
							{
								num = (<>1__state = 5);
								<>u__5 = taskAwaiter;
								<LoadSpriteMemoryOptimized>d__11 <LoadSpriteMemoryOptimized>d__ = this;
								<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, <LoadSpriteMemoryOptimized>d__11>(ref taskAwaiter, ref <LoadSpriteMemoryOptimized>d__);
								return;
							}
							break;
						}
						if (settings.debugLevel <= DebugLevel.Error)
						{
							Debug.LogError((object)("[ImageLoader] " + <>8__1.request.error + ": url=" + <>8__1.url));
						}
						result = null;
						goto end_IL_0007;
					}
					taskAwaiter.GetResult();
					SaveToMemoryCache(<>8__1.url, <sprite>5__12, replace: true);
					result = <sprite>5__12;
					end_IL_0007:;
				}
				catch (Exception ex)
				{
					<>1__state = -2;
					<>8__1 = null;
					<createSprite>5__2 = null;
					<>t__builder.SetException(ex);
					return;
				}
				<>1__state = -2;
				<>8__1 = null;
				<createSprite>5__2 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <SetSprite>d__30 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			public string url;

			public Image image;

			public Vector2 pivot;

			public TextureFormat textureFormat;

			public bool ignoreImageNotFoundError;

			private <>c__DisplayClass30_0 <>8__1;

			private <>c__DisplayClass30_1 <>8__2;

			private Sprite <>s__3;

			private Exception <e>5__4;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0101: 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_010d: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				int num = <>1__state;
				try
				{
					if (num != 0)
					{
						<>8__1 = new <>c__DisplayClass30_0();
						<>8__1.image = image;
					}
					try
					{
						Awaiter<Sprite> val;
						if (num == 0)
						{
							val = <>u__1;
							<>u__1 = default(Awaiter<Sprite>);
							num = (<>1__state = -1);
							goto IL_011c;
						}
						<>8__2 = new <>c__DisplayClass30_1();
						<>8__2.CS$<>8__locals1 = <>8__1;
						if (!((Object)(object)<>8__2.CS$<>8__locals1.image == (Object)null) && !((UIBehaviour)<>8__2.CS$<>8__locals1.image).IsDestroyed() && !((Object)(object)((Component)<>8__2.CS$<>8__locals1.image).gameObject == (Object)null))
						{
							val = LoadSprite(url, pivot, textureFormat, ignoreImageNotFoundError).GetAwaiter();
							if (!val.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val;
								<SetSprite>d__30 <SetSprite>d__ = this;
								((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter<Sprite>, <SetSprite>d__30>(ref val, ref <SetSprite>d__);
								return;
							}
							goto IL_011c;
						}
						goto end_IL_002c;
						IL_011c:
						<>s__3 = val.GetResult();
						<>8__2.sprite = <>s__3;
						<>s__3 = null;
						UniTask.Post((Action)delegate
						{
							if ((Object)(object)<>8__2.CS$<>8__locals1.image == (Object)null || ((UIBehaviour)<>8__2.CS$<>8__locals1.image).IsDestroyed() || object.Equals(((Component)<>8__2.CS$<>8__locals1.image).gameObject, null))
							{
								return;
							}
							try
							{
								<>8__2.CS$<>8__locals1.image.sprite = <>8__2.sprite;
							}
							catch (Exception ex2)
							{
								if (settings.debugLevel <= DebugLevel.Exception)
								{
									Debug.LogException(ex2);
								}
							}
						}, (PlayerLoopTiming)8);
						<>8__2 = null;
						end_IL_002c:;
					}
					catch (Exception ex)
					{
						<e>5__4 = ex;
						if (settings.debugLevel <= DebugLevel.Exception)
						{
							Debug.LogException(<e>5__4);
						}
					}
				}
				catch (Exception ex)
				{
					<>1__state = -2;
					<>8__1 = null;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(ex);
					return;
				}
				<>1__state = -2;
				<>8__1 = null;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <SetSprite>d__35 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			public string url;

			public Vector2 pivot;

			public TextureFormat textureFormat;

			public bool ignoreImageNotFoundError;

			public Image[] images;

			private <>c__DisplayClass35_0 <>8__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_007e: 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)
				int num = <>1__state;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_00b8;
					}
					<>8__1 = new <>c__DisplayClass35_0();
					<>8__1.images = images;
					if (<>8__1.images != null)
					{
						val = LoadSprite(url, pivot, textureFormat, ignoreImageNotFoundError).GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<SetSprite>d__35 <SetSprite>d__ = this;
							((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter<Sprite>, <SetSprite>d__35>(ref val, ref <SetSprite>d__);
							return;
						}
						goto IL_00b8;
					}
					goto end_IL_0007;
					IL_00b8:
					<>s__2 = val.GetResult();
					<>8__1.sprite = <>s__2;
					<>s__2 = null;
					UniTask.Post((Action)delegate
					{
						for (int i = 0; i < <>8__1.images.Length; i++)
						{
							try
							{
								if (!((Object)(object)<>8__1.images[i] == (Object)null) && !((UIBehaviour)<>8__1.images[i]).IsDestroyed() && !object.Equals(((Component)<>8__1.images[i]).gameObject, null))
								{
									<>8__1.images[i].sprite = <>8__1.sprite;
								}
							}
							catch (Exception ex)
							{
								if (settings.debugLevel <= DebugLevel.Exception)
								{
									Debug.LogException(ex);
								}
							}
						}
					}, (PlayerLoopTiming)8);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<>8__1 = null;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				<>8__1 = null;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <SetSprite>d__37 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			public string url;

			public SpriteRenderer spriteRenderer;

			public Vector2 pivot;

			public TextureFormat textureFormat;

			public bool ignoreImageNotFoundError;

			private <>c__DisplayClass37_0 <>8__1;

			private <>c__DisplayClass37_1 <>8__2;

			private Sprite <>s__3;

			private Exception <e>5__4;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: 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_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: 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)
				//IL_00cb: 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)
				int num = <>1__state;
				try
				{
					if (num != 0)
					{
						<>8__1 = new <>c__DisplayClass37_0();
						<>8__1.spriteRenderer = spriteRenderer;
					}
					try
					{
						Awaiter<Sprite> val;
						if (num == 0)
						{
							val = <>u__1;
							<>u__1 = default(Awaiter<Sprite>);
							num = (<>1__state = -1);
							goto IL_0105;
						}
						<>8__2 = new <>c__DisplayClass37_1();
						<>8__2.CS$<>8__locals1 = <>8__1;
						if (!((Object)(object)<>8__2.CS$<>8__locals1.spriteRenderer == (Object)null) && !((Object)(object)((Component)<>8__2.CS$<>8__locals1.spriteRenderer).gameObject == (Object)null))
						{
							val = LoadSprite(url, pivot, textureFormat, ignoreImageNotFoundError).GetAwaiter();
							if (!val.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val;
								<SetSprite>d__37 <SetSprite>d__ = this;
								((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter<Sprite>, <SetSprite>d__37>(ref val, ref <SetSprite>d__);
								return;
							}
							goto IL_0105;
						}
						goto end_IL_002c;
						IL_0105:
						<>s__3 = val.GetResult();
						<>8__2.sprite = <>s__3;
						<>s__3 = null;
						UniTask.Post((Action)delegate
						{
							if ((Object)(object)<>8__2.CS$<>8__locals1.spriteRenderer == (Object)null || object.Equals(((Component)<>8__2.CS$<>8__locals1.spriteRenderer).gameObject, null))
							{
								return;
							}
							try
							{
								<>8__2.CS$<>8__locals1.spriteRenderer.sprite = <>8__2.sprite;
							}
							catch (Exception ex2)
							{
								if (settings.debugLevel <= DebugLevel.Exception)
								{
									Debug.LogException(ex2);
								}
							}
						}, (PlayerLoopTiming)8);
						<>8__2 = null;
						end_IL_002c:;
					}
					catch (Exception ex)
					{
						<e>5__4 = ex;
						if (settings.debugLevel <= DebugLevel.Exception)
						{
							Debug.LogException(<e>5__4);
						}
					}
				}
				catch (Exception ex)
				{
					<>1__state = -2;
					<>8__1 = null;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(ex);
					return;
				}
				<>1__state = -2;
				<>8__1 = null;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <SetSprite>d__42 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder <>t__builder;

			public string url;

			public Vector2 pivot;

			public TextureFormat textureFormat;

			public bool ignoreImageNotFoundError;

			public SpriteRenderer[] spriteRenderers;

			private <>c__DisplayClass42_0 <>8__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_007e: 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)
				int num = <>1__state;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_00b8;
					}
					<>8__1 = new <>c__DisplayClass42_0();
					<>8__1.spriteRenderers = spriteRenderers;
					if (<>8__1.spriteRenderers != null)
					{
						val = LoadSprite(url, pivot, textureFormat, ignoreImageNotFoundError).GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<SetSprite>d__42 <SetSprite>d__ = this;
							((AsyncUniTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<Awaiter<Sprite>, <SetSprite>d__42>(ref val, ref <SetSprite>d__);
							return;
						}
						goto IL_00b8;
					}
					goto end_IL_0007;
					IL_00b8:
					<>s__2 = val.GetResult();
					<>8__1.sprite = <>s__2;
					<>s__2 = null;
					UniTask.Post((Action)delegate
					{
						for (int i = 0; i < <>8__1.spriteRenderers.Length; i++)
						{
							try
							{
								if (!((Object)(object)<>8__1.spriteRenderers[i] == (Object)null) && !object.Equals(((Component)<>8__1.spriteRenderers[i]).gameObject, null))
								{
									<>8__1.spriteRenderers[i].sprite = <>8__1.sprite;
								}
							}
							catch (Exception ex)
							{
								if (settings.debugLevel <= DebugLevel.Exception)
								{
									Debug.LogException(ex);
								}
							}
						}
					}, (PlayerLoopTiming)8);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<>8__1 = null;
					((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				<>8__1 = null;
				((AsyncUniTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		private static HashSet<string> loadingInProcess = new HashSet<string>();

		internal static readonly TaskFactory diskTaskFactory = new TaskFactory(new LimitedConcurrencyLevelTaskScheduler(1));

		internal static Dictionary<string, Sprite> memorySpriteCache = new Dictionary<string, Sprite>();

		public static readonly Settings settings = new Settings();

		private static void AddLoading(string url)
		{
			loadingInProcess.Add(url);
		}

		private static void RemoveLoading(string url)
		{
			loadingInProcess.Remove(url);
		}

		public static void Init()
		{
			string text = settings.diskSaveLocation + settings.diskSaveLocation;
		}

		public static bool IsLoading(string url)
		{
			return loadingInProcess.Contains(url);
		}

		public static Task ClearCache()
		{
			ClearMemoryCache();
			return ClearDiskCache();
		}

		public static bool CacheContains(string url)
		{
			return MemoryCacheContains(url) || DiskCacheContains(url);
		}

		public static Sprite ToSprite(Texture2D texture, float pixelDensity = 100f)
		{
			//IL_0019: 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)
			return Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0.5f, 0.5f), pixelDensity);
		}

		public static Sprite ToSprite(Texture2D texture, Vector2 pivot, float pixelDensity = 100f)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), pivot, pixelDensity);
		}

		internal static UniTask<Sprite> LoadSprite(string url, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false)
		{
			//IL_0001: 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_0010: 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)
			return LoadSprite(url, Vector2.one * 0.5f, textureFormat, ignoreImageNotFoundError);
		}

		[AsyncStateMachine(typeof(<LoadSprite>d__10))]
		[DebuggerStepThrough]
		internal static UniTask<Sprite> LoadSprite(string url, Vector2 pivot, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_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_0047: Unknown result type (might be due to invalid IL or missing references)
			<LoadSprite>d__10 <LoadSprite>d__ = new <LoadSprite>d__10();
			<LoadSprite>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadSprite>d__.url = url;
			<LoadSprite>d__.pivot = pivot;
			<LoadSprite>d__.textureFormat = textureFormat;
			<LoadSprite>d__.ignoreImageNotFoundError = ignoreImageNotFoundError;
			<LoadSprite>d__.<>1__state = -1;
			<LoadSprite>d__.<>t__builder.Start<<LoadSprite>d__10>(ref <LoadSprite>d__);
			return <LoadSprite>d__.<>t__builder.Task;
		}

		[AsyncStateMachine(typeof(<LoadSpriteMemoryOptimized>d__11))]
		[DebuggerStepThrough]
		internal static UniTask<Sprite> LoadSpriteMemoryOptimized(string url, int ppu = 100, GraphicsFormat finalGraphicsFormat = (GraphicsFormat)4, int anisoLevel = 1, FilterMode filterMode = (FilterMode)1, SpriteMeshType spriteMeshType = (SpriteMeshType)1, Vector2? pivot = null, Rect? rect = null, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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)
			<LoadSpriteMemoryOptimized>d__11 <LoadSpriteMemoryOptimized>d__ = new <LoadSpriteMemoryOptimized>d__11();
			<LoadSpriteMemoryOptimized>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadSpriteMemoryOptimized>d__.url = url;
			<LoadSpriteMemoryOptimized>d__.ppu = ppu;
			<LoadSpriteMemoryOptimized>d__.finalGraphicsFormat = finalGraphicsFormat;
			<LoadSpriteMemoryOptimized>d__.anisoLevel = anisoLevel;
			<LoadSpriteMemoryOptimized>d__.filterMode = filterMode;
			<LoadSpriteMemoryOptimized>d__.spriteMeshType = spriteMeshType;
			<LoadSpriteMemoryOptimized>d__.pivot = pivot;
			<LoadSpriteMemoryOptimized>d__.rect = rect;
			<LoadSpriteMemoryOptimized>d__.textureFormat = textureFormat;
			<LoadSpriteMemoryOptimized>d__.ignoreImageNotFoundError = ignoreImageNotFoundError;
			<LoadSpriteMemoryOptimized>d__.<>1__state = -1;
			<LoadSpriteMemoryOptimized>d__.<>t__builder.Start<<LoadSpriteMemoryOptimized>d__11>(ref <LoadSpriteMemoryOptimized>d__);
			return <LoadSpriteMemoryOptimized>d__.<>t__builder.Task;
		}

		private static string DiskCachePath(string url)
		{
			return $"{settings.diskSaveLocation}/I_{url.GetHashCode()}";
		}

		private static void SaveDisk(string url, byte[] data)
		{
			if (settings.useDiskCache)
			{
				Directory.CreateDirectory(settings.diskSaveLocation);
				Directory.CreateDirectory(Path.GetDirectoryName(DiskCachePath(url)));
				File.WriteAllBytes(DiskCachePath(url), data);
			}
		}

		private static byte[] LoadDisk(string url)
		{
			if (!settings.useDiskCache)
			{
				return null;
			}
			Directory.CreateDirectory(settings.diskSaveLocation);
			Directory.CreateDirectory(Path.GetDirectoryName(DiskCachePath(url)));
			if (!DiskCacheContains(url))
			{
				return null;
			}
			return File.ReadAllBytes(DiskCachePath(url));
		}

		private static Task SaveDiskAsync(string url, byte[] data)
		{
			if (!settings.useDiskCache)
			{
				return Task.CompletedTask;
			}
			return diskTaskFactory.StartNew(delegate
			{
				SaveDisk(url, data);
			});
		}

		private static Task<byte[]> LoadDiskAsync(string url)
		{
			if (!settings.useDiskCache)
			{
				return Task.FromResult<byte[]>(null);
			}
			return diskTaskFactory.StartNew(() => LoadDisk(url));
		}

		public static bool DiskCacheContains(string url)
		{
			return File.Exists(DiskCachePath(url));
		}

		public static Task<bool> DiskCacheExistsAsync(string url)
		{
			string path = DiskCachePath(url);
			return diskTaskFactory.StartNew(() => File.Exists(path));
		}

		public static Task ClearDiskCache()
		{
			return diskTaskFactory.StartNew(delegate
			{
				if (Directory.Exists(settings.diskSaveLocation))
				{
					Directory.Delete(settings.diskSaveLocation, recursive: true);
				}
			});
		}

		public static Task ClearDiskCache(string url)
		{
			string diskPath = DiskCachePath(url);
			return diskTaskFactory.StartNew(delegate
			{
				if (File.Exists(diskPath))
				{
					File.Delete(diskPath);
				}
			});
		}

		public static bool MemoryCacheContains(string url)
		{
			return memorySpriteCache.ContainsKey(url);
		}

		public static void SaveToMemoryCache(string url, Sprite sprite, bool replace = false)
		{
			if (!settings.useMemoryCache)
			{
				return;
			}
			if (!replace && memorySpriteCache.ContainsKey(url))
			{
				if (settings.debugLevel <= DebugLevel.Warning)
				{
					Debug.LogError((object)("[ImageLoader] Memory cache already contains key: " + url));
				}
			}
			else
			{
				memorySpriteCache[url] = sprite;
			}
		}

		public static Sprite LoadFromMemoryCache(string url)
		{
			if (!settings.useMemoryCache)
			{
				return null;
			}
			return GetValueOrDefault(url);
		}

		public static void ClearMemoryCache(string url)
		{
			Sprite valueOrDefault = GetValueOrDefault(url);
			if ((Object)(object)((valueOrDefault != null) ? valueOrDefault.texture : null) != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)valueOrDefault.texture);
			}
			memorySpriteCache.Remove(url);
		}

		public static void ClearMemoryCache()
		{
			foreach (Sprite value in memorySpriteCache.Values)
			{
				if ((Object)(object)((value != null) ? value.texture : null) != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)value.texture);
				}
			}
			memorySpriteCache.Clear();
		}

		private static Sprite GetValueOrDefault(string url)
		{
			if (memorySpriteCache.TryGetValue(url, out var value))
			{
				return value;
			}
			return null;
		}

		public static UniTask SetSprite(string url, Image image, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false)
		{
			//IL_0002: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, image, Vector2.one * 0.5f, textureFormat, ignoreImageNotFoundError);
		}

		[AsyncStateMachine(typeof(<SetSprite>d__30))]
		[DebuggerStepThrough]
		public static UniTask SetSprite(string url, Image image, Vector2 pivot, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			<SetSprite>d__30 <SetSprite>d__ = new <SetSprite>d__30();
			<SetSprite>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<SetSprite>d__.url = url;
			<SetSprite>d__.image = image;
			<SetSprite>d__.pivot = pivot;
			<SetSprite>d__.textureFormat = textureFormat;
			<SetSprite>d__.ignoreImageNotFoundError = ignoreImageNotFoundError;
			<SetSprite>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Start<<SetSprite>d__30>(ref <SetSprite>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Task;
		}

		public static UniTask SetSprite(string url, params Image[] images)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, (TextureFormat)5, ignoreImageNotFoundError: false, images);
		}

		public static UniTask SetSprite(string url, TextureFormat textureFormat, params Image[] images)
		{
			//IL_0001: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, textureFormat, ignoreImageNotFoundError: false, images);
		}

		public static UniTask SetSprite(string url, bool ignoreImageNotFoundError, params Image[] images)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, (TextureFormat)5, ignoreImageNotFoundError, images);
		}

		public static UniTask SetSprite(string url, TextureFormat textureFormat, bool ignoreImageNotFoundError, params Image[] images)
		{
			//IL_0001: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, textureFormat, ignoreImageNotFoundError, images);
		}

		[AsyncStateMachine(typeof(<SetSprite>d__35))]
		[DebuggerStepThrough]
		public static UniTask SetSprite(string url, Vector2 pivot, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false, params Image[] images)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_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_004f: Unknown result type (might be due to invalid IL or missing references)
			<SetSprite>d__35 <SetSprite>d__ = new <SetSprite>d__35();
			<SetSprite>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<SetSprite>d__.url = url;
			<SetSprite>d__.pivot = pivot;
			<SetSprite>d__.textureFormat = textureFormat;
			<SetSprite>d__.ignoreImageNotFoundError = ignoreImageNotFoundError;
			<SetSprite>d__.images = images;
			<SetSprite>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Start<<SetSprite>d__35>(ref <SetSprite>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Task;
		}

		public static UniTask SetSprite(string url, SpriteRenderer spriteRenderer, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false)
		{
			//IL_0002: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, spriteRenderer, Vector2.one * 0.5f, textureFormat, ignoreImageNotFoundError);
		}

		[AsyncStateMachine(typeof(<SetSprite>d__37))]
		[DebuggerStepThrough]
		public static UniTask SetSprite(string url, SpriteRenderer spriteRenderer, Vector2 pivot, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			<SetSprite>d__37 <SetSprite>d__ = new <SetSprite>d__37();
			<SetSprite>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<SetSprite>d__.url = url;
			<SetSprite>d__.spriteRenderer = spriteRenderer;
			<SetSprite>d__.pivot = pivot;
			<SetSprite>d__.textureFormat = textureFormat;
			<SetSprite>d__.ignoreImageNotFoundError = ignoreImageNotFoundError;
			<SetSprite>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Start<<SetSprite>d__37>(ref <SetSprite>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Task;
		}

		public static UniTask SetSprite(string url, params SpriteRenderer[] spriteRenderers)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, (TextureFormat)5, ignoreImageNotFoundError: false, spriteRenderers);
		}

		public static UniTask SetSprite(string url, TextureFormat textureFormat, params SpriteRenderer[] spriteRenderers)
		{
			//IL_0001: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, textureFormat, ignoreImageNotFoundError: false, spriteRenderers);
		}

		public static UniTask SetSprite(string url, bool ignoreImageNotFoundError, params SpriteRenderer[] spriteRenderers)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, (TextureFormat)5, ignoreImageNotFoundError, spriteRenderers);
		}

		public static UniTask SetSprite(string url, TextureFormat textureFormat, bool ignoreImageNotFoundError, params SpriteRenderer[] spriteRenderers)
		{
			//IL_0001: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return SetSprite(url, Vector2.one * 0.5f, textureFormat, ignoreImageNotFoundError, spriteRenderers);
		}

		[AsyncStateMachine(typeof(<SetSprite>d__42))]
		[DebuggerStepThrough]
		public static UniTask SetSprite(string url, Vector2 pivot, TextureFormat textureFormat = (TextureFormat)5, bool ignoreImageNotFoundError = false, params SpriteRenderer[] spriteRenderers)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_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_004f: Unknown result type (might be due to invalid IL or missing references)
			<SetSprite>d__42 <SetSprite>d__ = new <SetSprite>d__42();
			<SetSprite>d__.<>t__builder = AsyncUniTaskMethodBuilder.Create();
			<SetSprite>d__.url = url;
			<SetSprite>d__.pivot = pivot;
			<SetSprite>d__.textureFormat = textureFormat;
			<SetSprite>d__.ignoreImageNotFoundError = ignoreImageNotFoundError;
			<SetSprite>d__.spriteRenderers = spriteRenderers;
			<SetSprite>d__.<>1__state = -1;
			((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Start<<SetSprite>d__42>(ref <SetSprite>d__);
			return ((AsyncUniTaskMethodBuilder)(ref <SetSprite>d__.<>t__builder)).Task;
		}
	}
	public class Settings
	{
		public DebugLevel debugLevel = DebugLevel.Error;

		public bool useMemoryCache = true;

		public bool useDiskCache = false;

		public bool generateMipMaps = false;

		public string diskSaveLocation { get; set; } = Application.persistentDataPath + "/imageCache";
	}
	public enum DebugLevel
	{
		Log,
		Warning,
		Error,
		Exception,
		None
	}
	public static class Utils
	{
		public enum SizeUnits
		{
			Byte,
			KB,
			MB,
			GB,
			TB,
			PB,
			EB,
			ZB,
			YB
		}

		public class SpriteContainer
		{
			public Sprite sprite;
		}

		public static string ToSize(long value, SizeUnits unit = SizeUnits.MB)
		{
			return ((double)value / Math.Pow(1024.0, (double)unit)).ToString("0.00") + unit;
		}

		public static bool IsPowerOfTwo(int x)
		{
			return x != 0 && (x & (x - 1)) == 0;
		}

		public static Texture2D CreateTexWithMipmaps(byte[] data, GraphicsFormat origGraphicsFormat, int height = 4, int width = 4, TextureFormat textureFormat = (TextureFormat)0, string name = "")
		{
			//IL_0003: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_002c: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			GraphicsFormat val = (GraphicsFormat)100;
			TextureCreationFlags val2 = (TextureCreationFlags)1;
			Texture2D val3 = new Texture2D(width, height, val, val2);
			((Texture)val3).wrapMode = (TextureWrapMode)1;
			if (!ImageConversion.LoadImage(val3, data))
			{
				Debug.Log((object)$"CreateTexWithMipmaps: LoadImage failed, using format={val}, trying again with {(object)(GraphicsFormat)4}");
				val = (GraphicsFormat)4;
				val3 = new Texture2D(width, height, val, val2);
				if (!ImageConversion.LoadImage(val3, data))
				{
					Debug.LogError((object)$"CreateTexWithMipmaps: LoadImage failed, using format={val}, returning null texture");
					val3 = null;
				}
			}
			return val3;
		}

		public static Texture2D CreateTexWithMipmaps(byte[] data, bool shouldGenerateMipMaps = true, GraphicsFormat finalGraphicsFormat = (GraphicsFormat)4, int anisoLevel = 1, FilterMode filterMode = (FilterMode)1, string name = "DynamicTex")
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0009: 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)
			TextureCreationFlags val = (TextureCreationFlags)0;
			if (shouldGenerateMipMaps)
			{
				val = (TextureCreationFlags)1;
			}
			Texture2D val2 = new Texture2D(4, 4, finalGraphicsFormat, val)
			{
				name = name + "-" + shouldGenerateMipMaps,
				wrapMode = (TextureWrapMode)1,
				anisoLevel = 1,
				filterMode = (FilterMode)1
			};
			if (!ImageConversion.LoadImage(val2, data))
			{
				Debug.Log((object)$"CreateTexWithMipmaps: LoadImage failed using format={finalGraphicsFormat}, size={((Texture)val2).width}x{((Texture)val2).height} trying again with {(object)(GraphicsFormat)4}");
			}
			if (((Texture)val2).width % 4 == 0 && ((Texture)val2).height % 4 == 0)
			{
				val2.Compress(false);
			}
			return val2;
		}

		public static IEnumerator GetImageUsingUWRTexture(string url, Image img = null)
		{
			UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(url);
			yield return uwr.SendWebRequest();
			string name = Path.GetFileNameWithoutExtension(url);
			if ((int)uwr.result != 1 || !uwr.isDone)
			{
				Debug.Log((object)("GetImageUsingUWRTexture: Download failed : name=" + name + ", error=" + uwr.error));
				yield break;
			}
			Texture2D uwrTexture = ((DownloadHandlerTexture)uwr.downloadHandler).texture;
			Sprite downloadedSprite = Sprite.Create(uwrTexture, new Rect(0f, 0f, (float)((Texture)uwrTexture).width, (float)((Texture)uwrTexture).height), Vector2.zero, 100f, 0u, (SpriteMeshType)0);
			if ((Object)(object)img != (Object)null)
			{
				img.overrideSprite = downloadedSprite;
			}
			Debug.Log((object)$"GetImageUsingUWRTexture: name={name}, RawSize={ToSize(uwrTexture.GetRawTextureData().Length)}, mipmap={((Texture)uwrTexture).mipmapCount}, format={uwrTexture.format}, graphicsFormat={((Texture)uwrTexture).graphicsFormat}, dimensions={((Texture)uwrTexture).width}x{((Texture)uwrTexture).height}");
			uwr.Dispose();
		}

		public static IEnumerator GetImageUsingUWRBufferAndEnableMipmapsAndCompression(string url, SpriteContainer sprite = null)
		{
			UnityWebRequest uwr = new UnityWebRequest(url);
			uwr.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
			yield return uwr.SendWebRequest();
			string name = Path.GetFileNameWithoutExtension(url);
			if ((int)uwr.result != 1 || !uwr.isDone)
			{
				Debug.Log((object)("GetImageUsingUWRBufferAndEnableMipmapsAndCompression: Download failed : name=" + name + ", error=" + uwr.error));
				yield break;
			}
			GraphicsFormat graphicsFormat = (GraphicsFormat)4;
			TextureCreationFlags flags = (TextureCreationFlags)1;
			Texture2D createdTexture = new Texture2D(4, 4, graphicsFormat, flags)
			{
				name = name,
				wrapMode = (TextureWrapMode)1
			};
			if (!ImageConversion.LoadImage(createdTexture, uwr.downloadHandler.data))
			{
				Debug.LogError((object)$"GetImageUsingUWRBufferAndEnableMipmapsAndCompression: LoadImage failed using format={graphicsFormat}");
			}
			if (((Texture)createdTexture).width % 4 == 0 && ((Texture)createdTexture).height % 4 == 0)
			{
				createdTexture.Compress(false);
			}
			Sprite downloadedSprite = Sprite.Create(createdTexture, new Rect(0f, 0f, (float)((Texture)createdTexture).width, (float)((Texture)createdTexture).height), Vector2.zero, 100f, 0u, (SpriteMeshType)0);
			if (sprite != null)
			{
				sprite.sprite = downloadedSprite;
			}
			Debug.Log((object)$"GetImageUsingUWRBufferAndEnableMipmapsAndCompression: name={name}, RawSize={ToSize(createdTexture.GetRawTextureData().Length)}, mipmap={((Texture)createdTexture).mipmapCount}, format={createdTexture.format}, graphicsFormat={((Texture)createdTexture).graphicsFormat}, dimensions={((Texture)createdTexture).width}x{((Texture)createdTexture).height}");
			uwr.Dispose();
		}
	}
	internal class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
	{
		[ThreadStatic]
		private static bool _currentThreadIsProcessingItems;

		private readonly LinkedList<Task> _tasks = new LinkedList<Task>();

		private readonly int _maxDegreeOfParallelism;

		private int _delegatesQueuedOrRunning = 0;

		public sealed override int MaximumConcurrencyLevel => _maxDegreeOfParallelism;

		public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
		{
			if (maxDegreeOfParallelism < 1)
			{
				throw new ArgumentOutOfRangeException("maxDegreeOfParallelism");
			}
			_maxDegreeOfParallelism = maxDegreeOfParallelism;
		}

		protected sealed override void QueueTask(Task task)
		{
			lock (_tasks)
			{
				_tasks.AddLast(task);
				if (_delegatesQueuedOrRunning < _maxDegreeOfParallelism)
				{
					_delegatesQueuedOrRunning++;
					NotifyThreadPoolOfPendingWork();
				}
			}
		}

		private void NotifyThreadPoolOfPendingWork()
		{
			ThreadPool.UnsafeQueueUserWorkItem(delegate
			{
				_currentThreadIsProcessingItems = true;
				try
				{
					while (true)
					{
						Task value;
						lock (_tasks)
						{
							if (_tasks.Count == 0)
							{
								_delegatesQueuedOrRunning--;
								break;
							}
							value = _tasks.First.Value;
							_tasks.RemoveFirst();
						}
						TryExecuteTask(value);
					}
				}
				catch (Exception ex)
				{
					Debug.LogException(ex);
				}
				finally
				{
					_currentThreadIsProcessingItems = false;
				}
			}, null);
		}

		protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
		{
			if (!_currentThreadIsProcessingItems)
			{
				return false;
			}
			if (taskWasPreviouslyQueued)
			{
				TryDequeue(task);
			}
			return TryExecuteTask(task);
		}

		protected sealed override bool TryDequeue(Task task)
		{
			lock (_tasks)
			{
				return _tasks.Remove(task);
			}
		}

		protected sealed override IEnumerable<Task> GetScheduledTasks()
		{
			bool lockTaken = false;
			try
			{
				Monitor.TryEnter(_tasks, ref lockTaken);
				if (lockTaken)
				{
					return _tasks.ToArray();
				}
				throw new NotSupportedException();
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
				return null;
			}
			finally
			{
				if (lockTaken)
				{
					Monitor.Exit(_tasks);
				}
			}
		}
	}
}
namespace LBoLEntitySideloader
{
	[BepInPlugin("neo.lbol.frameworks.entitySideloader", "Entity Sideloader", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource log;

		private static Harmony harmony = PluginInfo.harmony;

		public static ConfigEntry<bool> devModeConfig;

		public static ConfigEntry<bool> devExtraLoggingConfig;

		public static ConfigEntry<KeyboardShortcut> reloadKeyConfig;

		public static ConfigEntry<KeyboardShortcut> hardReloadKeyConfig;

		public static ConfigEntry<bool> autoRestartLevelConfig;

		public static BepinexPlugin instance;

		private static SemaphoreSlim maBoi = new SemaphoreSlim(1);

		internal static int doingMidRunReload = 0;

		private void Awake()
		{
			//IL_0086: 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)
			instance = this;
			log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			devModeConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("DevMode", "DevMode", false, "Enables mod developer mode for extra functionality and error feedback.");
			devExtraLoggingConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("DevMode", "ExtraLogging", true, "Enables some additional error feedback when devMode is enabled.");
			reloadKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("DevMode", "ReloadKey", new KeyboardShortcut((KeyCode)287, Array.Empty<KeyCode>()), "Reload all entities (requires scriptengine).");
			hardReloadKeyConfig = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("DevMode", "HardReloadKey", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), "Hard reload localization and all entities (requires scriptengine).");
			autoRestartLevelConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("DevMode", "AutoRestart", true, "Restart level after reloading all entities.");
			ImageLoader.Init();
			ImageLoader.settings.useDiskCache = false;
			ImageLoader.settings.debugLevel = DebugLevel.Error;
			harmony.PatchAll();
		}

		private void OnDestroy()
		{
			instance = null;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		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)
			//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)
			if (!devModeConfig.Value)
			{
				return;
			}
			KeyboardShortcut value = reloadKeyConfig.Value;
			if (!((KeyboardShortcut)(ref value)).IsDown())
			{
				value = hardReloadKeyConfig.Value;
				if (!((KeyboardShortcut)(ref value)).IsDown())
				{
					return;
				}
			}
			if (Chainloader.PluginInfos.TryGetValue("com.bepis.bepinex.scriptengine", out var value2))
			{
				Reload(value2, hardReload: true);
			}
			else
			{
				log.LogInfo((object)"scriptengine is required for runtime reload");
			}
		}

		public void Reload(PluginInfo scriptEngineInfo, bool hardReload = false)
		{
			if (!hardReload)
			{
				log.LogInfo((object)"'Soft' reload is not a thing. Use 'hard' reload instead");
				return;
			}
			foreach (UserInfo value in EntityManager.Instance.sideloaderUsers.userInfos.Values)
			{
				EntityManager.Instance.UnregisterUser(value);
			}
			foreach (UserInfo value2 in EntityManager.Instance.secondaryUsers.userInfos.Values)
			{
				EntityManager.Instance.UnregisterUser(value2);
			}
			EntityManager.Instance.sideloaderUsers.userInfos = new Dictionary<Assembly, UserInfo>();
			EntityManager.Instance.secondaryUsers.userInfos = new Dictionary<Assembly, UserInfo>();
			UniqueTracker.DestroySelf();
			CollectionExtensions.Do<Assembly>((IEnumerable<Assembly>)EntityManager.Instance.loadedFromDiskUsers, (Action<Assembly>)delegate(Assembly a)
			{
				EntityManager.RegisterAssembly(a);
			});
			CollectionExtensions.Do<Action>((IEnumerable<Action>)EntityManager.Instance.loadedFromDiskPostAction, (Action<Action>)delegate(Action a)
			{
				UniqueTracker.Instance.PostMainLoad += a;
			});
			UniqueTracker.Instance.formationAddActions.AddRange(EnemyGroupTemplate.loadedFromDiskCustomFormations);
			UniqueTracker.Instance.populateLoadoutInfosActions.AddRange(EntityManager.Instance.loadedFromDiskCharLoadouts);
			UniqueTracker.Instance.modifyStageListFuncs.AddRange(EntityManager.Instance.loadedFromDiskmodifyStageListFuncs);
			UniqueTracker.Instance.modifyStageActions.AddRange(EntityManager.Instance.loadedFromModifyStageActions);
			UniqueTracker.Instance.formationAddActions.AddRange(StageTemplate.loadedFromDiskEnvironments);
			EntityManager.Instance.addBossIconsActions.Clear();
			Extensions.AddRange<SaveDataID, CustomGameRunSaveData>(UniqueTracker.Instance.customGrSaveData, EntityManager.Instance.loadedFromDsikCustomGrSaveData);
			ScriptEngineWrapper.ReloadPlugins(scriptEngineInfo.Instance);
			((MonoBehaviour)this).StartCoroutine(DoubleDelayAction(async delegate
			{
				if (await maBoi.WaitAsync(0))
				{
					try
					{
						ConfigDataManager.Reload();
						if (hardReload)
						{
							EntityManager.Instance.LoadAll(EntityManager.Instance.sideloaderUsers, "All primary Sideloader users registered!", "Finished loading primary user resources", loadLoc: false);
							await L10nManager.ReloadLocalization();
							UniqueTracker.Instance.RaisePostMainLoad();
							EntityManager.Instance.LoadAll(EntityManager.Instance.secondaryUsers, "All secondary Sideloader users registered!", "Finished loading secondary user resources", loadLoc: false);
						}
						else
						{
							EntityManager.Instance.LoadAll(EntityManager.Instance.sideloaderUsers, "All primary Sideloader users registered!", "Finished loading primary user resources");
							UniqueTracker.Instance.RaisePostMainLoad();
							EntityManager.Instance.LoadAll(EntityManager.Instance.secondaryUsers, "All secondary Sideloader users registered!", "Finished loading secondary user resources");
						}
						EntityManager.Instance.addBossIconsActions.Reload();
						EntityManager.Instance.PostAllLoadProcessing();
						CollectionExtensions.Do<Action>((IEnumerable<Action>)UniqueTracker.Instance.populateLoadoutInfosActions, (Action<Action>)delegate(Action a)
						{
							a();
						});
						if (Singleton<GameMaster>.Instance.CurrentGameRun == null)
						{
							UiManager.GetPanel<StartGamePanel>()._jadeBoxToggles.Clear();
							UiManager.GetPanel<StartGamePanel>().InitialForJadeBox();
							EnemyGroupTemplate.ReloadFormations();
							PlayerSpriteLoader.ReloadForMainMenu();
						}
						else
						{
							SpellTemplate.LoadAllSpecialLoc();
						}
						StageTemplate.ReloadEnvs();
						if (autoRestartLevelConfig.Value && Singleton<GameMaster>.Instance.CurrentGameRun != null)
						{
							SettingPanel panel = UiManager.GetPanel<SettingPanel>();
							if (panel != null)
							{
								panel.UI_RestartBattle();
							}
							doingMidRunReload = 1;
						}
					}
					catch (Exception ex)
					{
						Exception ex2 = ex;
						log.LogError((object)ex2);
					}
					finally
					{
						maBoi.Release();
					}
				}
			}));
		}

		private IEnumerator DoubleDelayAction(Action action)
		{
			yield return null;
			yield return null;
			action();
		}
	}
	public static class CharNames
	{
		public const string Reimu = "Reimu";

		public const string Marisa = "Marisa";

		public const string Sakuya = "Sakuya";

		public const string Cirno = "Cirno";

		public const string Koishi = "Koishi";
	}
	internal class DeferredActions
	{
		internal Dictionary<IdContainer, Action> actions = new Dictionary<IdContainer, Action>();

		internal Dictionary<IdContainer, Action> reloadableActions = new Dictionary<IdContainer, Action>();

		internal void AddAction(IdContainer id, Action action, Assembly callingAssembly)
		{
			if (callingAssembly.IsLoadedFromDisk())
			{
				actions.AlwaysAdd(id, action);
			}
			else
			{
				reloadableActions.Add(id, action);
			}
		}

		internal void DoAll()
		{
			CollectionExtensions.Do<Action>((IEnumerable<Action>)actions.Values, (Action<Action>)delegate(Action a)
			{
				a();
			});
			CollectionExtensions.Do<Action>((IEnumerable<Action>)reloadableActions.Values, (Action<Action>)delegate(Action a)
			{
				a();
			});
		}

		internal void Clear()
		{
			reloadableActions.Clear();
		}

		internal void Reload()
		{
			CollectionExtensions.Do<Action>((IEnumerable<Action>)reloadableActions.Values, (Action<Action>)delegate(Action a)
			{
				a();
			});
		}
	}
	public static class DictionaryExtensions
	{
		public static bool AlwaysAdd<K, V>(this Dictionary<K, V> dictionary, K key, V value)
		{
			if (!dictionary.TryAdd(key, value))
			{
				dictionary[key] = value;
				return true;
			}
			return false;
		}

		public static bool AlwaysAdd<K, V>(this AssociationList<K, V> associationList, K key, V value)
		{
			if (!((IDictionary<K, V>)associationList).TryAdd(key, value))
			{
				associationList[key] = value;
				return true;
			}
			return false;
		}

		public static bool Merge<K, V>(this Dictionary<K, V> dictionary, Dictionary<K, V> otherDic, bool overwrite = true)
		{
			bool dupes = false;
			otherDic.ToList().ForEach(delegate(KeyValuePair<K, V> x)
			{
				dupes = dictionary.AlwaysAdd(x.Key, x.Value) || dupes;
			});
			return dupes;
		}
	}
	public static class AdventureRegistry
	{
		internal static readonly Dictionary<string, YarnData> YarnPrograms = new Dictionary<string, YarnData>(StringComparer.OrdinalIgnoreCase);

		internal static readonly Dictionary<string, Texture2D> AdventureTextures = new Dictionary<string, Texture2D>(StringComparer.OrdinalIgnoreCase);

		public static void RegisterYarnData(string dialogName, YarnData yarnData)
		{
			if (yarnData != null)
			{
				YarnPrograms[dialogName] = yarnData;
				if (!dialogName.StartsWith("Adventure/", StringComparison.OrdinalIgnoreCase))
				{
					YarnPrograms["Adventure/" + dialogName] = yarnData;
				}
			}
		}

		public static void RegisterAdventureImage(string imageName, Texture2D texture)
		{
			if ((Object)(object)texture != (Object)null)
			{
				AdventureTextures[imageName] = texture;
			}
		}
	}
	[HarmonyPatch(typeof(DialogRunner), "LoadAsync")]
	public static class DialogRunnerPatch
	{
		private static bool Prefix(string name, IVariableStorage storage, Library library, ref UniTask<DialogRunner> __result)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//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)
			BepinexPlugin.log.LogInfo((object)("[DialogRunnerPatch] Intercepted LoadAsync for dialog name: '" + name + "'"));
			if (!AdventureRegistry.YarnPrograms.TryGetValue(name, out var value) || value == null)
			{
				return true;
			}
			if (value.compiledBytes == null)
			{
				BepinexPlugin.log.LogError((object)("[DialogRunnerPatch] Dialog '" + name + "' found in registry, but compiledBytes is NULL!"));
				return true;
			}
			BepinexPlugin.log.LogInfo((object)("[DialogRunnerPatch] Found YarnData for '" + name + "'. Getting string table..."));
			Dictionary<string, string> stringTableForCurrentLocale = value.GetStringTableForCurrentLocale();
			DialogRunner val = new DialogRunner(name, value.compiledBytes, (IDictionary<string, string>)stringTableForCurrentLocale, storage, library);
			__result = UniTask.FromResult<DialogRunner>(val);
			BepinexPlugin.log.LogInfo((object)$"[DialogRunnerPatch] Successfully created DialogRunner for '{name}' with {stringTableForCurrentLocale.Count} string table entries.");
			return false;
		}
	}
	[HarmonyPatch(typeof(ResourcesHelper), "LoadAdventureImage")]
	public static class AdventureImagePatch
	{
		private static bool Prefix(string name, ref Texture2D __result)
		{
			if (AdventureRegistry.AdventureTextures.TryGetValue(name, out var value) && (Object)(object)value != (Object)null)
			{
				__result = value;
				return false;
			}
			return true;
		}
	}
	public class EntityManager
	{
		private static EntityManager _instance;

		private static readonly ManualLogSource log = BepinexPlugin.log;

		public HashSet<Assembly> loadedFromDiskUsers = new HashSet<Assembly>();

		public HashSet<Action> loadedFromDiskPostAction = new HashSet<Action>();

		public SideloaderUsers sideloaderUsers = new SideloaderUsers();

		public SideloaderUsers secondaryUsers = new SideloaderUsers();

		public List<Action> loadedFromDiskCharLoadouts = new List<Action>();

		public List<Func<List<Stage>, List<Stage>>> loadedFromDiskmodifyStageListFuncs = new List<Func<List<Stage>, List<Stage>>>();

		public List<UniqueTracker.StageModAction> loadedFromModifyStageActions = new List<UniqueTracker.StageModAction>();

		internal DeferredActions addBossIconsActions = new DeferredActions();

		internal Dictionary<SaveDataID, CustomGameRunSaveData> loadedFromDsikCustomGrSaveData = new Dictionary<SaveDataID, CustomGameRunSaveData>();

		public static EntityManager Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new EntityManager();
				}
				return _instance;
			}
		}

		public IEnumerable<(Assembly ass, UserInfo userInfo)> AllUsers => from kv in sideloaderUsers.userInfos.Concat(secondaryUsers.userInfos)
			select (Key: kv.Key, Value: kv.Value);

		public static UserInfo ScanAssembly(Assembly assembly, bool lookForFactypes = true)
		{
			UserInfo userInfo = new UserInfo();
			userInfo.assembly = assembly;
			if (!assembly.IsDynamic && BepinexPlugin.devModeConfig.Value && !string.IsNullOrEmpty(assembly.Location))
			{
				Instance.loadedFromDiskUsers.Add(assembly);
			}
			ManualLogSource obj = Log.LogDev();
			if (obj != null)
			{
				obj.LogInfo((object)("Scanning " + assembly.GetName().Name + "..."));
			}
			Type[] array = ((!assembly.IsDynamic) ? assembly.GetExportedTypes() : assembly.GetTypes());
			userInfo.assembly = assembly;
			HashSet<Type> hashSet = new HashSet<Type>();
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				if (!assembly.IsDynamic && type.IsSubclassOf(typeof(BaseUnityPlugin)))
				{
					object[] customAttributes = type.GetCustomAttributes(inherit: false);
					BepInPlugin val = type.SingularAttribute<BepInPlugin>(customAttributes);
					if (val != null)
					{
						userInfo.GUID = val.GUID;
					}
					else
					{
						log.LogError((object)$"{assembly.GetName().Name}: {type} does not have {typeof(BepInPlugin).Name} attribute despite extending {typeof(BaseUnityPlugin).Name}");
					}
					IEnumerable<BepInDependency> enumerable = type.MultiAttribute<BepInDependency>(customAttributes);
					if (enumerable == null || !enumerable.Any((BepInDependency bd) => bd.DependencyGUID == "neo.lbol.frameworks.entitySideloader" && (int)bd.Flags == 1))
					{
						log.LogWarning((object)string.Format("{0}: {1} does not have a {2} attribute with {3} as hard dependency.", assembly.GetName().Name, type, typeof(BepInDependency).Name, "neo.lbol.frameworks.entitySideloader"));
					}
					continue;
				}
				if (type.IsSubclassOf(typeof(EntityDefinition)))
				{
					if (type.IsSealed)
					{
						EntityDefinition entityDefinition = (EntityDefinition)Activator.CreateInstance(type);
						userInfo.definitionInstances.Add(type, entityDefinition);
						entityDefinition.userAssembly = userInfo.assembly;
						entityDefinition.user = userInfo;
						OverwriteVanilla customAttribute = type.GetCustomAttribute<OverwriteVanilla>(inherit: true);
						if (customAttribute != null)
						{
							userInfo.entitiesToOverwrite.Add(type, new ModificationInfo
							{
								attribute = customAttribute
							});
						}
					}
					else if (BepinexPlugin.devModeConfig.Value && !type.IsSealed)
					{
						ManualLogSource obj2 = Log.LogDevExtra();
						if (obj2 != null)
						{
							obj2.LogWarning((object)$"(Extra logging) {assembly.GetName().Name}: {type} is subtype of {typeof(EntityDefinition).Name} but isn't sealed. Final entity templates need to be sealed.");
						}
					}
					continue;
				}
				Type type2 = TypeFactoryReflection.factoryTypes.FirstOrDefault((Type t) => type.IsSubclassOf(t));
				if (!(type2 != null))
				{
					continue;
				}
				if (type.IsSealed)
				{
					userInfo.entityInfos.TryAdd(type2, new List<EntityInfo>());
					EntityLogic customAttribute2 = type.GetCustomAttribute<EntityLogic>();
					if (customAttribute2 != null)
					{
						if (hashSet.Contains(customAttribute2.DefinitionType))
						{
							log.LogError((object)$"{assembly.GetName().Name}: {customAttribute2.DefinitionType} already has an entity logic type associated. Entity can only have one type defining its logic. Please remove {typeof(EntityLogic).Name} attribute.");
						}
						else if (BepinexPlugin.devModeConfig.Value && !TemplatesReflection.IsTemplateType(customAttribute2.DefinitionType))
						{
							log.LogError((object)(customAttribute2.DefinitionType.Name + " type provided to " + typeof(EntityLogic).Name + " attribute on " + type.Name + " is not an " + typeof(EntityDefinition).Name + ". Entity definition must extend one of the entity templates."));
						}
						else
						{
							hashSet.Add(customAttribute2.DefinitionType);
							EntityInfo entityInfo = new EntityInfo(type2, type, customAttribute2.DefinitionType);
							userInfo.entityInfos[type2].Add(entityInfo);
							userInfo.definition2customEntityLogicType.Add(customAttribute2.DefinitionType, entityInfo.entityType);
						}
						continue;
					}
					ExternalEntityLogicAttribute customAttribute3 = type.GetCustomAttribute<ExternalEntityLogicAttribute>();
					if (customAttribute3 == null)
					{
						ManualLogSource obj3 = Log.LogDevExtra();
						if (obj3 != null)
						{
							obj3.LogWarning((object)("(Extra logging) " + assembly.GetName().Name + ": " + type.Name + " does not have " + typeof(EntityLogic).Name + " attribute despite having qualities of an entity logic type. Please add " + typeof(EntityLogic).Name + " attribute."));
						}
					}
				}
				else if (BepinexPlugin.devModeConfig.Value && !type.IsSealed)
				{
					ManualLogSource obj4 = Log.LogDevExtra();
					if (obj4 != null)
					{
						obj4.LogWarning((object)$"(Extra logging) {assembly.GetName().Name}: {type} is subtype of {type2.Name} but isn't sealed. Final entity logic types need to be sealed");
					}
				}
			}
			if (BepinexPlugin.devModeConfig.Value && BepinexPlugin.devExtraLoggingConfig.Value && !assembly.IsDynamic)
			{
				foreach (Type item in hashSet)
				{
					if (userInfo.definition2customEntityLogicType.TryGetValue(item, out var value) && userInfo.definitionInstances.TryGetValue(item, out var value2) && !value.IsSubclassOf(value2.EntityType()))
					{
						throw new InvalidProgramException($"(Extra Logging) {item.Name} expects its entity logic type, {value.Name}, to extend {value2.EntityType()}. Instead {value.Name} extends {value.BaseType} ");
					}
				}
				foreach (KeyValuePair<Type, EntityDefinition> definitionInstance in userInfo.definitionInstances)
				{
					Type key = definitionInstance.Key;
					EntityDefinition value3 = definitionInstance.Value;
					if (!userInfo.IsForOverwriting(key) && TemplatesReflection.ExpectsEntityLogic(key) && !hashSet.Contains(key))
					{
						log.LogWarning((object)("(Extra logging) " + key.Name + " needs entity logic type extending " + value3.EntityType().Name + " but none was found. Did you define public sealed entity logic class with " + typeof(EntityLogic).Name + " attribute?"));
					}
				}
			}
			log.LogMessage((object)$"{assembly.GetName().Name} scanned! {userInfo.definitionInstances.Count()} Entity definition(s) found.");
			if (BepinexPlugin.devModeConfig.Value && BepinexPlugin.devExtraLoggingConfig.Value)
			{
				log.LogInfo((object)"(Extra logging) Entity definitions found: ");
				CollectionExtensions.Do<KeyValuePair<Type, EntityDefinition>>((IEnumerable<KeyValuePair<Type, EntityDefinition>>)userInfo.definitionInstances, (Action<KeyValuePair<Type, EntityDefinition>>)delegate(KeyValuePair<Type, EntityDefinition> kv)
				{
					log.LogInfo((object)kv.Key.Name);
				});
			}
			return userInfo;
		}

		public static void AddExternalDefinitionTypePromise(Type entityLogicType, Func<Type> defTypePromise, Assembly userAssembly = null)
		{
			if (userAssembly == null)
			{
				userAssembly = Assembly.GetCallingAssembly();
			}
			UniqueTracker.Instance.typePromiseDic.TryAdd(userAssembly, new Dictionary<Type, List<UniqueTracker.DefTypePromisePair>>());
			Type type = TypeFactoryReflection.factoryTypes.FirstOrDefault((Type t) => entityLogicType.IsSubclassOf(t));
			if (type == null)
			{
				throw new ArgumentException($"{entityLogicType} does not inherit from general entity logic types");
			}
			UniqueTracker.Instance.typePromiseDic[userAssembly].TryAdd(type, new List<UniqueTracker.DefTypePromisePair>());
			UniqueTracker.Instance.typePromiseDic[userAssembly][type].Add(new UniqueTracker.DefTypePromisePair
			{
				entityLogicType = entityLogicType,
				defTypePromise = defTypePromise
			});
		}

		public static void AddPostLoadAction(Action action, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			Action action2 = delegate
			{
				try
				{
					action();
				}
				catch (Exception arg)
				{
					log.LogError((object)$"Error during template generation: {arg}");
				}
			};
			if (!callingAssembly.IsDynamic && !string.IsNullOrEmpty(callingAssembly.Location))
			{
				Instance.loadedFromDiskPostAction.Add(action2);
			}
			UniqueTracker.Instance.PostMainLoad += action2;
		}

		public static void RegisterSelf()
		{
			Assembly callingAssembly = Assembly.GetCallingAssembly();
			RegisterAssembly(callingAssembly);
		}

		public static void RegisterAssembly(Assembly assembly)
		{
			Instance.sideloaderUsers.AddUser(assembly);
		}

		internal bool RegisterId(UserInfo user, EntityDefinition entityDefinition)
		{
			ManualLogSource obj = Log.LogDevExtra();
			if (obj != null)
			{
				obj.LogDebug((object)$"(Extra logging) Registering id:  template: {entityDefinition.GetType().Name}, id: {entityDefinition.GetId()}, IsForOverwriting: {user.IsForOverwriting(entityDefinition.GetType())}");
			}
			Type type = entityDefinition.GetType();
			try
			{
				if (user.entitiesToOverwrite.ContainsKey(type))
				{
					if (!UniqueTracker.Instance.id2ConfigListIndex[entityDefinition.ConfigType()].ContainsKey(entityDefinition.GetId()))
					{
						log.LogError((object)$"RegisterId: {entityDefinition.GetId()} was not found among vanilla ids. Overwriting is not supported for non-vanilla entities (for now, maybe).");
						UniqueTracker.Instance.invalidRegistrations.Add(type);
						return false;
					}
					return true;
				}
				UniqueTracker.AddUniqueId(entityDefinition, user);
			}
			catch (Exception ex)
			{
				log.LogError((object)ex);
				UniqueTracker.Instance.invalidRegistrations.Add(type);
				return false;
			}
			return true;
		}

		internal void RegisterUser(UserInfo user)
		{
			log.LogInfo((object)("Registering assembly: " + user.assembly.GetName().Name));
			ManualLogSource obj = Log.LogDev();
			if (obj != null)
			{
				obj.LogDebug((object)"Adding configs..");
			}
			Stopwatch stopwatch = new Stopwatch();
			if (BepinexPlugin.devModeConfig.Value)
			{
				stopwatch.Start();
			}
			foreach (KeyValuePair<Type, EntityDefinition> definitionInstance in user.definitionInstances)
			{
				Type key = definitionInstance.Key;
				EntityDefinition value = definitionInstance.Value;
				if (!RegisterId(user, value))
				{
					continue;
				}
				try
				{
					if (value is CardTemplate cardTemplate)
					{
						CardConfig val = RegisterConfig(cardTemplate, user);
						if (val == null)
						{
							val = CardConfig.FromId((string)cardTemplate.UniqueId);
						}
						val.Colors = val.Colors.OrderBy((ManaColor c) => (int)c).ToList();
					}
					else if (value is StatusEffectTemplate configProvider)
					{
						RegisterConfig(configProvider, user);
					}
					else if (value is ExhibitTemplate configProvider2)
					{
						RegisterConfig(configProvider2, user);
					}
					else if (value is BgmTemplate bgmTemplate)
					{
						BgmConfig val2 = RegisterConfig(bgmTemplate, user);
						if (val2 == null)
						{
							val2 = BgmConfig.FromID((string)bgmTemplate.UniqueId);
						}
						if (!user.IsForOverwriting(bgmTemplate.GetType()) || (user.IsForOverwriting(bgmTemplate.GetType()) && TemplatesReflection.DoOverwrite(bgmTemplate.GetType(), "LoadAudioClipAsync")))
						{
							val2.Path = val2.ID;
							val2.Folder = "";
						}
						UniqueTracker.Instance.AddOnDemandResource(bgmTemplate.TemplateType(), val2.ID, value);
					}
					else if (value is SfxTemplate configProvider3)
					{
						RegisterConfig(configProvider3, user);
					}
					else if (value is UiSoundTemplate configProvider4)
					{
						RegisterConfig(configProvider4, user);
					}
					else if (value is JadeBoxTemplate configProvider5)
					{
						RegisterConfig(configProvider5, user);
					}
					else if (value is EnemyUnitTemplate configProvider6)
					{
						RegisterConfig(configProvider6, user);
					}
					else if (value is UltimateSkillTemplate configProvider7)
					{
						RegisterConfig(configProvider7, user);
					}
					else if (value is EnemyGroupTemplate configProvider8)
					{
						RegisterConfig(configProvider8, user);
					}
					else if (value is PlayerUnitTemplate playerUnitTemplate)
					{
						PlayerUnitConfig val3 = RegisterConfig(playerUnitTemplate, user);
						UniqueTracker.Instance.AddOnDemandResource(playerUnitTemplate.TemplateType(), val3.Id, playerUnitTemplate);
					}
					else if (value is UnitModelTemplate unitModelTemplate)
					{
						UnitModelConfig val4 = RegisterConfig(unitModelTemplate, user);
						UniqueTracker.Instance.AddOnDemandResource(unitModelTemplate.TemplateType(), val4.Name, unitModelTemplate);
					}
					else if (value is StageTemplate configProvider9)
					{
						RegisterConfig(configProvider9, user);
					}
					else if (value is EffectTemplate effectTemplate)
					{
						string text = null;
						if (user.IsForOverwriting(effectTemplate.GetType()) && TemplatesReflection.DoOverwrite(effectTemplate.GetType(), "MakeConfig"))
						{
							text = EffectConfig.FromName((string)value.UniqueId).Path;
						}
						EffectConfig val5 = RegisterConfig(effectTemplate, user);
						if (val5 != null)
						{
							if (text != null)
							{
								val5.Path = text;
							}
							else
							{
								val5.Path = val5.Name;
							}
						}
					}
					else if (value is LaserTemplate configProvider10)
					{
						RegisterConfig(configProvider10, user);
					}
					else if (value is BulletTemplate configProvider11)
					{
						RegisterConfig(configProvider11, user);
					}
					else if (value is GunTemplate configProvider12)
					{
						RegisterConfig(configProvider12, user);
					}
					else if (value is PieceTemplate configProvider13)
					{
						RegisterConfig(configProvider13, user);
					}
					else if (value is SpellTemplate configProvider14)
					{
						RegisterConfig(configProvider14, user);
					}
					else if (value is PackTemplate configProvider15)
					{
						RegisterConfig(configProvider15, user);
					}
					else if (value is AdventureTemplate configProvider16)
					{
						RegisterConfig(configProvider16, user);
					}
				}
				catch (Exception arg)
				{
					log.LogError((object)$"Exception registering config of {value}: {arg}");
				}
			}
			ManualLogSource obj2 = Log.LogDev();
			if (obj2 != null)
			{
				obj2.LogDebug((object)"Adding entity logic types..");
			}
			foreach (KeyValuePair<Type, List<EntityInfo>> entityInfo in user.entityInfos)
			{
				RegisterTypes(entityInfo.Key, user);
			}
			string text2 = "Registering assembly " + user.assembly.GetName().Name + " done!";
			if (BepinexPlugin.devModeConfig.Value)
			{
				stopwatch.Stop();
				text2 += $" Elapsed time: {stopwatch.ElapsedMilliseconds}ms";
			}
			log.LogInfo((object)text2);
		}

		internal C RegisterConfig<C>(IConfigProvider<C> configProvider, UserInfo user, EntityDefinition entityDefinition = null) where C : class
		{
			if (entityDefinition == null)
			{
				entityDefinition = (EntityDefinition)configProvider;
			}
			Type type = entityDefinition.ConfigType();
			Type type2 = entityDefinition.GetType();
			if (type == null)
			{
				return null;
			}
			if (type.IsSubclassOf(typeof(MockConfig)))
			{
				return null;
			}
			FieldInfo idField = ConfigReflection.GetIdField(type);
			ManualLogSource obj = Log.LogDevExtra();
			if (obj != null)
			{
				obj.LogDebug((object)$"(Extra Logging) Registering config: id: {entityDefinition.UniqueId}, config type:{entityDefinition.ConfigType().Name}");
			}
			FieldInfo arrayField = ConfigReflection.GetArrayField(type);
			FieldRef<C[]> val = AccessTools.StaticFieldRefAccess<C[]>(arrayField);
			FieldInfo tableField = ConfigReflection.GetTableField(type);
			C val2 = null;
			if (!UniqueTracker.Instance.invalidRegistrations.Contains(type2) && (!user.IsForOverwriting(entityDefinition.GetType()) || TemplatesReflection.DoOverwrite(type2, "MakeConfig")))
			{
				val2 = configProvider.MakeConfig();
				if (val2 == null)
				{
					throw new ArgumentException("MakeConfig must return a non-null value.");
				}
				switch (entityDefinition.UniqueId.idType)
				{
				case IdContainer.IdType.String:
					idField.SetValue(val2, (string)entityDefinition.UniqueId);
					break;
				case IdContainer.IdType.Int:
					idField.SetValue(val2, (int)entityDefinition.UniqueId);
					break;
				default:
					log.LogWarning((object)"RegisterConfig: you shouldn't be here");
					break;
				}
			}
			if (!user.IsForOverwriting(entityDefinition.GetType()))
			{
				FieldInfo fieldInfo = ConfigReflection.HasIndex(type);
				if (fieldInfo != null)
				{
					fieldInfo.SetValue(val2, UniqueTracker.AddUniqueIndex(IdContainer.CastFromObject(fieldInfo.GetValue(val2)), entityDefinition));
				}
				switch (entityDefinition.UniqueId.idType)
				{
				case IdContainer.IdType.String:
					idField.SetValue(val2, (string)entityDefinition.UniqueId);
					break;
				case IdContainer.IdType.Int:
					idField.SetValue(val2, (int)entityDefinition.UniqueId);
					break;
				default:
					log.LogWarning((object)"RegisterConfig: you shouldn't be here");
					break;
				}
				switch (entityDefinition.UniqueId.idType)
				{
				case IdContainer.IdType.String:
					((Dictionary<string, C>)tableField.GetValue(null)).Add(entityDefinition.UniqueId, val2);
					break;
				case IdContainer.IdType.Int:
					((Dictionary<int, C>)tableField.GetValue(null)).Add(entityDefinition.UniqueId, val2);
					break;
				default:
					log.LogWarning((object)"RegisterConfig: you shouldn't be here");
					break;
				}
				val.Invoke() = CollectionExtensions.AddToArray<C>(val.Invoke(), val2).ToArray();
			}
			else if (!UniqueTracker.Instance.invalidRegistrations.Contains(type2) && TemplatesReflection.DoOverwrite(type2, "MakeConfig") && !UniqueTracker.IsOverwriten(entityDefinition.TemplateType(), entityDefinition.UniqueId, "MakeConfig", type2, user))
			{
				int num = UniqueTracker.Instance.id2ConfigListIndex[type][IdContainer.CastFromObject(idField.GetValue(val2))];
				switch (entityDefinition.UniqueId.idType)
				{
				case IdContainer.IdType.String:
					((Dictionary<string, C>)tableField.GetValue(null)).AlwaysAdd((string)entityDefinition.UniqueId, val2);
					break;
				case IdContainer.IdType.Int:
					((Dictionary<int, C>)tableField.GetValue(null)).AlwaysAdd((int)entityDefinition.UniqueId, val2);
					break;
				default:
					log.LogWarning((object)"RegisterConfig: you shouldn't be here");
					break;
				}
				val.Invoke()[num] = val2;
			}
			return val2;
		}

		internal static void RegisterTypes(Type facType, UserInfo user)
		{
			if (!user.entityInfos.TryGetValue(facType, out var value))
			{
				return;
			}
			foreach (EntityInfo item in value)
			{
				try
				{
					ManualLogSource obj = Log.LogDevExtra();
					if (obj != null)
					{
						obj.LogDebug((object)("(Extra Logging) Registering entity logic type in TypeFactory<" + facType.Name + ">, typeName: " + item.entityType.Name + ", from template: " + item.definitionType.Name));
					}
					if (UniqueTracker.Instance.invalidRegistrations.Contains(item.definitionType) || !user.definitionInstances.ContainsKey(item.definitionType))
					{
						log.LogError((object)("TypeFactory<" + facType.Name + ">: Cannot register entity logic " + item.entityType.Name + " because template " + item.definitionType.Name + " was not properly loaded."));
						continue;
					}
					EntityDefinition entityDefinition = user.definitionInstances[item.definitionType];
					IdContainer uniqueId = entityDefinition.UniqueId;
					if (uniqueId != (IdContainer)item.entityType.Name)
					{
						log.LogError((object)$"{user.GUID} entity id, {uniqueId}, mismatches entity type name, {item.entityType.Name}");
						continue;
					}
					if (!user.IsForOverwriting(item.definitionType))
					{
						if (!TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.FullNameTypeDict).Invoke((object)null).TryAdd(item.entityType.FullName, item.entityType))
						{
							log.LogError((object)("RegisterType: " + item.entityType.Name + " matches an already registered type. Please change plugin namespace."));
						}
					}
					else
					{
						IdContainer id = entityDefinition.GetId();
						if (!UniqueTracker.IsOverwriten(entityDefinition.TemplateType(), id, "EntityLogic", item.definitionType, user))
						{
							Type type = TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.TypeDict).Invoke((object)null)[uniqueId];
							user.typeName2VanillaType.Add(id, type);
							TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.FullNameTypeDict).Invoke((object)null)[type.FullName] = item.entityType;
						}
					}
					if (!user.IsForOverwriting(item.definitionType))
					{
						TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.TypeDict).Invoke((object)null).Add(uniqueId, item.entityType);
					}
					else
					{
						TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.TypeDict).Invoke((object)null).AlwaysAdd((string)uniqueId, item.entityType);
					}
					ProcessWeighterAttribute(facType, item.entityType);
				}
				catch (Exception ex)
				{
					log.LogError((object)ex);
				}
			}
		}

		private static void ProcessWeighterAttribute(Type facType, Type entityType)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			if (facType == typeof(Exhibit))
			{
				ExhibitInfoAttribute customAttribute = ((MemberInfo)entityType).GetCustomAttribute<ExhibitInfoAttribute>();
				IExhibitWeighter val = ((customAttribute != null) ? customAttribute.CreateWeighter() : null);
				if (val != null)
				{
					Library._exhibitWeighterTable.AlwaysAdd(entityType, val);
				}
			}
			else
			{
				if (!(facType == typeof(Adventure)))
				{
					return;
				}
				AdventureInfoAttribute customAttribute2 = ((MemberInfo)entityType).GetCustomAttribute<AdventureInfoAttribute>();
				if (((customAttribute2 != null) ? customAttribute2.WeighterType : null) != null)
				{
					IAdventureWeighter val2 = (IAdventureWeighter)Activator.CreateInstance(customAttribute2.WeighterType);
					if (val2 != null)
					{
						Library._adventureWeighterTable.AlwaysAdd(entityType, val2);
					}
				}
			}
		}

		internal static void UnRegisterTypes(Type facType, UserInfo user)
		{
			if (!user.entityInfos.TryGetValue(facType, out var value))
			{
				return;
			}
			foreach (EntityInfo item in value)
			{
				if (UniqueTracker.Instance.invalidRegistrations.Contains(item.definitionType) || !user.definitionInstances.ContainsKey(item.definitionType))
				{
					continue;
				}
				EntityDefinition entityDefinition = user.definitionInstances[item.definitionType];
				IdContainer uniqueId = entityDefinition.UniqueId;
				if (!user.IsForOverwriting(item.definitionType))
				{
					TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.FullNameTypeDict).Invoke((object)null).Remove(item.entityType.FullName);
					TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.TypeDict).Invoke((object)null).Remove(uniqueId);
					if (facType == typeof(Exhibit))
					{
						Library._exhibitWeighterTable.Remove(item.entityType);
					}
					else if (facType == typeof(Adventure))
					{
						Library._adventureWeighterTable.Remove(item.entityType);
					}
				}
				else
				{
					Type type = user.typeName2VanillaType[uniqueId];
					TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.FullNameTypeDict).Invoke((object)null)[item.entityType.FullName] = type;
					TypeFactoryReflection.AccessTypeDicts(facType, TypeFactoryReflection.TableFieldName.TypeDict).Invoke((object)null)[uniqueId] = type;
					ProcessWeighterAttribute(facType, type);
				}
			}
		}

		internal void UnregisterUser(UserInfo user)
		{
			foreach (KeyValuePair<Type, List<EntityInfo>> entityInfo in user.entityInfos)
			{
				UnRegisterTypes(entityInfo.Key, user);
			}
		}

		internal void RegisterUsers(SideloaderUsers sideloaderUsers, string onCompleteMsg = "All sideloader users registered!")
		{
			foreach (KeyValuePair<Assembly, UserInfo> userInfo in sideloaderUsers.userInfos)
			{
				UserInfo value = userInfo.Value;
				RegisterUser(value);
			}
			log.LogInfo((object)onCompleteMsg);
		}

		internal void LoadAssetsForResourceHelper(SideloaderUsers sideloaderUsers)
		{
			foreach (KeyValuePair<Assembly, UserInfo> userInfo in sideloaderUsers.userInfos)
			{
				UserInfo value = userInfo.Value;
				foreach (KeyValuePair<Type, EntityDefinition> definitionInstance in userInfo.Value.definitionInstances)
				{
					Type key = definitionInstance.Key;
					EntityDefinition value2 = definitionInstance.Value;
					CardTemplate ct = value2 as CardTemplate;
					if (ct != null)
					{
						HandleOverwriteWrap(delegate
						{
							ct.Consume(ct.LoadCardImages());
						}, value2, "LoadCardImages", value);
						continue;
					}
					StatusEffectTemplate st = value2 as StatusEffectTemplate;
					if (st != null)
					{
						HandleOverwriteWrap(delegate
						{
							st.Consume(st.LoadSprite());
						}, value2, "LoadSprite", value);
						continue;
					}
					ExhibitTemplate et = value2 as ExhibitTemplate;
					if (et != null)
					{
						HandleOverwriteWrap(delegate
						{
							et.Consume(et.LoadSprite());
						}, value2, "LoadSprite", value);
						continue;
					}
					UltimateSkillTemplate ust = value2 as UltimateSkillTemplate;
					if (ust != null)
					{
						HandleOverwriteWrap(delegate
						{
							ust.Consume(ust.LoadSprite());
						}, value2, "LoadSprite", value);
						continue;
					}
					SfxTemplate sfxT = value2 as SfxTemplate;
					if (sfxT != null)
					{
						HandleOverwriteWrap(delegate
						{
							sfxT.Consume(sfxT.LoadSfxListAsync());
						}, value2, "LoadSfxListAsync", value);
						continue;
					}
					UiSoundTemplate usfxT = value2 as UiSoundTemplate;
					if (usfxT != null)
					{
						HandleOverwriteWrap(delegate
						{
							usfxT.Consume(usfxT.LoadSfxListAsync());
						}, value2, "LoadSfxListAsync", value);
						continue;
					}
					if (value2 is PlayerUnitTemplate playerUnitTemplate)
					{
						playerUnitTemplate.Consume(playerUnitTemplate.LoadPlayerImages());
						continue;
					}
					EffectTemplate eft = value2 as EffectTemplate;
					if (eft != null)
					{
						HandleOverwriteWrap(delegate
						{
							eft.Consume(eft.LoadEffectData());
						}, value2, "LoadEffectData", value);
						continue;
					}
					IntentionTemplate it = value2 as IntentionTemplate;
					if (it != null)
					{
						HandleOverwriteWrap(delegate
						{
							it.Consume(it.LoadSprites());
						}, value2, "LoadSprites", value);
						continue;
					}
					PackTemplate pt = value2 as PackTemplate;
					if (pt != null)
					{
						HandleOverwriteWrap(delegate
						{
							pt.Consume(pt.LoadPackIcon());
						}, value2, "LoadPackIcon", value);
						continue;
					}
					AdventureTemplate at = value2 as AdventureTemplate;
					if (at != null)
					{
						HandleOverwriteWrap(delegate
						{
							at.Consume(at.LoadAdventureImages());
						}, value2, "LoadAdventureImages", value);
						HandleOverwriteWrap(delegate
						{
							at.Consume(at.LoadYarnData());
						}, value2, "LoadYarnData", value);
					}
				}
			}
		}

		internal void LoadLocalization(SideloaderUsers sideloaderUsers)
		{
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0640: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Assembly, UserInfo> userInfo in sideloaderUsers.userInfos)
			{
				UserInfo value = userInfo.Value;
				UniqueTracker.Instance.typesToLocalize[value.assembly] = new Dictionary<Type, LocalizationInfo>();
				foreach (KeyValuePair<Type, EntityDefinition> definitionInstance in value.definitionInstances)
				{
					EntityDefinition value2 = definitionInstance.Value;
					CardTemplate ct = value2 as CardTemplate;
					if (ct != null)
					{
						HandleOverwriteWrap(delegate
						{
							ct.Consume(ct.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					StatusEffectTemplate st = value2 as StatusEffectTemplate;
					if (st != null)
					{
						HandleOverwriteWrap(delegate
						{
							st.Consume(st.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					ExhibitTemplate et = value2 as ExhibitTemplate;
					if (et != null)
					{
						HandleOverwriteWrap(delegate
						{
							et.Consume(et.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					JadeBoxTemplate jt = value2 as JadeBoxTemplate;
					if (jt != null)
					{
						HandleOverwriteWrap(delegate
						{
							jt.Consume(jt.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					EnemyUnitTemplate eut = value2 as EnemyUnitTemplate;
					if (eut != null)
					{
						HandleOverwriteWrap(delegate
						{
							eut.Consume(eut.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					UltimateSkillTemplate ust = value2 as UltimateSkillTemplate;
					if (ust != null)
					{
						HandleOverwriteWrap(delegate
						{
							ust.Consume(ust.LoadLocalization());
							UniqueTracker.Instance.ultimateSkillTemplates.TryAdd(ust.userAssembly, new Dictionary<string, UltimateSkillTemplate>());
							UniqueTracker.Instance.ultimateSkillTemplates[ust.userAssembly].AlwaysAdd((string)ust.GetId(), ust);
						}, value2, "LoadLocalization", value);
						continue;
					}
					UnitModelTemplate umT = value2 as UnitModelTemplate;
					if (umT != null)
					{
						HandleOverwriteWrap(delegate
						{
							umT.Consume(umT.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					PlayerUnitTemplate puT = value2 as PlayerUnitTemplate;
					if (puT != null)
					{
						HandleOverwriteWrap(delegate
						{
							puT.Consume(puT.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					SpellTemplate spT = value2 as SpellTemplate;
					if (spT != null)
					{
						HandleOverwriteWrap(delegate
						{
							spT.Consume(spT.LoadLocalization());
							UniqueTracker.Instance.spellTemplates.TryAdd(spT.userAssembly, new Dictionary<string, SpellTemplate>());
							UniqueTracker.Instance.spellTemplates[spT.userAssembly].AlwaysAdd((string)spT.GetId(), spT);
						}, value2, "LoadLocalization", value);
						continue;
					}
					IntentionTemplate it = value2 as IntentionTemplate;
					if (it != null)
					{
						HandleOverwriteWrap(delegate
						{
							it.Consume(it.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					PackTemplate pt = value2 as PackTemplate;
					if (pt != null)
					{
						HandleOverwriteWrap(delegate
						{
							pt.Consume(pt.LoadLocalization());
						}, value2, "LoadLocalization", value);
						continue;
					}
					AdventureTemplate at = value2 as AdventureTemplate;
					if (at != null)
					{
						HandleOverwriteWrap(delegate
						{
							at.Consume(at.LoadLocalization());
						}, value2, "LoadLocalization", value);
					}
				}
				if (UniqueTracker.Instance.typesToLocalize.ContainsKey(value.assembly))
				{
					foreach (KeyValuePair<Type, LocalizationInfo> item in UniqueTracker.Instance.typesToLocalize[value.assembly])
					{
						try
						{
							Type key = item.Key;
							LocalizationInfo value3 = item.Value;
							if (value3.locFiles == null)
							{
								Log.log.LogError((object)(value.assembly.GetName().Name + ": localization files parameter was never initialized for global localization option of " + key.Name));
								continue;
							}
							if (CollectionsExtensions.Empty<KeyValuePair<Locale, Func<YamlMappingNode>>>((IReadOnlyCollection<KeyValuePair<Locale, Func<YamlMappingNode>>>)value3.locFiles.locTable))
							{
								Log.log.LogError((object)(value.GUID + ": no files were given for global localization option of " + key.Name));
								continue;
							}
							Dictionary<string, Dictionary<string, object>> termDic = value3.locFiles.LoadLocTable(key, value3.entityLogicTypes.ToArray());
							LocalizationOption.FillLocalizationTables(termDic, key, value3.locFiles.mergeTerms);
						}
						catch (Exception ex)
						{
							log.LogError((object)ex);
						}
					}
				}
				if (UniqueTracker.Instance.unitNamesGlobalLocalizationFiles.TryGetValue(value.assembly, out var value4))
				{
					try
					{
						LocalizationOption.FillUnitNameTable(value4.Load(Localization.CurrentLocale), value4.mergeTerms, UniqueTracker.Instance.unitIdsToLocalize[value.assembly]);
					}
					catch (Exception ex2)
					{
						log.LogError((object)ex2);
					}
				}
				if (!UniqueTracker.Instance.batchLocalization.ContainsKey(value.assembly))
				{
					continue;
				}
				foreach (KeyValuePair<Type, HashSet<BatchLocalization>> item2 in UniqueTracker.Instance.batchLocalization[value.assembly])
				{
					if (item2.Key == typeof(SpellTemplate))
					{
						continue;
					}
					foreach (BatchLocalization item3 in item2.Value)
					{
						try
						{
							LocalizationFiles localizationFiles = item3.localizationFiles;
							if (item3.templateType == typeof(UnitModelTemplate) || item3.IsUnitNameSource)
							{
								Log.log.LogDebug((object)"unit model batch loc");
								LocalizationOption.FillUnitNameTable(localizationFiles.Load(Localization.CurrentLocale), localizationFiles.mergeTerms, item3.entityIds);
							}
							if (item3.templateType == typeof(PackTemplate))
							{
								PackTemplate.FillPacksLocTable(localizationFiles.LoadLocTable(item3.entityIds, addEmptyDic: false), localizationFiles.mergeTerms);
							}
							else
							{
								LocalizationOption.FillLocalizationTables(localizationFiles.LoadLocTable(item3.entityIds), item3.factoryType, localizationFiles.mergeTerms);
							}
						}
						catch (Exception ex3)
						{
							log.LogError((object)ex3);
						}
					}
				}
			}
		}

		internal void LoadAll(SideloaderUsers sideloaderUsers, string onRegistrationCompleteMsg = "All sideloader users registered!", string onCompleteMsg = "Finished loading custom resources.", bool loadLoc = true)
		{
			try
			{
				Instance.RegisterUsers(sideloaderUsers, onRegistrationCompleteMsg);
				Instance.LoadAssetsForResourceHelper(sideloaderUsers);
				if (loadLoc)
				{
					Instance.LoadLocalization(sideloaderUsers);
				}
			}
			catch (Exception ex)
			{
				log.LogError((object)ex);
			}
			log.LogInfo((object)onCompleteMsg);
		}

		internal void PostAllLoadProcessing()
		{
			foreach (KeyValuePair<Assembly, Dictionary<string, UltimateSkillTemplate>> ultimateSkillTemplate in UniqueTracker.Instance.ultimateSkillTemplates)
			{
				Assembly key = ultimateSkillTemplate.Key;
				Dictionary<string, UltimateSkillTemplate> value = ultimateSkillTemplate.Value;
				Dictionary<string, SpellTemplate> spellTemplates;
				List<UltimateSkillTemplate> list = ((!UniqueTracker.Instance.spellTemplates.TryGetValue(key, out spellTemplates)) ? value.Select((KeyValuePair<string, UltimateSkillTemplate> kv) => kv.Value).ToList() : (from kv in value
					where !spellTemplates.ContainsKey(kv.Key)
					select kv.Value).ToList());
				foreach (UltimateSkillTemplate item in list)
				{
					item.CreateSpellTemplate();
				}
			}
		}

		internal void DoForAllUsers(Action<UserInfo> action)
		{
			CollectionExtensions.Do<UserInfo>((IEnumerable<UserInfo>)sideloaderUsers.userInfos.Values, (Action<UserInfo>)delegate(UserInfo ui)
			{
				action(ui);
			});
			CollectionExtensions.Do<UserInfo>((IEnumerable<UserInfo>)secondaryUsers.userInfos.Values, (Action<UserInfo>)delegate(UserInfo ui)
			{
				action(ui);
			});
		}

		internal static bool HandleOverwriteWrap(Action action, EntityDefinition definition, string methodName, UserInfo user)
		{
			try
			{
				Type type = definition.GetType();
				if (!UniqueTracker.Instance.invalidRegistrations.Contains(type))
				{
					if (!user.IsForOverwriting(type))
					{
						action();
						return true;
					}
					if (TemplatesReflection.DoOverwrite(type, methodName) && !UniqueTracker.IsOverwriten(definition.TemplateType(), definition.UniqueId, methodName, type, user))
					{
						action();
						return true;
					}
				}
			}
			catch (Exception ex)
			{
				Log.log.LogError((object)$"Error while processing {definition.TemplateType().Name} {definition.GetType().Name}.{methodName}: {ex}");
			}
			return false;
		}
	}
	internal class HookPoints
	{
		[HarmonyPatch(typeof(GameEntry), "InitializeRestAsync")]
		[HarmonyPriority(800)]
		private class InitializeRestAsync_Patch
		{
			public static async void Postfix(Task __result)
			{
				await __result;
				EntityManager.Instance.LoadAll(EntityManager.Instance.sideloaderUsers, "All primary Sideloader users registered!", "Finished loading primary user resources", loadLoc: false);
				UniqueTracker.Instance.RaisePostMainLoad();
				EntityManager.Instance.LoadAll(EntityManager.Instance.secondaryUsers, "All secondary Sideloader users registered!", "Finished loading secondary user resources");
				CollectionExtensions.Do<Action>((IEnumerable<Action>)UniqueTracker.Instance.populateLoadoutInfosActions, (Action<Action>)delegate(Action a)
				{
					a();
				});
				EntityManager.Instance.addBossIconsActions.DoAll();
				EntityManager.Instance.PostAllLoadProcessing();
			}
		}

		[HarmonyPatch(typeof(CrossPlatformHelper), "SetWindowTitle")]
		[HarmonyPriority(800)]
		private class Localization_Patch
		{
			private static void Postfix()
			{
				try
				{
					log.LogDebug((object)"loc reload");
					EntityManager.Instance.LoadLocalization(EntityManager.Instance.sideloaderUsers);
					EntityManager.Instance.LoadLocalization(EntityManager.Instance.secondaryUsers);
				}
				catch (Exception ex)
				{
					log.LogWarning((object)ex);
				}
			}
		}

		[HarmonyPatch(typeof(GameDirector), "Awake")]
		[HarmonyPriority(800)]
		private class AddFormations_Patch
		{
			private static void Postfix()
			{
				EnemyGroupTemplate.LoadCustomFormations();
			}
		}

		[HarmonyPatch(typeof(Environment), "Awake")]
		[HarmonyPriority(800)]
		private class AddEnvironments_Patch
		{
			private static void Postfix()
			{
				StageTemplate.LoadCustomEnvironments();
			}
		}

		[HarmonyPatch(typeof(GameDirector), "InternalClearEnemies")]
		private class FormationsHotReload_Patch
		{
			private static void Postfix()
			{
				if (BepinexPlugin.doingMidRunReload > 0)
				{
					BepinexPlugin.doingMidRunReload--;
					EnemyGroupTemplate.ReloadFormations();
				}
			}
		}

		[HarmonyPatch]
		private class SpellPanelSpecialLoc_Patch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return ExtraAccess.InnerMoveNext(typeof(SpellPanel), "CustomLocalizationAsync");
			}

			private static void LoadLoc(SpellPanel spellPanel)
			{
				SpellTemplate.LoadAllSpecialLoc(spellPanel);
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0018: 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_003b: Expected O, but got Unknown
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Expected O, but got Unknown
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: 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
				FieldInfo fieldInfo = AccessTools.Field(typeof(SpellPanel), "_l10nTable");
				return new CodeMatcher(instructions, generator).End().MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Stfld, (object)fieldInfo)) }).Advance(-1)
					.MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Stfld, (object)fieldInfo)) })
					.Advance(1)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SpellPanelSpecialLoc_Patch), "LoadLoc", (Type[])null, (Type[])null))
					})
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldloc_1, (object)null)
					})
					.InstructionEnumeration();
			}
		}

		private class Loc_IntrusivePatch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return ExtraAccess.InnerMoveNext(typeof(L10nManager), "ReloadAsync");
			}

			private static void LoadLocWrap()
			{
				EntityManager.Instance.LoadLocalization(EntityManager.Instance.sideloaderUsers);
				EntityManager.Instance.LoadLocalization(EntityManager.Instance.secondaryUsers);
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				foreach (CodeInstruction ci in instructions)
				{
					if (ci.opcode == OpCodes.Call && (MethodInfo)ci.operand == AccessTools.Method(typeof(CrossPlatformHelper), "SetWindowTitle", (Type[])null, (Type[])null))
					{
						yield return ci;
						yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Loc_IntrusivePatch), "LoadLocWrap", (Type[])null, (Type[])null));
					}
					else
					{
						yield return ci;
					}
				}
			}
		}

		[HarmonyPatch]
		private class ReadVanillaConfigIds_Patch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				foreach (Type t in ConfigReflection.AllConfigTypes())
				{
					yield return AccessTools.Method(t, "Load", (Type[])null, (Type[])null);
				}
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
			{
				foreach (CodeInstruction ci in instructions)
				{
					if (CodeInstructionExtensions.Is(ci, OpCodes.Newobj, (MemberInfo)AccessTools.FirstConstructor(original.DeclaringType, (Func<ConstructorInfo, bool>)((ConstructorInfo c) => c.GetParameters().Count() > 0))))
					{
						yield return ci;
						yield return new CodeInstruction(OpCodes.Dup, (object)null);
						yield return new CodeInstruction(OpCodes.Ldc_I4_1, (object)null);
						yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(UniqueTracker), "TrackVanillaConfig", (Type[])null, (Type[])null));
					}
					else
					{
						yield return ci;
					}
				}
			}
		}

		private static readonly ManualLogSource log = BepinexPlugin.log;
	}
	public struct IdContainer : IEquatable<IdContainer>
	{
		public enum IdType
		{
			String,
			Int
		}

		private string sId;

		private int iId;

		public readonly IdType idType;

		public string SId
		{
			get
			{
				return sId;
			}
			set
			{
				sId = value;
			}
		}

		public int IId
		{
			get
			{
				return iId;
			}
			set
			{
				iId = value;
			}
		}

		public static implicit operator string(IdContainer id)
		{
			return id.sId;
		}

		public static implicit operator int(IdContainer id)
		{
			return id.iId;
		}

		public static implicit operator IdContainer(string s)
		{
			return new IdContainer(s);
		}

		public static implicit operator IdContainer(int i)
		{
			return new IdContainer(i);
		}

		public static IdContainer CastFromObject(object o)
		{
			if (o is string s)
			{
				return new IdContainer(s);
			}
			if (o is int i)
			{
				return new IdContainer(i);
			}
			throw new ArgumentException($"IdContainer: {o.GetType()} is not a valid type to cast from.");
		}

		public IdContainer(string s)
		{
			this = default(IdContainer);
			sId = s;
			idType = IdType.String;
		}

		public IdContainer(int i)
		{
			this = default(IdContainer);
			iId = i;
			idType = IdType.Int;
		}

		public static bool operator ==(IdContainer a, IdContainer b)
		{
			if (a.idType != b.idType)
			{
				throw new ArgumentException("Can't compare IdContainers of different types");
			}
			switch (a.idType)
			{
			case IdType.String:
				if (a.sId == null)
				{
					return false;
				}
				return a.sId.Equals(b.sId);
			case IdType.Int:
				return a.iId.Equals(b.iId);
			default:
				if (a.sId == null)
				{
					return false;
				}
				return a.sId.Equals(b.sId);
			}
		}

		public static bool operator !=(IdContainer a, IdContainer b)
		{
			if (a.idType != b.idType)
			{
				throw new ArgumentException("Can't compare IdContainers of different types");
			}
			switch (a.idType)
			{
			case IdType.String:
				if (a.sId == null)
				{
					return true;
				}
				return !a.sId.Equals(b.sId);
			case IdType.Int:
				return !a.iId.Equals(b.iId);
			default:
				if (a.sId == null)
				{
					return true;
				}
				return !a.sId.Equals(b.sId);
			}
		}

		public override bool Equals(object obj)
		{
			if ((object)this == obj)
			{
				return true;
			}
			if (obj == null)
			{
				return false;
			}
			return idType switch
			{
				IdType.String => sId.Equals(obj), 
				IdType.Int => iId.Equals(obj), 
				_ => sId.Equals(obj), 
			};
		}

		public override int GetHashCode()
		{
			switch (idType)
			{
			case IdType.String:
				if (sId == null)
				{
					return 0;
				}
				return sId.GetHashCode();
			case IdType.Int:
				return iId.GetHashCode();
			default:
				if (sId == null)
				{
					return 0;
				}
				return sId.GetHashCode();
			}
		}

		public override string ToString()
		{
			return idType switch
			{
				IdType.String => sId?.ToString(), 
				IdType.Int => iId.ToString(), 
				_ => sId?.ToString(), 
			};
		}

		public bool Equals(IdContainer other)
		{
			return this == other;
		}
	}
	internal static class Log
	{
		private static readonly ManualLogSource BePinExlogger = BepinexPlugin.log;

		public static ManualLogSource log => BePinExlogger;

		public static ManualLogSource LogDev()
		{
			if (BepinexPlugin.devModeConfig.Value)
			{
				return log;
			}
			return null;
		}

		public static ManualLogSource LogDevExtra()
		{
			if (BepinexPlugin.devModeConfig.Value && BepinexPlugin.devExtraLoggingConfig.Value)
			{
				return log;
			}
			return null;
		}
	}
	public class PluginInfo
	{
		public const string GUID = "neo.lbol.frameworks.entitySideloader";

		public const string description = "Entity Sideloader";

		public const string version = "1.0.1";

		public static readonly Harmony harmony = new Harmony("neo.lbol.frameworks.entitySideloader");
	}
	public class UserInfo
	{
		public string GUID;

		public Assembly assembly;

		public Dictionary<Type, EntityDefinition> definitionInstances = new Dictionary<Type, EntityDefinition>();

		public Dictionary<Type, List<EntityInfo>> entityInfos = new Dictionary<Type, List<EntityInfo>>();

		public Dictionary<Type, Type> definition2customEntityLogicType = new Dictionary<Type, Type>();

		public Dictionary<Type, ModificationInfo> entitiesToOverwrite = new Dictionary<Type, ModificationInfo>();

		public Dictionary<string, Type> typeName2VanillaType = new Dictionary<string, Type>();

		public bool IsForOverwriting(Type definitionType)
		{
			return entitiesToOverwrite.ContainsKey(definitionType);
		}
	}
	public class EntityInfo
	{
		public Type factoryType;

		public Type entityType;

		public Type definitionType;

		public Type originalType;

		public EntityInfo(Type factoryType, Type entityType, Type definitionType)
		{
			this.factoryType = factoryType;
			this.entityType = entityType;
			this.definitionType = definitionType;
		}
	}
	public class LocalizationInfo
	{
		public LocalizationFiles locFiles;

		public HashSet<Type> entityLogicTypes = new HashSet<Type>();
	}
	public class ModificationInfo
	{
		public OverwriteVanilla attribute;
	}
	public class OverwriteInfo
	{
		public IdContainer entityId;

		public string componentName;

		public Type defType;

		public UserInfo user;
	}
	internal class ScriptEngineWrapper
	{
		internal static void ReloadPlugins(BaseUnityPlugin scriptEngineInstance)
		{
			ScriptEngine val = (ScriptEngine)(object)((scriptEngineInstance is ScriptEngine) ? scriptEngineInstance : null);
			if (val != null)
			{
				val.ReloadPlugins();
			}
			else
			{
				BepinexPlugin.log.LogWarning((object)$"ScriptEngineWrapper: {scriptEngineInstance} is not an instance of scriptengine");
			}
		}
	}
	public class Sequence
	{
		private int counter = 0;

		public int Counter => counter;

		public Sequence(int startingPoint = 0)
		{
			counter = startingPoint;
		}

		public void SetCounter(int counter)
		{
			this.counter = counter;
		}

		public int Next()
		{
			return counter++;
		}
	}
	public class SideloaderUsers
	{
		public Dictionary<Assembly, UserInfo> userInfos = new Dictionary<Assembly, UserInfo>();

		public void AddUser(Assembly assembly)
		{
			if (userInfos.ContainsKey(assembly))
			{
				throw new Exception(assembly.GetName().Name + " is already registered");
			}
			try
			{
				userInfos.Add(assembly, EntityManager.ScanAssembly(assembly));
			}
			catch (Exception arg)
			{
				Log.log.LogError((object)$"{assembly.GetName().Name}: {arg}");
			}
		}

		public UserInfo GetDefinitionUser(EntityDefinition entityDefinition)
		{
			if (userInfos.TryGetValue(entityDefinition.userAssembly, out var value))
			{
				return value;
			}
			Log.log.LogWarning((object)(entityDefinition.userAssembly.GetName().Name + " was not found among registered users"));
			return null;
		}

		public static Type GetEntityLogicType(Assembly assembly, Type definitionType)
		{
			SideloaderUsers[] array = new SideloaderUsers[2]
			{
				EntityManager.Instance.sideloaderUsers,
				EntityManager.Instance.secondaryUsers
			};
			SideloaderUsers[] array2 = array;
			foreach (SideloaderUsers sideloaderUsers in array2)
			{
				if (!sideloaderUsers.userInfos.TryGetValue(assembly, out var value))
				{
					continue;
				}
				if (value.definition2customEntityLogicType.TryGetValue(definitionType, out var value2))
				{
					return value2;
				}
				if (value.IsForOverwriting(definitionType) && value.definitionInstances.TryGetValue(definitionType, out var value3))
				{
					FieldRef<object, Dictionary<string, Type>> val = TypeFactoryReflection.AccessTypeDicts(value3.EntityType(), TypeFactoryReflection.TableFieldName.TypeDict);
					if (val.Invoke((object)null).TryGetValue(value3.UniqueId, out var value4))
					{
						return value4;
					}
				}
			}
			Log.log.LogError((object)(definitionType.Name + " was not found in " + assembly.GetName().Name + " or " + definitionType.Name + " is not for overwriting"));
			return null;
		}
	}
	public class TemplateSequenceTable
	{
		private static readonly ManualLogSource log = BepinexPlugin.log;

		private static Dictionary<Type, string> lookUpDic = new Dictionary<Type, string>();

		private Dictionary<string, Sequence> table = new Dictionary<string, Sequence>();

		public TemplateSequenceTable(int startingPoint = 0)
		{
			if (CollectionsExtensions.Empty<KeyValuePair<Type, string>>((IReadOnlyCollection<KeyValuePair<Type, string>>)lookUpDic))
			{
				foreach (Type item in ConfigReflection.AllConfigTypes())
				{
					lookUpDic.Add(item, item.Name);
				}
				foreach (Type item2 in TemplatesReflection.AllTemplateTypes())
				{
					Type? type = item2.GetInterface("IConfigProvider`1");
					Type type2 = (((object)type != null) ? type.GenericTypeArguments[0] : null);
					if (type2 != null)
					{
						lookUpDic.Add(item2, type2.Name);
					}
					else
					{
						lookUpDic.Add(item2, item2.Name);
					}
				}
			}
			foreach (KeyValuePair<Type, string> item3 in lookUpDic)
			{
				table.TryAdd(item3.Value, new Sequence(startingPoint));
			}
		}

		public Sequence Sequence(Type type)
		{
			TestType(type);
			return table[lookUpDic[type]];
		}

		public int Next(Type type)
		{
			TestType(type);
			return table[lookUpDic[type]].Next();
		}

		private void TestType(Type type)
		{
			if (!TemplatesReflection.AllTemplateTypes().Contains(type) && !ConfigReflection.AllConfigTypes().Contains(type))
			{
				throw new ArgumentException($"TemplateSequenceTable: {type} is not a Entity definition template type or a Config type");
			}
			if (!lookUpDic.ContainsKey(type))
			{
				throw new ArgumentException($"TemplateSequenceTable: {type} is not in lookup dictionary. Some templates might not have an associated config type. Try using template type instead.");
			}
		}
	}
	public class UniqueTracker
	{
		public class DefTypePromisePair
		{
			public Type entityLogicType;

			public Func<Type> defTypePromise;
		}

		public class CharLoadoutInfo
		{
			public string ultimateSkill;

			public string exhibit;

			public List<string> deck;

			public int complexity;

			public string typeSuffix;

			public string typeName;
		}

		public class StageModAction
		{
			public string Id;

			public Func<Stage, Stage> mod;
		}

		private static readonly ManualLogSource log = BepinexPlugin.log;

		private static UniqueTracker _instance;

		public Dictionary<Type, HashSet<IdContainer>> configIds = new Dictionary<Type, HashSet<IdContainer>>();

		public Dictionary<Type, HashSet<int>> configIndexes = new Dictionary<Type, HashSet<int>>();

		public Dictionary<Type, IdContainer> entity2uniqueIds = new Dictionary<Type, IdContainer>();

		public Dictionary<Type, Dictionary<IdContainer, int>> id2ConfigListIndex = new Dictionary<Type, Dictionary<IdContainer, int>>();

		private TemplateSequenceTable tempConfigIndexTable = new TemplateSequenceTable();

		public HashSet<Type> invalidRegistrations = new HashSet<Type>();

		public Dictionary<Type, Dictionary<IdContainer, Dictionary<string, OverwriteInfo>>> overwriteTracker = new Dictionary<Type, Dictionary<IdContainer, Dictionary<string, OverwriteInfo>>>();

		public Dictionary<Assembly, List<Assembly>> generatedAssemblies = new Dictionary<Assembly, List<Assembly>>();

		public Dictionary<Assembly, Assembly> gen2User = new Dictionary<Assembly, Assembly>();

		public Dictionary<Assembly, Type> gen2FacType = new Dictionary<Assembly, Type>();

		public Dictionary<Assembly, Dictionary<Type, List<DefTypePromisePair>>> typePromiseDic = new Dictionary<Assembly, Dictionary<Type, List<DefTypePromisePair>>>();

		public Dictionary<Assembly, Dictionary<Type, LocalizationInfo>> typesToLocalize = new Dictionary<Assembly, Dictionary<Type, LocalizationInfo>>();

		public Dictionary<Assembly, Dictionary<Type, HashSet<BatchLocalization>>> batchLocalization = new Dictionary<Assembly, Dictionary<Type, HashSet<BatchLocalization>>>();

		public Dictionary<Assembly, LocalizationFiles> unitNamesGlobalLocalizationFiles = new Dictionary<Assembly, LocalizationFiles>();

		public Dictionary<Assembly, HashSet<IdContainer>> unitIdsToLocalize = new Dictionary<Assembly, HashSet<IdContainer>>();

		public Dictionary<Assembly, HashSet<LocalizationFiles>> spellEntriesLocFiles = new Dictionary<Assembly, HashSet<LocalizationFiles>>();

		public Dictionary<Assembly, HashSet<string>> spellIdsToLocalize = new Dictionary<Assembly, HashSet<string>>();

		public Dictionary<Assembly, Dictionary<string, SpellTemplate>> spellTemplates = new Dictionary<Assembly, Dictionary<string, SpellTemplate>>();

		public Dictionary<Assembly, Dictionary<string, UltimateSkillTemplate>> ultimateSkillTemplates = new Dictionary<Assembly, Dictionary<string, UltimateSkillTemplate>>();

		public Dictionary<string, MethodCache> methodCacheDic = new Dictionary<string, MethodCache>();

		public List<Action> formationAddActions = new List<Action>();

		public List<Action> environmentsAddActions = new List<Action>();

		public Dictionary<Assembly, Dictionary<string, GameObject>> createdEnvObjectCache = new Dictionary<Assembly, Dictionary<string, GameObject>>();

		public Dictionary<string, List<CharLoadoutInfo>> loadoutInfos = new Dictionary<string, List<CharLoadoutInfo>>();

		public List<Action> populateLoadoutInfosActions = new List<Action>();

		internal Dictionary<SaveDataID, CustomGameRunSaveData> customGrSaveData = new Dictionary<SaveDataID, CustomGameRunSaveData>();

		public List<Func<List<Stage>, List<Stage>>> modifyStageListFuncs = new List<Func<List<Stage>, List<Stage>>>();

		public List<StageModAction> modifyStageActions = new List<StageModAction>();

		public Dictionary<Assembly, List<PlayerUnitTemplate>> user2PlayerTemplates = new Dictionary<Assembly, List<PlayerUnitTemplate>>();

		public CHandlerManager cHandlerManager = new CHandlerManager();

		private Dictionary<string, Func<Intention, string>> intentionSuffixFuncs = null;

		private Sequence uIdSalt = new Sequence();

		private Sequence uIntId = new Sequence(1394);

		private TemplateSequenceTable indexTable = new TemplateSequenceTable(12000);

		public Dictionary<Type, int> entity2uniqueIndexes = new Dictionary<Type, int>();

		public Dictionary<Type, Dictionary<string, EntityDefinition>> onDemandResourceTracker = new Dictionary<Type, Dictionary<string, EntityDefinition>>();

		public static UniqueTracker Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new UniqueTracker();
					_instance.indexTable.Sequence(typeof(BgmConfig)).SetCounter(120);
					_instance.indexTable.Sequence(typeof(PlayerUnitConfig)).SetCounter(6);
					_instance.indexTable.Sequence(typeof(ExhibitConfig)).SetCounter(800);
				}
				return _instance;
			}
		}

		public Dictionary<string, Func<Intention, string>> IntentionSuffixFuncs
		{
			get
			{
				if (intentionSuffixFuncs == null)
				{
					intentionSuffixFuncs = (from d in EntityManager.Instance.AllUsers.Select(((Assembly ass, UserInfo userInfo) tu) => tu.userInfo).SelectMany((UserInfo ui) => ui.definitionInstances.Values)
						where d is IntentionTemplate
						select d).Cast<IntentionTemplate>().ToDictionary((Func<IntentionTemplate, string>)((IntentionTemplate it) => it.UniqueId.ToString()), (Func<IntentionTemplate, Func<Intention, string>>)((IntentionTemplate it) => it.SelectAltIconsSuffix));
				}
				return intentionSuffixFuncs;
			}
		}

		internal event Action PostMainLoad;

		internal static void DestroySelf()
		{
			_instance = null;
		}

		public void RaisePostMainLoad()
		{
			if (this.PostMainLoad == null)
			{
				ManualLogSource obj = Log.LogDev();
				if (obj != null)
				{
					obj.LogInfo((object)"No template generation was queued.");
				}
				return;
			}
			this.PostMainLoad();
			generatedAssemblies.Values.ToList().ForEach(delegate(List<Assembly> l)
			{
				l.ForEach(delegate(Assembly a)
				{
					EntityManager.Instance.secondaryUsers.AddUser(a);
				});
			});
			foreach (KeyValuePair<Assembly, Assembly> item in gen2User)
			{
				if (!gen2FacType.TryGetValue(item.Key, out var value) || !typePromiseDic.TryGetValue(item.Value, out var value2))
				{
					continue;
				}
				foreach (DefTypePromisePair item2 in value2[value])
				{
					Type type = item2.defTypePromise();
					EntityInfo entityInfo = new EntityInfo(value, item2.entityLogicType, type);
					UserInfo userInfo = EntityManager.Instance.secondaryUsers.userInfos[item.Key];
					userInfo.entityInfos.TryAdd(value, new List<EntityInfo>());
					userInfo.entityInfos[value].Add(entityInfo);
					userInfo.definition2customEntityLogicType.Add(type, entityInfo.entityType);
				}
			}
		}

		public bool IsLoadedOnDemand(Type templateType, string Id, out EntityDefinition entityDefinition)
		{
			entityDefinition = null;
			onDemandResourceTracker.TryGetValue(templateType, out var value);
			return value?.TryGetValue(Id, out entityDefinition) ?? false;
		}

		public bool AddOnDemandResource(Type templateType, string Id, EntityDefinition definition)
		{
			onDemandResourceTracker.TryAdd(templateType, new Dictionary<string, EntityDefinition>());
			return onDemandResourceTracker[templateType].TryAdd(Id, definition);
		}

		public static bool IsOverwriten(Type templateType, IdContainer id, string component, Type definitionType, UserInfo user)
		{
			Instance.overwriteTracker.TryAdd(templateType, new Dictionary<IdContainer, Dictionary<string, OverwriteInfo>>());
			Dictionary<IdContainer, Dictionary<string, OverwriteInfo>> dictionary = Instance.overwriteTracker[templateType];
			if (dictionary.TryGetValue(id, out var value))
			{
				if (value.TryGetValue(component, out var value2))
				{
					if (!value2.defType.Equals(definitionType))
					{
						log.LogError((object)$"{user.assembly.GetName().Name} definition {definitionType.Name} is trying to change {component} of {id} but it's already modified by {value2.user.assembly.GetName().Name} definition {value2.defType.Name}.");
						return true;
					}
					return false;
				}
				value.Add(component, new OverwriteInfo
				{
					defType = definitionType,
					user = user
				});
				return false;
			}
			dictionary.Add(id, new Dictionary<string, OverwriteInfo>());
			dictionary[id].Add(component, new OverwriteInfo
			{
				defType = definitionType,
				user = user
			});
			return false;
		}

		internal static void TrackVanillaConfig(object config, bool allowDuplicateIndex = false)
		{
			Instance.configIds.TryAdd(config.GetType(), new HashSet<IdContainer>());
			HashSet<IdContainer> hashSet = Instance.configIds[config.GetType()];
			FieldInfo idField = ConfigReflection.GetIdField(config.GetType());
			IdContainer idContainer = IdContainer.CastFromObject(idField.GetValue(config));
			if (hashSet.Contains(idContainer))
			{
				log.LogDebug((object)idContainer);
				log.LogWarning((object)$"duplicate id: {idContainer} in {config.GetType()}");
			}
			else
			{
				hashSet.Add(idContainer);
			}
			FieldInfo fieldInfo = ConfigReflection.HasIndex(config.GetType());
			if (fieldInfo != null)
			{
				Instance.configIndexes.TryAdd(config.GetType(), new HashSet<int>());
				Instance.configIndexes.TryGetValue(config.GetType(), out var value);
				int num = (int)fieldInfo.GetValue(config);
				if (value.Contains(num) && !allowDuplicateIndex)
				{
					log.LogDebug((object)$"index: {num}");
					log.LogWarning((object)$"duplicate id: {num} in {config.GetType()}");
				}
				else
				{
					value.Add(num);
				}
			}
			Instance.id2ConfigListIndex.TryAdd(config.GetType(), new Dictionary<IdContainer, int>());
			Instance.id2ConfigListIndex[config.GetType()].Add(idContainer, Instance.tempConfigIndexTable.Next(config.GetType()));
		}

		public static IdContainer GetUniqueId(IdContainer id)
		{
			throw new NotImplementedException();
		}

		public static IdContainer GetUniqueId(EntityDefinition entityDefinition)
		{
			if (Instance.entity2uniqueIds.TryGetValue(entityDefinition.GetType(), out var value))
			{
				return value;
			}
			return entityDefinition.GetId();
		}

		internal static void AddUniqueId(EntityDefinition entityDefinition, UserInfo userInfo)
		{
			IdContainer id = entityDefinition.GetId();
			Type key = entityDefinition.ConfigType();
			Instance.configIds.TryAdd(key, new HashSet<IdContainer>());
			HashSet<IdContainer> hashSet = Instance.configIds[key];
			if (hashSet.Contains(id))
			{
				throw new NotImplementedException($"Uniquefying ids is not supported yet. {userInfo.GUID} is trying to register {entityDefinition.TemplateType().Name} id {id} which already used by either vanilla entities or other mods.");
			}
			hashSet.Add(id);
		}

		internal static IdContainer MakeUniqueId(IdContainer id, EntityDefinition entityDefinition, UserInfo userInfo)
		{
			if (id.idType == IdContainer.IdType.String)
			{
				string text = userInfo.GUID + id;
				if (Instance.configIds[entityDefinition.ConfigType()].Contains(text))
				{
					text += Instance.uIdSalt.Next();
				}
				return text;
			}
			if (id.idType == IdContainer.IdType.Int)
			{
				throw new NotImplementedException();
			}
			throw new NotImplementedException();
		}

		internal static int AddUniqueIndex(int index, EntityDefinition entityDefinition)
		{
			int num = Instance.indexTable.Sequence(entityDefinition.ConfigType()).Counter;
			HashSet<int> hashSet = Instance.configIndexes[entityDefinition.ConfigType()];
			while (hashSet.Contains(index + num))
			{
				num = Instance.indexTable.Next(entityDefinition.ConfigType());
			}
			hashSet.Add(index + num);
			return index + num;
		}
	}
}
namespace LBoLEntitySideloader.Utils
{
	public static class AssemblyExtensions
	{
		public static bool IsLoadedFromDisk(this Assembly assembly)
		{
			return !assembly.IsDynamic && !string.IsNullOrEmpty(assembly.Location);
		}
	}
	public static class GameObjectExtensions
	{
		public static IEnumerable<GameObject> IterateHierarchy(this Transform root)
		{
			Queue<Transform> queue = new Queue<Transform>();
			queue.Enqueue(root);
			while (queue.Count > 0)
			{
				Transform current = queue.Dequeue();
				yield return ((Component)current).gameObject;
				foreach (Transform item in current)
				{
					Transform child = item;
					queue.Enqueue(child);
				}
			}
		}

		public static T JankyCopyComponent<T>(this GameObject destination, T original) where T : Component
		{
			Type type = ((object)original).GetType();
			Component val = destination.AddComponent(type);
			BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			FieldInfo[] fields = type.GetFields(bindingAttr);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (!propertyInfo.CanWrite)
				{
					continue;
				}
				try
				{
					propertyInfo.SetValue(val, propertyInfo.GetValue(original, null), null);
				}
				catch (Exception ex)
				{
					ManualLogSource obj = Log.LogDev();
					if (obj != null)
					{
						obj.LogWarning((object)$"Exception while copying  gameObject {((Object)destination).name}, component {typeof(T)}, property {propertyInfo.Name}: {ex}");
					}
				}
			}
			FieldInfo[] array2 = fields;
			foreach (FieldInfo fieldInfo in array2)
			{
				fieldInfo.SetValue(val, fieldInfo.GetValue(original));
			}
			return (T)(object)((val is T) ? val : null);
		}
	}
	public static class Numbers
	{
		public static string DecimalToABC(long decimalNumber, int radix = 26)
		{
			if (radix < 2 || radix > "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Length)
			{
				throw new ArgumentException("The radix must be >= 2 and <= " + "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Length);
			}
			if (decimalNumber == 0)
			{
				return "0";
			}
			int num = 63;
			long num2 = Math.Abs(decimalNumber);
			char[] array = new char[64];
			while (num2 != 0)
			{
				int index = (int)(num2 % radix);
				array[num--] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[index];
				num2 /= radix;
			}
			string text = new string(array, num + 1, 64 - num - 1);
			if (decimalNumber < 0)
			{
				text = "-" + text;
			}
			return text;
		}
	}
	public static class ObjectExtensions
	{
		private static readonly MethodInfo CloneMethod = typeof(object).GetMethod("MemberwiseClone", BindingFlags.Instance | BindingFlags.NonPublic);

		public static bool IsPrimitive(this Type type)
		{
			if (type == typeof(string))
			{
				return true;
			}
			return type.IsValueType & type.IsPrimitive;
		}

		public static object Copy(this object originalObject)
		{
			return InternalCopy(originalObject, new Dictionary<object, object>(new ReferenceEqualityComparer()));
		}

		private static object InternalCopy(object originalObject, IDictionary<object, object> visited)
		{
			if (originalObject == null)
			{
				return null;
			}
			Type type = originalObject.GetType();
			if (type.IsPrimitive())
			{
				return originalObject;
			}
			if (visited.ContainsKey(originalObject))
			{
				return visited[originalObject];
			}
			if (typeof(Delegate).IsAssignableFrom(type))
			{
				return null;
			}
			object obj = CloneMethod.Invoke(originalObject, null);
			if (type.IsArray)
			{
				Type elementType = type.GetElementType();
				if (!elementType.IsPrimitive())
				{
					Array clonedArray = (Array)obj;
					clonedArray.ForEach(delegate(Array array, int[] indices)
					{
						array.SetValue(InternalCopy(clonedArray.GetValue(indices), visited), indices);
					});
				}
			}
			visited.Add(originalObject, obj);
			CopyFields(originalObject, visited, obj, type);
			RecursiveCopyBaseTypePrivateFields(originalObject, visited, obj, type);
			return obj;
		}

		private static void RecursiveCopyBaseTypePrivateFields(object originalObject, IDictionary<object, object> visited, object cloneObject, Type typeToReflect)
		{
			if (typeToReflect.BaseType != null)
			{
				RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect.BaseType);
				CopyFields(originalObject, visited, cloneObject, typeToReflect.BaseType, BindingFlags.Instance | BindingFlags.NonPublic, (FieldInfo info) => info.IsPrivate);
			}
		}

		private static void CopyFields(object originalObject, IDictionary<object, object> visited, object cloneObject, Type typeToReflect, BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy, Func<FieldInfo, bool> filter = null)
		{
			FieldInfo[] fields = typeToReflect.GetFields(bindingFlags);
			foreach (FieldInfo fieldInfo in fields)
			{
				if ((filter == null || filter(fieldInfo)) && !fieldInfo.FieldType.IsPrimitive())
				{
					object value = fieldInfo.GetValue(originalObject);
					object value2 = InternalCopy(value, visited);
					fieldInfo.SetValue(cloneObject, value2);
				}
			}
		}

		public static T Copy<T>(this T original)
		{
			return (T)((object)original).Copy();
		}
	}
	public class ReferenceEqualityComparer : EqualityComparer<object>
	{
		public override bool Equals(object x, object y)
		{
			return x == y;
		}

		public override int GetHashCode(object obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
}
namespace LBoLEntitySideloader.Utils.ArrayExtensions
{
	public static class ArrayExtensions
	{
		public static void ForEach(this Array array, Action<Array, int[]> action)
		{
			if (array.LongLength != 0)
			{
				ArrayTraverse arrayTraverse = new ArrayTraverse(array);
				do
				{
					action(array, arrayTraverse.Position);
				}
				while (arrayTraverse.Step());
			}
		}
	}
	internal class ArrayTraverse
	{
		public int[] Position;

		private int[] maxLengths;

		public ArrayTraverse(Array array)
		{
			maxLengths = new int[array.Rank];
			for (int i = 0; i < array.Rank; i++)
			{
				maxLengths[i] = array.GetLength(i) - 1;
			}
			Position = new int[array.Rank];
		}

		public bool Step()
		{
			for (int i = 0; i < Position.Length; i++)
			{
				if (Position[i] < maxLengths[i])
				{
					Position[i]++;
					for (int j = 0; j < i; j++)
					{
						Position[j] = 0;
					}
					return true;
				}
			}
			return false;
		}
	}
}
namespace LBoLEntitySideloader.Utils.EnumExtender
{
	[HarmonyPatch]
	internal static class EnumInfoPatch
	{
		static EnumInfoPatch()
		{
		}

		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(Type.GetType("System.Enum"), "GetCachedValuesAndNames", (Type[])null, (Type[])null);
		}

		private static void FixEnum(object type, ref ulong[] oldValues, ref string[] oldNames)
		{
			Type enumType = type as Type;
			if (!EnumPatcher.TryGetRawPatch(enumType, out var patch))
			{
				return;
			}
			List<KeyValuePair<ulong, string>> pairs = patch.GetPairs();
			List<ulong> list = new List<ulong>(oldValues);
			List<string> list2 = new List<string>(oldNames);
			foreach (KeyValuePair<ulong, string> item in pairs)
			{
				list.Add(item.Key);
				list2.Add(item.Value);
			}
			oldValues = list.ToArray();
			oldNames = list2.ToArray();
			Array.Sort(oldValues, oldNames, Comparer<ulong>.Default);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			using IEnumerator<CodeInstruction> enumerator = instructions.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CodeInstruction v = enumerator.Current;
				object operand = v.operand;
				if (operand is MethodInfo me && me.Name == "Sort")
				{
					yield return v;
					enumerator.MoveNext();
					v = enumerator.Current;
					List<Label> labels = v.labels;
					v.labels = new List<Label>();
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null)
					{
						labels = labels
					};
					yield return new CodeInstruction(OpCodes.Ldloca, (object)1);
					yield return new CodeInstruction(OpCodes.Ldloca, (object)2);
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EnumInfoPatch), "FixEnum", (Type[])null, (Type[])null));
					yield return v;
				}
				else
				{
					yield return v;
				}
			}
		}
	}
	public static class EnumPatcher
	{
		public delegate object AlternateEnumRegister(object value, string name);

		public class EnumPatch
		{
			private Dictionary<ulong, List<string>> values = new Dictionary<ulong, List<string>>();

			public void AddValue(ulong enumValue, string name)
			{
				if (values.ContainsKey(enumValue))
				{
					values[enumValue].Add(name);
					return;
				}
				values.Add(enumValue, new List<string> { name });
			}

			public List<KeyValuePair<ulong, string>> GetPairs()
			{
				List<KeyValuePair<ulong, string>> list = new List<KeyValuePair<ulong, string>>();
				foreach (KeyValuePair<ulong, List<string>> value in values)
				{
					foreach (string item in value.Value)
					{
						list.Add(new KeyValuePair<ulong, string>(value.Key, item));
					}
				}
				return list;
			}

			public bool HasName(string name)
			{
				foreach (string item in values.Values.SelectMany((List<string> l) => l))
				{
					if (name.Equals(item))
					{
						return true;
					}
				}
				return false;
			}
		}

		private static readonly Dictionary<Type, AlternateEnumRegister> BANNED_ENUMS;

		private static FieldInfo cache;

		private static Dictionary<Type, EnumPatch> patches;

		public static void RegisterAlternate<TEnum>(AlternateEnumRegister del) where TEnum : Enum
		{
			RegisterAlternate(typeof(TEnum), del);
		}

		public static void RegisterAlternate(Type type, AlternateEnumRegister del)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!type.IsEnum)
			{
				throw new Exception($"The given type {type} isn't an enum");
			}
			BANNED_ENUMS.Add(type, del);
		}

		static EnumPatcher()
		{
			BANNED_ENUMS = new Dictionary<Type, AlternateEnumRegister>();
			patches = new Dictionary<Type, EnumPatch>();
			Type type = AccessTools.TypeByName("System.RuntimeType");
			cache = AccessTools.Field(type, "GenericCache");
		}

		public static TEnum AddEnumValue<TEnum>(string name) where TEnum : Enum
		{
			return (TEnum)AddEnumValue(typeof(TEnum), name);
		}

		public static object AddEnumValue(Type enumType, string name)
		{
			object firstFreeValue = GetFirstFreeValue(enumType);
			AddEnumValue(enumType, firstFreeValue, name);
			return firstFreeValue;
		}

		public static void AddEnumValue<T>(object value, string name)
		{
			AddEnumValue(typeof(T), value, name);
		}

		public static void AddEnumValue(Type enumType, object value, string name)
		{
			if (enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			if (!enumType.IsEnum)
			{
				throw new Exception($"{enumType} is not a valid Enum!");
			}
			if (AlreadyHasName(enumType, name) || EnumUtils.HasEnumValue(enumType, name))
			{
				throw new Exception("The enum (" + enumType.FullName + ") already has a value with the name \"" + name + "\"");
			}
			value = (ulong)Convert.ToInt64(value, CultureInfo.InvariantCulture);
			if (!patches.TryGetValue(enumType, out var value2))
			{
				value2 = new EnumPatch();
				patches.Add(enumType, value2);
			}
			ClearEnumCache(enumType);
			value2.AddValue((ulong)value, name);
		}

		public static void AddEnumValueWithAlternatives<TEnum>(object value, string name) where TEnum : Enum
		{
			AddEnumValueWithAlternatives(typeof(TEnum), value, name);
		}

		public static void AddEnumValueWithAlternatives(Type enumType, object value, string name)
		{
			if (BANNED_ENUMS.TryGetValue(enumType, out var value2))
			{
				value2(value, name);
			}
			else
			{
				AddEnumValue(enumType, value, name);
			}
		}

		internal static bool TryAsNumber(this object value, Type type, out object result)
		{
			if (type.IsSubclassOf(typeof(IConvertible)))
			{
				throw new ArgumentException("The type must inherit the IConvertible interface", "type");
			}
			result = null;
			if (type.IsInstanceOfType(value))
			{
				result = value;
				return true;
			}
			if (value is IConvertible)
			{
				if (type.IsEnum)
				{
					result = Enum.ToObject(type, value);
					return true;
				}
				NumberFormatInfo currentInfo = NumberFormatInfo.CurrentInfo;
				result = (value as IConvertible).ToType(type, currentInfo);
				return true;
			}
			return false;
		}

		public static TEnum GetFirstFreeValue<TEnum>()
		{
			return (TEnum)GetFirstFreeValue(typeof(TEnum));
		}

		public static object GetFirstFreeValue(Type enumType)
		{
			if (!enumType.IsEnum)
			{
				throw new ArgumentException("enumType");
			}
			if (enumType == null)
			{
				throw new ArgumentNullException("enumType");
			}
			if (!enumType.IsEnum)
			{
				throw new Exception($"{enumType} is not a valid Enum!");
			}
			Array values = Enum.GetValues(enumType);
			long num = 0L;
			object result;
			for (ulong num2 = 0uL; num2 <= ulong.MaxValue && num2.TryAsNumber(enumType, out result); num2++)
			{
				while (true)
				{
					if (num < values.Length)
					{
						if (values.GetValue(num).Equals(result))
						{
							break;
						}
						num++;
						continue;
					}
					return result;
				}
			}
			long num3 = -1L;
			object result2;
			while (num3 >= long.MinValue && num3.TryAsNumber(enumType, out result2))
			{
				while (true)
				{
					if (num < values.Length)
					{
						if (values.GetValue(num).Equals(result2))
						{
							break;
						}
						num++;
						continue;
					}
					return result2;
				}
				num3--;
			}
			throw new Exception("No unused values in enum " + enumType.FullName);
		}

		public static void ClearEnumCache(Type enumType)
		{
			cache.SetValue(enumType, null);
		}

		internal static bool TryGetRawPatch(Type enumType, out EnumPatch patch)
		{
			return patches.TryGetValue(enumType, out patch);
		}

		internal static bool AlreadyHasName(Type enumType, string name)
		{
			if (TryGetRawPatch(enumType, out var patch))
			{
				return patch.HasName(name);
			}
			return false;
		}
	}
	public static class EnumUtils
	{
		public static object Parse(Type enumType, string value)
		{
			if (!enumType.IsEnum)
			{
				throw new Exception("The given type isn't an enum (" + enumType.FullName + " isn't an Enum)");
			}
			try
			{
				return Enum.Parse(enumType, value);
			}
			catch
			{
				return null;
			}
		}

		public static object Parse(Type enumType, string value, bool ignoreCase)
		{
			if (!enumType.IsEnum)
			{
				throw new Exception("The given type isn't an enum (" + enumType.FullName + " isn't an Enum)");
			}
			try
			{
				return Enum.Parse(enumType, value, ignoreCase);
			}
			catch
			{
				return null;
			}
		}

		public static object FromInt(Type enumType, int value)
		{
			if (!enumType.IsEnum)
			{
				throw new Exception("The given type isn't an enum (" + enumType.FullName + " isn't an Enum)");
			}
			return Enum.ToObject(enumType, value);
		}

		public static string[] GetAllNames(Type enumType)
		{
			if (!enumType.IsEnum)
			{
				throw new Exception("The given type isn't an enum (" + enumType.FullName + " isn't an Enum)");
			}
			return Enum.GetNames(enumType);
		}

		public static object[] GetAll(Type enumType)
		{
			List<object> list = new List<object>();
			string[] allNames = GetAllNames(enumType);
			foreach (string value in allNames)
			{
				object obj = Parse(enumType, value);
				if (obj != null)
				{
					list.Add(obj);
				}
			}
			return list.ToArray();
		}

		public static bool IsDefined(Type enumType, string value)
		{
			try
			{
				return Enum.IsDefined(enumType, value);
			}
			catch
			{
				return false;
			}
		}

		public static bool HasEnumValue(Type enumType, string value)
		{
			string[] allNames = GetAllNames(enumType);
			foreach (string text in allNames)
			{
				if (text.Equals(value))
				{
					return true;
				}
			}
			return false;
		}

		public static object GetMinValue(Type enumType)
		{
			return GetAll(enumType).Cast<int>().Min();
		}

		public static object GetMaxValue(Type enumType)
		{
			return GetAll(enumType).Cast<int>().Max();
		}

		public static T Parse<T>(string value, T errorReturn = default(T)) where T : Enum
		{
			try
			{
				return (T)Enum.Parse(typeof(T), value);
			}
			catch
			{
				return errorReturn;
			}
		}

		public static T Parse<T>(string value, bool ignoreCase, T errorReturn = default(T)) where T : Enum
		{
			try
			{
				return (T)Enum.Parse(typeof(T), value, ignoreCase);
			}
			catch
			{
				return errorReturn;
			}
		}

		public static T FromInt<T>(int value) where T : Enum
		{
			return (T)Enum.ToObject(typeof(T), value);
		}

		public static string[] GetAllNames<T>() where T : Enum
		{
			return Enum.GetNames(typeof(T));
		}

		public static T[] GetAll<T>(T errorReturn = default(T)) where T : Enum
		{
			List<T> list = new List<T>();
			string[] allNames = GetAllNames<T>();
			foreach (string value in allNames)
			{
				list.Add(Parse(value, errorReturn));
			}
			return list.ToArray();
		}

		public static bool IsDefined<T>(string value) where T : Enum
		{
			try
			{
				return Enum.IsDefined(typeof(T), value);
			}
			catch
			{
				return false;
			}
		}

		public static bool HasEnumValue<T>(string value) where T : Enum
		{
			string[] allNames = GetAllNames<T>();
			foreach (string text in allNames)
			{
				if (text.Equals(value))
				{
					return true;
				}
			}
			return false;
		}

		public static T GetMinValue<T>() where T : Enum
		{
			return GetAll(default(T)).Min();
		}

		public static T GetMaxValue<T>() where T : Enum
		{
			return GetAll(default(T)).Max();
		}
	}
}
namespace LBoLEntitySideloader.UIhelpers
{
	public static class Extensions
	{
		public static void KeepPositionAfterAction(this Transform transform, Action action, bool outputDebug = false)
		{
			//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_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_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_0037: 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_0053: 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_00ce: 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_0093: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = transform.position;
			Quaternion rotation = transform.rotation;
			Vector3 localScale = transform.localScale;
			if (outputDebug)
			{
				Debug.Log((object)$"{((Object)((Component)transform).gameObject).name} before pos :{transform.position}, rot: {transform.rotation}, scale: {transform.localScale}");
			}
			action();
			if (outputDebug)
			{
				Debug.Log((object)$"{((Object)((Component)transform).gameObject).name} after pos :{transform.position}, rot: {transform.rotation}, scale: {transform.localScale}");
			}
			transform.position = position;
			transform.rotation = rotation;
			transform.localScale = localScale;
		}
	}
}
namespace LBoLEntitySideloader.UIAdditions.StartGameUI
{
	[HarmonyPatch(typeof(StartGamePanel))]
	internal class StartGameUI_Patches
	{
		[HarmonyPatch("RefreshConfirm")]
		[HarmonyPostfix]
		private static void UnlockCharacter(StartGamePanel __instance)
		{
			if (__instance._playerIndex >= 0 && __instance._playerIndex <= __instance._players.Count && __instance._players[__instance._playerIndex].Config.UnlockLevel.HasValue)
			{
				__instance.characterHintRoot.gameObject.SetActive(false);
				((TMP_Text)__instance.characterHint).text = "";
				((Selectable)__instance.characterConfirmButton).interactable = true;
			}
		}

		[HarmonyPatch("RefreshDifficultyConfirm")]
		[HarmonyPostfix]
		private static void UnlockDifficulty(StartGamePanel __instance)
		{
			if (!__instance.gameModeSwitch.IsOn)
			{
				__instance.difficultyGroups[__instance._difficultyIndex].SetLocked(false);
				__instance._isDifficultyLock = false;
				((Selectable)__instance.difficultyConfirmButton).interactable = true;
				__instance._confirmTooltip.SetDirect("", (string)null);
			}
		}

		[HarmonyPatch("SetPuzzleStatus")]
		[HarmonyPostfix]
		private static void UnlockRequests(StartGamePanel __instance)
		{
			for (int i = 0; i < PuzzleFlags.AllPuzzleFlags.Count; i++)
			{
				foreach (PuzzleToggleWidget value in __instance._puzzleToggles.Values)
				{
					value.IsLock = false;
				}
			}
			__instance.puzzleSelectAllGroup.SetActive(true);
		}

		[HarmonyPatch("SetJadeBoxStatus")]
		[HarmonyPostfix]
		private static void UnlockJadeboxes(StartGamePanel __instance)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			((Selectable)__instance.jadeBoxButton).interactable = true;
			((Behaviour)__instance._jadeBoxTooltip).enabled = false;
			((Component)__instance.jadeBoxLockImage).gameObject.SetActive(false);
			((Graphic)__instance.jadeBoxText).color = Color.white;
		}
	}
}
namespace LBoLEntitySideloader.UIAdditions.CardUIAdds
{
	public static class CardUiExtensions
	{
		public static BattleActionViewer<T> BAV_DelegateWrap<T>(Func<T, CardUi, IEnumerator> viewer, CardUi cardUi) where T : BattleAction
		{
			return (T action) => viewer(action, cardUi);
		}

		public static BattleActionViewer<AddCardsToExileAction> AddCardsToExileViewer(CardUi cardUi)
		{
			return CardUiExtensions.BAV_DelegateWrap<AddCardsToExileAction>((Func<AddCardsToExileAction, CardUi, IEnumerator>)ViewAddCardsToExile, cardUi);
		}

		public static IEnumerator ViewAddCardsToExile(AddCardsToExileAction action, CardUi cardUi)
		{
			float interval = 0.05f;
			Vector3? vector = cardUi._playBoard.FindActionSourceWorldPosition(((BattleAction)action).Source);
			List<Card> list2 = ((EventBattleAction<CardsEventArgs>)(object)action).Args.Cards.ToList();
			List<CardWidget> list3 = new List<CardWidget>();
			Vector3 localPosition = cardUi.ExileLocalPosition;
			Vector3 endPosition = cardUi.ExileLocalPosition;
			Sequence val = DOTween.Sequence();
			int count = list2.Count;
			if (count > 5)
			{
				Debug.LogWarning((object)"Adding 5+ cards in one time, which may cause presentation weired.");
			}
			AudioManager.PlayUi("CardAppear", false);
			for (int i = 0; i < count; i++)
			{
				Card card = list2[i];
				CardWidget cardWidget = cardUi.CreateCardWidget(card, (Transform)(object)cardUi._rectTransform);
				list3.Add(cardWidget);
				Transform transform = ((Component)cardWidget).transform;
				if (vector.HasValue)
				{
					transform.position = vector.GetValueOrDefault();
				}
				else
				{
					transform.localPosition = localPosition;
				}
				((Component)cardWidget).gameObject.SetActive(false);
				transform.localScale = new Vector3(0.2f, 0.2f);
				float num = interval * (float)i;
				TweenSettingsExtensions.InsertCallback(val, num, (TweenCallback)delegate
				{
					((Component)cardWidget).gameObject.SetActive(true);
				});
				TweenSettingsExtensions.SetEase<Sequence>(TweenSettingsExtensions.Insert(val, num, (Tween)ShortcutExtensions.DOLocalMove(transform, new Vector3(600f * ((float)i - (float)(count - 1) / 2f), 0f), 0.3f, false)), (Ease)3);
				TweenSettingsExtensions.Insert(val, num, (Tween)ShortcutExtensions.DOScale(transform, Vector3.one, 0.3f));
			}
			yield return TweenExtensions.WaitForCompletion((Tween)TweenSettingsExtensions.SetUpdate<Sequence>(TweenSettingsExtensions.AppendInterval(val, 0.3f), true));
			cardUi.RefreshAll();
			((MonoBehaviour)cardUi).StartCoroutine(EndRunner(cardUi));
			IEnumerator EndRunner(CardUi val3)
			{
				AudioManager.PlayUi("CardFly", false);
				Sequence val2 = DOTween.Sequence();
				List<Transform> parents = new List<Transform>();
				foreach (var item3 in CollectionsExtensions.WithIndices<CardWidget>((IEnumerable<CardWidget>)list3))
				{
					int item4 = item3.Item1;
					CardWidget item5 = item3.Item2;
					float num2 = interval * (float)item4;
					Transform transform2 = ((Component)item5).transform;
					Transform transform3 = Object.Instantiate<Transform>(val3.cardFlyHelperPrefab, val3.cardEffectLayer);
					parents.Add(transform3);
					transform3.localPosition = transform2.localPosition;
					transform2.SetParent(transform3);
					GameObject gameObject = Object.Instantiate<GameObject>(val3.cardFlyTrail, transform3);
					TweenSettingsExtensions.Insert(val2, num2, (Tween)TweenSettingsExtensions.SetEase<TweenerCore<Vector3, Vector3, VectorOptions>>(ShortcutExtensions.DOLocalMove(transform3, endPosition, 0.4f, false), (Ease)2));
					TweenSettingsExtensions.Insert(val2, num2, (Tween)ShortcutExtensions.DOLocalRotate(transform2, new Vector3(0f, 0f, -500f), 0.2f, (RotateMode)1));
					TweenSettingsExtensions.Insert(val2, num2, (Tween)ShortcutExtensions.DOScale(transform2, new Vector3(0.2f, 0.2f, 1f), 0.2f));
					int num3 = Random.Range(200, 400);
					TweenSettingsExtensions.Insert(val2, num2, (Tween)TweenSettingsExtensions.SetLoops<TweenerCore<Vector3, Vector3, VectorOptions>>(TweenSettingsExtensions.SetRelative<TweenerCore<Vector3, Vector3, VectorOptions>>(TweenSettingsExtensions.SetEase<TweenerCore<Vector3, Vector3, VectorOptions>>(ShortcutExtensions.DOLocalMoveY(transform2, (float)num3, 0.2f, false), (Ease)3), true), 2, (LoopType)1));
					TweenSettingsExtensions.Insert(val2, num2, (Tween)TweenSettingsExtensions.SetLoops<TweenerCore<Vector3, Vector3, VectorOptions>>(TweenSettingsExtensions.SetRelative<TweenerCore<Vector3, Vector3, VectorOptions>>(TweenSettingsExtensions.SetEase<TweenerCore<Vector3, Vector3, VectorOptions>>(ShortcutExtensions.DOLocalMoveY(gameObject.transform, (float)num3, 0.2f, false), (Ease)3), true), 2, (LoopType)1));
				}
				yield return TweenExtensions.WaitForCompletion((Tween)TweenSettingsExtensions.SetUpdate<Sequence>(val2, true));
				foreach (CardWidget item6 in list3)
				{
					Object.Destroy((Object)(object)((Component)item6).gameObject);
				}
				val3.ExileCount = val3.Battle.ExileZone.Count;
				foreach (Transform item7 in parents)
				{
					Object.Destroy((Object)(object)((Component)item7).gameObject, 0.2f);
				}
			}
		}
	}
	internal class CardUi_EnterBattle_Patch
	{
		private static void Postfix(CardUi __instance, BattleController battle)
		{
			battle.ActionViewer.Register<AddCardsToExileAction>(CardUiExtensions.AddCardsToExileViewer(__instance), (Predicate<AddCardsToExileAction>)null);
		}
	}
	internal class CardUi_LeaveBattle_Patch
	{
		private static void Postfix(CardUi __instance, BattleController battle)
		{
			battle.ActionViewer.Unregister<AddCardsToExileAction>(CardUiExtensions.AddCardsToExileViewer(__instance));
		}
	}
}
namespace LBoLEntitySideloader.TemplateGen
{
	public class BgmGen : TemplateGen<BgmTemplate>
	{
		public void QueueGen(IdContainer Id, bool overwriteVanilla, Func<BgmConfig> makeConfig = null, Func<UniTask<AudioClip>> loadAudioClipAsync = null)
		{
			CodeTypeDeclaration targetClass = InnitDefintionType(Id, overwriteVanilla);
			MakeMethod("MakeConfig", makeConfig, targetClass, overwriteVanilla);
			MakeMethod("LoadAudioClipAsync", loadAudioClipAsync, targetClass, overwriteVanilla);
		}

		public BgmGen()
			: base((Assembly)null)
		{
		}
	}
	public class CardGen : TemplateGen<CardTemplate>
	{
		public void QueueGen(IdContainer Id, bool overwriteVanilla, Func<CardConfig> makeConfig = null, Func<CardImages> loadCardImages = null, Func<LocalizationOption> loadLocalization = null, bool generateEmptyLogic = false)
		{
			CodeTypeDeclaration val = InnitDefintionType(Id, overwriteVanilla);
			MakeMethod("MakeConfig", makeConfig, val, overwriteVanilla);
			MakeMethod("LoadCardImages", loadCardImages, val, overwriteVanilla);
			MakeMethod("LoadLocalization", loadLocalization, val, overwriteVanilla);
			if (generateEmptyLogic)
			{
				MakeEntityLogic(Id, val, typeof(Card));
			}
		}

		public CardGen()
			: base((Assembly)null)
		{
		}
	}
	public class ExhibitGen : TemplateGen<ExhibitTemplate>
	{
		public void QueueGen(IdContainer Id, bool overwriteVanilla, Func<ExhibitConfig> makeConfig = null, Func<ExhibitSprites> loadSprite = null, Func<LocalizationOption> loadLocalization = null, bool generateEmptyLogic = false)
		{
			CodeTypeDeclaration val = InnitDefintionType(Id, overwriteVanilla);
			MakeMethod("MakeConfig", makeConfig, val, overwriteVanilla);
			MakeMethod("LoadSprite", loadSprite, val, overwriteVanilla);
			MakeMethod("LoadLocalization", loadLocalization, val, overwriteVanilla);
			if (generateEmptyLogic)
			{
				MakeEntityLogic(Id, val, typeof(Exhibit));
			}
		}

		public ExhibitGen()
			: base((Assembly)null)
		{
		}
	}
	public static class GenHelper
	{
		public static Func<TResult> WrapFunc<TParam, TResult>(Func<TParam, TResult> func, TParam locals)
		{
			return () => func(locals);
		}
	}
	public class JadeBoxGen : TemplateGen<JadeBoxTemplate>
	{
		public void QueueGen(IdContainer Id, bool overwriteVanilla, Func<JadeBoxConfig> makeConfig = null, Func<LocalizationOption> loadLocalization = null, bool generateEmptyLogic = false)
		{
			CodeTypeDeclaration val = InnitDefintionType(Id, overwriteVanilla);
			MakeMethod("MakeConfig", makeConfig, val, overwriteVanilla);
			MakeMethod("LoadLocalization", loadLocalization, val, overwriteVanilla);
			if (generateEmptyLogic)
			{
				MakeEntityLogic(Id, val, typeof(JadeBox));
			}
		}

		public JadeBoxGen()
			: base((Assembly)null)
		{
		}
	}
	public class MethodCache
	{
		public Dictionary<Type, Dictionary<string, Dictionary<string, Delegate>>> methodPayloadCache = new Dictionary<Type, Dictionary<string, Dictionary<string, Delegate>>>();

		public Delegate GetMethod(Type templateType, string defName, string name)
		{
			if (methodPayloadCache.TryGetValue(templateType, out var value) && value.TryGetValue(defName, out var value2) && value2.TryGetValue(name, out var value3))
			{
				return value3;
			}
			return null;
		}

		public bool AddMethod(Type templateType, string defFullName, string name, Delegate func)
		{
			methodPayloadCache.TryAdd(templateType, new Dictionary<string, Dictionary<string, Delegate>>());
			methodPayloadCache[templateType].TryAdd(defFullName, new Dictionary<string, Delegate>());
			return methodPayloadCache[templateType][defFullName].TryAdd(name, func);
		}

		public void CleargenTemplateMethodPayloadCache()
		{
			methodPayloadCache = new Dictionary<Type, Dictionary<string, Dictionary<string, Delegate>>>();
		}
	}
	public class ScriptEvaluator : Evaluator, IDisposable
	{
		internal TextWriter _textWriter;

		internal static StreamReportPrinter _reportPrinter;

		private static readonly HashSet<string> StdLib = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase) { "mscorlib", "System.Core", "System", "System.Xml" };

		public ScriptEvaluator(TextWriter tw)
			: base(BuildContext(tw))
		{
			_textWriter = tw;
			ImportAppdomainAssemblies();
			((Evaluator)this).ReferenceAssembly(typeof(EntityManager).Assembly);
		}

		public void Dispose()
		{
			_textWriter.Dispose();
		}

		private static CompilerContext BuildContext(TextWriter tw)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			_reportPrinter = new StreamReportPrinter(tw);
			CompilerSettings val = new CompilerSettings
			{
				Version = (LanguageVersion)100,
				GenerateDebugInfo = false,
				StdLib = true,
				Target = (Target)0,
				WarningLevel = 0,
				EnhancedWarnings = false,
				Encoding = Encoding.UTF8
			};
			return new CompilerContext(val, (ReportPrinter)(object)_reportPrinter);
		}

		private void ImportAppdomainAssemblies()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				string name = assembly.GetName().Name;
				if (!StdLib.Contains(name))
				{
					try
					{
						((Evaluator)this).ReferenceAssembly(assembly);
					}
					catch
					{
					}
				}
			}
		}
	}
	public class SfxGen : TemplateGen<SfxTemplate>
	{
		public void QueueGen(IdContainer Id, bool overwriteVanilla, Func<SfxConfig> makeConfig = null, Func<List<UniTask<AudioClip>>> loadSfxListAsync = null)
		{
			CodeTypeDeclaration targetClass = InnitDefintionType(Id, overwriteVanilla);
			MakeMethod("MakeConfig", makeConfig, targetClass, overwriteVanilla);
			MakeMethod("LoadSfxListAsync", loadSfxListAsync, targetClass, overwriteVanilla);
		}

		public SfxGen()
			: base((Assembly)null)
		{
		}
	}
	public class StatusEffectGen : TemplateGen<StatusEffectTemplate>
	{
		public void QueueGen(IdContainer Id, bool overwriteVanilla, Func<StatusEffectConfig> makeConfig = null, Func<Sprite> loadSprite = null, Func<LocalizationOption> loadLocalization = null, bool generateEmptyLogic = false)
		{
			CodeTypeDeclaration val = InnitDefintionType(Id, overwriteVanilla);
			MakeMethod("MakeConfig", makeConfig, val, overwriteVanilla);
			MakeMethod("LoadSprite", loadSprite, val, overwriteVanilla);
			MakeMethod("LoadLocalization", loadLocalization, val, overwriteVanilla);
			if (generateEmptyLogic)
			{
				MakeEntityLogic(Id, val, typeof(StatusEffect));
			}
		}

		public StatusEffectGen()
			: base((Assembly)null)
		{
		}
	}
	public abstract class TemplateGen<ED> where ED : EntityDefinition
	{
		public static readonly Assembly sideLoaderAss = typeof(BepinexPlugin).Assembly;

		protected static Sequence dupNameSeq = new Sequence();

		private static readonly StringBuilder evaluatorOutput;

		protected static readonly ScriptEvaluator scriptEvaluator = new ScriptEvaluator(new StringWriter(evaluatorOutput = new StringBuilder()));

		public readonly Assembly originAssembly;

		public Assembly newAssembly = null;

		public string newAssName;

		public CodeNamespace newNameSpace;

		protected CodeCompileUnit compileUnit;

		protected CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");

		protected CodeGeneratorOptions codeGenOptions = new CodeGeneratorOptions();

		public Dictionary<IdContainer, CodeTypeDeclaration> generatedTypes = new Dictionary<IdContainer, CodeTypeDeclaration>();

		private bool properInnit = false;

		private Dictionary<string, Type> name2DefTypeCache = new Dictionary<string, Type>();

		public TemplateGen(Assembly originAssembly = null)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Expected O, but got Unknown
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Expected O, but got Unknown
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Expected O, but got Unknown
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Expected O, but got Unknown
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Expected O, but got Unknown
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Expected O, but got Unknown
			if (originAssembly == null)
			{
				this.originAssembly = new StackTrace().GetFrame(2).GetMethod().ReflectedType.Assembly;
			}
			else
			{
				this.originAssembly = originAssembly;
			}
			newAssName = this.originAssembly.GetName().Name + "_" + typeof(ED).Name + "_Dynamic";
			if (UniqueTracker.Instance.methodCacheDic.ContainsKey(newAssName))
			{
				newAssName = newAssName + "_" + dupNameSeq.Next();
			}
			newAssName = LegalizeTypeName(newAssName);
			ManualLogSource obj = Log.LogDev();
			if (obj != null)
			{
				obj.LogDebug((object)("Initializing generation of: " + typeof(ED).Name + ", " + newAssName));
			}
			if (newNameSpace == null)
			{
				compileUnit = new CodeCompileUnit();
				newNameSpace = new CodeNamespace(newAssName ?? "");
				compileUnit.Namespaces.Add(newNameSpace);
				newNameSpace.Imports.Add(new CodeNamespaceImport("System"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoL.Base"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoL.Base.Extensions"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoL.ConfigData"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoL.Core"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoL.Core.Cards"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoL.Presentation"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoLEntitySideloader"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoLEntitySideloader.Resource"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("LBoLEntitySideloader.TemplateGen"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("System"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("System.Linq"));
				newNameSpace.Imports.Add(new CodeNamespaceImport("System.Reflection"));
			}
			UniqueTracker.Instance.methodCacheDic.TryAdd(newAssName, new MethodCache());
			properInnit = true;
		}

		internal CodeMemberMethod MakeGetIdMethod(IdContainer Id, CodeTypeDeclaration targetClass)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			CodeMemberMethod val = new CodeMemberMethod();
			((CodeTypeMember)val).Name = "GetId";
			val.ReturnType = new CodeTypeReference(typeof(IdContainer));
			((CodeTypeMember)val).Attributes = (MemberAttributes)24580;
			val.Statements.Add((CodeStatement)new CodeMethodReturnStatement((CodeExpression)new CodePrimitiveExpression((object)Id.ToString())));
			targetClass.Members.Add((CodeTypeMember)(object)val);
			return val;
		}

		internal CodeMemberMethod MakeMethod<R>(string name, Func<R> func, CodeTypeDeclaration targetClass, bool vanillaOverwrite = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			CodeMemberMethod val = new CodeMemberMethod();
			((CodeTypeMember)val).Name = name;
			val.ReturnType = new CodeTypeReference(typeof(R));
			((CodeTypeMember)val).Attributes = (MemberAttributes)24580;
			if (vanillaOverwrite && func == null)
			{
				CodeAttributeDeclarationCollection val2 = new CodeAttributeDeclarationCollection();
				val2.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(DontOverwriteAttribute))));
				((CodeTypeMember)val).CustomAttributes = val2;
			}
			UniqueTracker.Instance.methodCacheDic.TryAdd(newAssName, new MethodCache());
			if (func == null)
			{
				func = () => default(R);
			}
			UniqueTracker.Instance.methodCacheDic[newAssName].AddMethod(typeof(ED), ((CodeTypeMember)targetClass).Name, name, func);
			val.Statements.Add((CodeExpression)new CodeSnippetExpression("\r\n                var method = UniqueTracker.Instance.methodCacheDic[this.GetType().Assembly.GetName().Name].GetMethod(this.TemplateType(), this.GetType().Name, \"" + name + "\");\r\n                return method.DynamicInvoke(null) as " + provider.GetTypeOutput(val.ReturnType) + ";\r\n            "));
			targetClass.Members.Add((CodeTypeMember)(object)val);
			return val;
		}

		protected CodeTypeDeclaration MakeEntityLogic(IdContainer Id, CodeTypeDeclaration definitionClass, Type entityType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0051: 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_00a2: 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_00a8: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			CodeTypeDeclaration val = new CodeTypeDeclaration(Id.ToString());
			val.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
			newNameSpace.Types.Add(val);
			val.BaseTypes.Add(entityType);
			CodeAttributeDeclarationCollection val2 = new CodeAttributeDeclarationCollection();
			val2.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(EntityLogic)), (CodeAttributeArgument[])(object)new CodeAttributeArgument[1]
			{
				new CodeAttributeArgument((CodeExpression)new CodeSnippetExpression("typeof(" + newNameSpace.Name + "." + ((CodeTypeMember)definitionClass).Name + ")"))
			}));
			((CodeTypeMember)val).CustomAttributes = val2;
			return val;
		}

		public static string MakeDefName(IdContainer Id)
		{
			return LegalizeTypeName(Id) + "Definition";
		}

		public static string LegalizeTypeName(string name)
		{
			return "_" + name.Replace('-', '_').Replace(' ', '_').Replace('.', '_');
		}

		protected CodeTypeDeclaration InnitDefintionType(IdContainer Id, bool overwriteVanilla = false)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			if (!properInnit)
			{
				Log.log.LogError((object)(GetType().Name + " was not properly initialized"));
				return null;
			}
			if (!generatedTypes.ContainsKey(Id))
			{
				CodeTypeDeclaration val = new CodeTypeDeclaration(MakeDefName(Id));
				val.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
				newNameSpace.Types.Add(val);
				val.BaseTypes.Add(typeof(ED));
				if (overwriteVanilla)
				{
					((CodeTypeMember)val).CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(OverwriteVanilla))));
				}
				generatedTypes.Add(Id, val);
				MakeGetIdMethod(Id, val);
				return val;
			}
			ManualLogSource obj = Log.LogDevExtra();
			if (obj != null)
			{
				obj.LogWarning((object)$"{typeof(ED)} template gen: type {MakeDefName(Id)} was already generated. (ignore this warning if hot reloading)");
			}
			return generatedTypes[Id];
		}

		public void FinalizeGen()
		{
			if (newAssembly != null)
			{
				Log.log.LogWarning((object)("FinalizeGen: " + newAssName + " was already generated by " + originAssembly.GetName().Name + ". Skipping generation. FinalizeGen should only be called once. (ignore this warning if hot reloading)"));
			}
			else
			{
				Log.log.LogInfo((object)$"{newAssName}: generating {typeof(ED)} definitions..");
				CompiledMethod val = default(CompiledMethod);
				EvaluationInfo val2 = default(EvaluationInfo);
				string text = ((Evaluator)scriptEvaluator).Compile(OutputCSharpCode().ToString(), ref val, newAssName, ref val2);
				if (!string.IsNullOrEmpty(text))
				{
					Log.log.LogError((object)"Got parsing errors.");
					Log.log.LogError((object)text);
				}
				if (((ReportPrinter)ScriptEvaluator._reportPrinter).ErrorsCount > 0)
				{
					Log.log.LogError((object)"Got compile errors.");
					scriptEvaluator._textWriter.ToString().Split('\n').ToList()
						.ForEach(delegate(string s)
						{
							Log.log.LogError((object)s);
						});
					return;
				}
				newAssembly = val2.assembly;
			}
			UniqueTracker.Instance.generatedAssemblies.TryAdd(originAssembly, new List<Assembly>());
			UniqueTracker.Instance.generatedAssemblies[originAssembly].Add(newAssembly);
			UniqueTracker.Instance.gen2User.Add(newAssembly, originAssembly);
			if (TemplatesReflection.ExpectsEntityLogic(typeof(ED)))
			{
				UniqueTracker.Instance.gen2FacType.Add(newAssembly, TemplatesReflection.Template2FacType(typeof(ED)));
			}
		}

		public Func<Type> GetDefTypePromise(IdContainer Id)
		{
			return () => SearchForDefType(MakeDefName(Id));
		}

		private Type SearchForDefType(string name)
		{
			if (name2DefTypeCache.TryGetValue(name, out var value))
			{
				return value;
			}
			foreach (Type item in newAssembly.GetTypes().ToList())
			{
				name2DefTypeCache.TryAdd(item.Name, item);
			}
			if (name2DefTypeCache.TryGetValue(name, out value))
			{
				return value;
			}
			return null;
		}

		public StringBuilder OutputCSharpCode(bool outputToFile = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			CodeGeneratorOptions val = new CodeGeneratorOptions();
			val.BracingStyle = "C";
			StringBuilder stringBuilder = new StringBuilder();
			StringWriter stringWriter = new StringWriter(stringBuilder);
			provider.GenerateCodeFromCompileUnit(compileUnit, (TextWriter)stringWriter, val);
			if (outputToFile)
			{
				string text = "generatedCode";
				Directory.CreateDirectory(text);
				using FileStream stream = File.Open(text + "/" + newAssName + "-" + typeof(ED).Name + ".cs", FileMode.Create, FileAccess.Write, FileShare.None);
				using StreamWriter streamWriter = new StreamWriter(stream, Encoding.UTF8)
				{
					AutoFlush = true
				};
				streamWriter.Write(stringBuilder.ToString());
			}
			return stringBuilder;
		}
	}
	public class UiSoundGen : TemplateGen<UiSoundTemplate>
	{
		public void QueueGen(IdContainer Id, bool overwriteVanilla, Func<UiSoundConfig> makeConfig = null, Func<List<UniTask<AudioClip>>> loadSfxListAsync = null)
		{
			CodeTypeDeclaration targetClass = InnitDefintionType(Id, overwriteVanilla);
			MakeMethod("MakeConfig", makeConfig, targetClass, overwriteVanilla);
			MakeMethod("LoadSfxListAsync", loadSfxListAsync, targetClass, overwriteVanilla);
		}

		public UiSoundGen()
			: base((Assembly)null)
		{
		}
	}
}
namespace LBoLEntitySideloader.Resource
{
	public class AdventureImages
	{
		public Texture2D main;

		public Dictionary<string, Texture2D> extraImages = new Dictionary<string, Texture2D>();

		public AdventureImages()
		{
		}

		public AdventureImages(Texture2D main)
		{
			this.main = main;
		}

		public void AutoLoad(AdventureTemplate adventureTemplate, IResourceSource source, string extension = ".png", params string[] extraSuffixes)
		{
			string text = adventureTemplate.GetId();
			main = ResourceLoader.LoadTexture(text + extension, source);
			if (extraSuffixes == null)
			{
				return;
			}
			foreach (string text2 in extraSuffixes)
			{
				string text3 = text + text2;
				Texture2D val = ResourceLoader.LoadTexture(text3 + extension, source);
				if ((Object)(object)val != (Object)null)
				{
					extraImages[text3] = val;
				}
				else
				{
					Log.log.LogWarning((object)("[AdventureImages] Failed to load extra image '" + text3 + "' from source."));
				}
			}
		}
	}
	public class BatchLocalization : LocalizationOption
	{
		public readonly IResourceSource resourceSource;

		public readonly LocalizationFiles localizationFiles;

		public readonly HashSet<IdContainer> entityIds = new HashSet<IdContainer>();

		public readonly Type templateType;

		public readonly Type factoryType;

		public bool IsUnitNameSource { get; set; } = false;

		public BatchLocalization(IResourceSource resourceSource, Type templateType, bool mergeTerms = false)
		{
			this.resourceSource = resourceSource;
			localizationFiles = new LocalizationFiles(resourceSource, mergeTerms);
			this.templateType = templateType;
			factoryType = TemplatesReflection.Template2FacType(templateType);
		}

		internal void RegisterSelf(Assembly userAss)
		{
			if (!TemplatesReflection.AllTemplateTypes().Contains(templateType))
			{
				throw new ArgumentException($"{GetType().Name}: {templateType} is not a general template type (CardTemplate, StatusEffectTemplate etc.)");
			}
			Dictionary<Assembly, Dictionary<Type, HashSet<BatchLocalization>>> batchLocalization = UniqueTracker.Instance.batchLocalization;
			batchLocalization.TryAdd(userAss, new Dictionary<Type, HashSet<BatchLocalization>>());
			batchLocalization[userAss].TryAdd(templateType, new HashSet<BatchLocalization>());
			batchLocalization[userAss][templateType].Add(this);
		}

		public BatchLocalization(IResourceSource resourceSource, Type templateType, Locale defaultLocale, string fileName, bool mergeTerms = false)
			: this(resourceSource, templateType, mergeTerms)
		{
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			localizationFiles.AddLocaleFile(defaultLocale, fileName);
			localizationFiles.fallbackLoc = defaultLocale;
		}

		public BatchLocalization AddEntity(EntityDefinition entityTemplate)
		{
			if (entityTemplate.TemplateType() != templateType)
			{
				throw new ArgumentException($"{entityTemplate.GetId()} of type {entityTemplate.TemplateType().Name} does not match target template type of {GetType().Name}, {templateType.Name}.");
			}
			entityIds.Add(entityTemplate.UniqueId);
			return this;
		}

		public BatchLocalization(IResourceSource resourceSource, Type templateType, string fileNamePrefix, Locale fallbackLocale = (Locale)0, bool mergeTerms = false)
			: this(resourceSource, templateType, mergeTerms)
		{
			//IL_001a: 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)
			DiscoverAndLoadLocFiles(fileNamePrefix);
			localizationFiles.fallbackLoc = fallbackLocale;
		}

		public void DiscoverAndLoadLocFiles(string fileNamePrefix)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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)
			foreach (Locale item in Enum.GetValues(typeof(Locale)).Cast<Locale>())
			{
				string name = $"{fileNamePrefix}{item}";
				if (localizationFiles.source.TryGetFileName(Source.AddExtension(name, ".yaml"), out var name2))
				{
					localizationFiles.AddLocaleFile(item, name2);
				}
			}
		}
	}
	public class CardImages : IResourceProvider<Texture2D>
	{
		public static readonly string upgradeString = "Upgrade";

		public Texture2D main;

		public Texture2D upgrade;

		public Dictionary<string, Texture2D> subs = new Dictionary<string, Texture2D>();

		private IResourceSource source;

		private Func<string, Texture2D> loadingAction;

		public CardImages(IResourceSource source)
		{
			this.source = source;
			loadingAction = (string id) => ResourceLoader.LoadTexture(id, this.source);
		}

		public CardImages(IResourceSource source, Texture2D main)
			: this(source)
		{
			this.main = main;
		}

		public CardImages(IResourceSource source, Texture2D main, Dictionary<string, Texture2D> subs)
			: this(source, main)
		{
			this.subs = subs;
		}

		public void AutoLoad(CardTemplate cardTemplate, string extension, string relativePath = "", bool hasUpgradeImage = false)
		{
			AutoLoad(cardTemplate.GetId(), extension, relativePath, CardConfig.FromId((string)cardTemplate.UniqueId).SubIllustrator as List<string>, hasUpgradeImage);
		}

		public void AutoLoad(string mainId, string extension, string relativePath, List<string> subIds = null, bool hasUpgradeImage = false)
		{
			main = loadingAction(relativePath + mainId + extension);
			if (hasUpgradeImage)
			{
				upgrade = loadingAction(relativePath + mainId + upgradeString + extension);
			}
			if (subIds == null)
			{
				return;
			}
			foreach (string subId in subIds)
			{
				subs.Add(mainId + subId, loadingAction(relativePath + mainId + subId + extension));
			}
		}

		public Texture2D Load()
		{
			return main;
		}

		public Dictionary<string, Texture2D> LoadMany()
		{
			return subs;
		}
	}
	public class DirectLocalization : LocalizationOption
	{
		public bool mergeTerms;

		public Dictionary<Locale, Dictionary<string, object>> termDic = new Dictionary<Locale, Dictionary<string, object>>();

		public Locale defaultLocale;

		public Locale? fallbackLocale;

		public DirectLocalization(Dictionary<string, object> termDic, Locale defaultLocale = (Locale)0, Locale fallbackLocale = (Locale)0, bool mergeTerms = false)
		{
			//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_001b: 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)
			this.defaultLocale = defaultLocale;
			this.fallbackLocale = fallbackLocale;
			this.mergeTerms = mergeTerms;
			this.termDic.Add(defaultLocale, termDic);
		}

		public void AddLocalizedTerms(Locale locale, Dictionary<string, object> termDic)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			this.termDic.Add(locale, termDic);
		}

		public Dictionary<string, Dictionary<string, object>> WrapTermDic(IdContainer Id)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, Dictionary<string, object>> dictionary = new Dictionary<string, Dictionary<string, object>>();
			if (termDic.TryGetValue(Localization.CurrentLocale, out var value))
			{
				dictionary.Add(Id, value);
				return dictionary;
			}
			if (fallbackLocale.HasValue && termDic.TryGetValue(fallbackLocale.Value, out value))
			{
				dictionary.Add(Id, value);
				return dictionary;
			}
			dictionary.Add(Id, new Dictionary<string, object>());
			return dictionary;
		}
	}
	public class DirectorySource : Source
	{
		private class IdEqualFilename : IEqualityComparer<string>
		{
			public bool Equals(string x, string y)
			{
				return y.StartsWith(x);
			}

			public int GetHashCode(string obj)
			{
				return obj.GetHashCode();
			}
		}

		private string path;

		public DirectoryInfo dirInfo;

		private HashSet<string> fileNames = new HashSet<string>(new IdEqualFilename());

		public DirectorySource(string path)
		{
			this.path = path;
			dirInfo = new DirectoryInfo(path);
		}

		public DirectorySource(string GUID, string subFolder)
		{
			try
			{
				PluginInfo val = Chainloader.PluginInfos[GUID];
				string location = val.Location;
				if (location == null)
				{
					path = Path.Combine(Path.GetDirectoryName(Paths.PluginPath), subFolder);
				}
				else
				{
					path = Path.Combine(Path.GetDirectoryName(location), subFolder);
				}
				dirInfo = new DirectoryInfo(path);
			}
			catch (Exception ex)
			{
				path = "";
				Log.log.LogError((object)ex);
			}
		}

		public override bool TryGetFileName(string id, out string name, bool searchSubdirectories = true)
		{
			if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(path))
			{
				name = null;
				return false;
			}
			string text = id.Replace('/', Path.DirectorySeparatorChar).Replace('\\', Path.DirectorySeparatorChar);
			string text2 = Path.Combine(path, text);
			if (File.Exists(text2))
			{
				name = text.Replace('\\', '/');
				return true;
			}
			if (!searchSubdirectories)
			{
				name = null;
				BepinexPlugin.log.LogWarning((object)("[DirectorySource] Could not find file in path: " + id));
				return false;
			}
			if (dirInfo != null && dirInfo.Exists)
			{
				string fileName = Path.GetFileName(id);
				string directoryName = Path.GetDirectoryName(text);
				string text3 = (string.IsNullOrEmpty(directoryName) ? path : Path.Combine(path, directoryName));
				if (Directory.Exists(text3))
				{
					DirectoryInfo directoryInfo = new DirectoryInfo(text3);
					foreach (FileInfo item in directoryInfo.EnumerateFiles("*", SearchOption.AllDirectories))
					{
						if (item.Name.Equals(fileName, StringComparison.OrdinalIgnoreCase))
						{
							string text4 = Path.GetRelativePath(path, item.FullName).Replace('\\', '/');
							name = text4;
							return true;
						}
					}
				}
			}
			name = null;
			return false;
		}

		public override Stream Load(string id)
		{
			string arg = FullPath(id);
			try
			{
				if (File.Exists(arg))
				{
					return new FileStream(arg, FileMode.Open, FileAccess.Read, FileShare.Read);
				}
				Log.log.LogWarning((object)$"{GetType()}: File not found at path '{arg}' for id '{id}'");
				return null;
			}
			catch (Exception arg2)
			{
				Log.log.LogError((object)$"{GetType()} exception while loading file {id}: {arg2}");
				return null;
			}
		}

		public string FullPath(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return this.path;
			}
			string path = id.Replace('/', Path.DirectorySeparatorChar).Replace('\\', Path.DirectorySeparatorChar);
			return Path.Combine(this.path, path);
		}
	}
	public class EffectWidgetData
	{
		public class ExtraElementProperties
		{
			public bool changeColor;

			public DieType dieType;

			public bool lowPerformance;
		}

		public enum SortingLayer
		{
			Bullet,
			Effect
		}

		public GameObject effectGo;

		private static ExtraElementProperties defaultProps = new ExtraElementProperties
		{
			changeColor = false,
			dieType = (DieType)0,
			lowPerformance = false
		};

		public EffectWidgetData()
		{
		}

		public EffectWidgetData(GameObject effectGo, Queue<ExtraElementProperties> particleSystemProperties, Queue<ExtraElementProperties> trailRendererProperties = null, SortingLayer sortingLayer = SortingLayer.Bullet, string nameOverwrite = "")
		{
			this.effectGo = CreateEffect(effectGo, particleSystemProperties, trailRendererProperties, sortingLayer, nameOverwrite);
		}

		public static GameObject CreateEffect(GameObject effectGo, Queue<ExtraElementProperties> particleSystemProperties, Queue<ExtraElementProperties> trailRendererProperties = null, SortingLayer sortingLayer = SortingLayer.Bullet, string nameOverwrite = "")
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			if (!string.IsNullOrEmpty(nameOverwrite))
			{
				((Object)effectGo).name = nameOverwrite;
			}
			int layer = 0;
			switch (sortingLayer)
			{
			case SortingLayer.Bullet:
				layer = 10;
				break;
			case SortingLayer.Effect:
				layer = 11;
				break;
			}
			effectGo.transform.position = Vector3.zero;
			EffectWidget val = effectGo.AddComponent<EffectWidget>();
			List<ParticleSystemElement> list = new List<ParticleSystemElement>();
			List<TrailRendererElement> list2 = new List<TrailRendererElement>();
			ParticleSystem particleSystem = default(ParticleSystem);
			ParticleSystemRenderer val2 = default(ParticleSystemRenderer);
			TrailRenderer val3 = default(TrailRenderer);
			foreach (GameObject item in effectGo.transform.IterateHierarchy())
			{
				item.layer = layer;
				if (item.TryGetComponent<ParticleSystem>(ref particleSystem))
				{
					ExtraElementProperties extraElementProperties = WrapQ(particleSystemProperties);
					list.Add(new ParticleSystemElement
					{
						particleSystem = particleSystem,
						changeColor = extraElementProperties.changeColor,
						dieType = extraElementProperties.dieType,
						lowPerformance = extraElementProperties.lowPerformance
					});
				}
				if (item.TryGetComponent<ParticleSystemRenderer>(ref val2))
				{
					((Renderer)val2).sortingLayerName = sortingLayer.ToString();
				}
				if (item.TryGetComponent<TrailRenderer>(ref val3))
				{
					((Renderer)val3).sortingLayerName = sortingLayer.ToString();
					ExtraElementProperties extraElementProperties2 = WrapQ(trailRendererProperties);
					list2.Add(new TrailRendererElement
					{
						trailRenderer = val3,
						changeColor = extraElementProperties2.changeColor,
						dieType = extraElementProperties2.dieType,
						lowPerformance = extraElementProperties2.lowPerformance
					});
				}
			}
			val.particleSystemElements = list.ToArray();
			val.trailRendererElements = list2.ToArray();
			val.Awake();
			return effectGo;
		}

		private static ExtraElementProperties WrapQ(Queue<ExtraElementProperties> queue)
		{
			if (queue == null)
			{
				return defaultProps;
			}
			if (queue.Count == 1)
			{
				return queue.Last();
			}
			return queue.Dequeue();
		}
	}
	public class EmbeddedSource : Source
	{
		private Assembly assembly;

		public EmbeddedSource(Assembly assembly)
		{
			this.assembly = assembly;
		}

		public override bool TryGetFileName(string id, out string name, bool searchSubdirectories = true)
		{
			if (string.IsNullOrEmpty(id) || assembly == null)
			{
				name = null;
				return false;
			}
			string dotPath = Source.LegalizeFileName(id).Replace('/', '.').Replace('\\', '.');
			string fileNameOnly = Path.GetFileName(id);
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			name = manifestResourceNames.FirstOrDefault((string n) => n.EndsWith("." + dotPath, StringComparison.OrdinalIgnoreCase) || n.Equals(dotPath, StringComparison.OrdinalIgnoreCase) || (searchSubdirectories && n.EndsWith("." + fileNameOnly, StringComparison.OrdinalIgnoreCase)));
			if (name == null)
			{
				Log.log.LogWarning((object)("[EmbeddedSource] File '" + id + "' not found in embedded resources for '" + assembly.GetName().Name + "'."));
				return false;
			}
			return true;
		}

		public override Stream Load(string id)
		{
			TryGetFileName(id, out var name);
			if (name == null)
			{
				BepinexPlugin.log.LogWarning((object)(assembly.GetName().Name + ": no embedded file found with name " + id));
				return null;
			}
			return assembly.GetManifestResourceStream(name);
		}
	}
	public class ExhibitSprites : IResourceProvider<Sprite>
	{
		public Sprite main;

		public Dictionary<string, Sprite> customSprites = new Dictionary<string, Sprite>();

		public ExhibitSprites()
		{
		}

		public ExhibitSprites(Sprite main)
		{
			this.main = main;
		}

		public Sprite Load()
		{
			return main;
		}

		public Dictionary<string, Sprite> LoadMany()
		{
			Dictionary<string, Sprite> dic = new Dictionary<string, Sprite>();
			CollectionExtensions.Do<KeyValuePair<string, Sprite>>((IEnumerable<KeyValuePair<string, Sprite>>)customSprites, (Action<KeyValuePair<string, Sprite>>)delegate(KeyValuePair<string, Sprite> kv)
			{
				dic.TryAdd(kv.Key, kv.Value);
			});
			return dic;
		}
	}
	public class ExtraIcons : IResourceProvider<Sprite>
	{
		public Dictionary<string, Sprite> icons = new Dictionary<string, Sprite>();

		public Sprite Load()
		{
			throw new NotImplementedException("Load not implemented for ExtraIcons");
		}

		public Dictionary<string, Sprite> LoadMany()
		{
			Dictionary<string, Sprite> dic = new Dictionary<string, Sprite>();
			CollectionExtensions.Do<KeyValuePair<string, Sprite>>((IEnumerable<KeyValuePair<string, Sprite>>)icons, (Action<KeyValuePair<string, Sprite>>)delegate(KeyValuePair<string, Sprite> kv)
			{
				dic.Add(kv.Key, kv.Value);
			});
			return dic;
		}
	}
	[Obsolete("Use BatchLocalization instead", false)]
	public class GlobalLocalization : LocalizationOption
	{
		public readonly LocalizationFiles LocalizationFiles;

		public GlobalLocalization(IResourceSource source)
		{
			LocalizationFiles = new LocalizationFiles(source, mergeTerms: false);
		}

		public GlobalLocalization(IResourceSource source, bool mergeTerms)
			: this(source)
		{
			LocalizationFiles.mergeTerms = mergeTerms;
		}

		public GlobalLocalization(LocalizationFiles localizationFiles)
		{
			LocalizationFiles = localizationFiles;
		}

		[Obsolete("Use the other overload")]
		public void DiscoverAndLoadLocFiles(EntityDefinition entityTemplate)
		{
			string name = entityTemplate.EntityType().Name;
			DiscoverAndLoadLocFiles(name);
		}

		public void DiscoverAndLoadLocFiles(string templateName)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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)
			foreach (Locale item in Enum.GetValues(typeof(Locale)).Cast<Locale>())
			{
				string text = $"{templateName}{item}";
				if (LocalizationFiles.source.TryGetFileName(Source.AddExtension(text, ".yaml"), out var _))
				{
					LocalizationFiles.AddLocaleFile(item, text);
				}
			}
		}
	}
	public class IntentionImages : IResourceProvider<Sprite>
	{
		public Sprite main;

		public Dictionary<string, Sprite> subSprites = new Dictionary<string, Sprite>();

		public Sprite Load()
		{
			return main;
		}

		public Dictionary<string, Sprite> LoadMany()
		{
			Dictionary<string, Sprite> dic = new Dictionary<string, Sprite>();
			CollectionExtensions.Do<KeyValuePair<string, Sprite>>((IEnumerable<KeyValuePair<string, Sprite>>)subSprites, (Action<KeyValuePair<string, Sprite>>)delegate(KeyValuePair<string, Sprite> kv)
			{
				dic.TryAdd(kv.Key, kv.Value);
			});
			return dic;
		}
	}
	public interface IResourceConsumer<T>
	{
		void Consume(T resource);
	}
	internal interface IResourceProvider<T>
	{
		T Load();

		Dictionary<string, T> LoadMany();
	}
	public interface IResourceSource
	{
		Stream Load(string id);

		bool TryGetFileName(string id, out string name, bool searchSubdirectories = true);
	}
	public class LocalizationFiles : LocalizationOption, IResourceProvider<YamlMappingNode>
	{
		public Locale fallbackLoc = (Locale)0;

		internal Dictionary<Locale, Func<YamlMappingNode>> locTable = new Dictionary<Locale, Func<YamlMappingNode>>();

		public Dictionary<Locale, string> fileNames = new Dictionary<Locale, string>();

		public bool mergeTerms = false;

		public readonly IResourceSource source;

		private Func<string, YamlMappingNode> loadingAction;

		public LocalizationFiles(IResourceSource source)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			this.source = source;
			loadingAction = (string id) => ResourceLoader.LoadYaml(id, this.source);
		}

		public LocalizationFiles(IResourceSource source, bool mergeTerms)
			: this(source)
		{
			this.mergeTerms = mergeTerms;
		}

		public LocalizationFiles(IResourceSource source, Locale fallbackLoc)
			: this(source)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			this.fallbackLoc = fallbackLoc;
		}

		public LocalizationFiles(IResourceSource source, Locale fallbackLoc, bool mergeTerms)
			: this(source, fallbackLoc)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			this.mergeTerms = mergeTerms;
		}

		public void AddLocaleFile(Locale locale, string fileName)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			fileName = Source.AddExtension(fileName, ".yaml");
			if (!locTable.TryAdd(locale, () => loadingAction(fileName)))
			{
				ManualLogSource obj = Log.LogDev();
				if (obj != null)
				{
					obj.LogWarning((object)$"{fileName}: LocalizationFiles already have {locale} registered");
				}
			}
			else
			{
				fileNames.TryAdd(locale, fileName);
			}
		}

		public Locale GetAvailableLocale()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			return locTable.ContainsKey(Localization.CurrentLocale) ? Localization.CurrentLocale : fallbackLoc;
		}

		public YamlMappingNode Load(Locale locale)
		{
			//IL_0007: 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_003f: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (locTable.TryGetValue(locale, out var value))
			{
				return value();
			}
			if (locTable.TryGetValue(fallbackLoc, out value))
			{
				string valueSafe = GeneralExtensions.GetValueSafe<Locale, string>(fileNames, fallbackLoc);
				ManualLogSource obj = Log.LogDev();
				if (obj != null)
				{
					obj.LogInfo((object)$"Localization for {Localization.CurrentLocale} not found. Trying to use {fallbackLoc} fallback option from file: {valueSafe}.");
				}
				return value();
			}
			ManualLogSource obj2 = Log.LogDev();
			if (obj2 != null)
			{
				obj2.LogWarning((object)$"{GetType().Name}: {locale} locale option does not have a file set.");
			}
			return null;
		}

		internal Dictionary<string, Dictionary<string, object>> LoadLocTable(Type entityType, Type[] entityLogicTypes)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			YamlMappingNode val = Load(Localization.CurrentLocale);
			if (val != null)
			{
				return Localization.InternalLoadTypeLocalizationTable(val, entityType, (IEnumerable<Type>)entityLogicTypes);
			}
			Log.log.LogWarning((object)(entityType.Assembly.GetName().Name + ": No localization found for " + entityType.Name + " types."));
			return null;
		}

		internal Dictionary<string, Dictionary<string, object>> LoadLocTable(IEnumerable<string> Ids, bool addEmptyDic = true)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, Dictionary<string, object>> dictionary = new Dictionary<string, Dictionary<string, object>>();
			YamlMappingNode val = Load(Localization.CurrentLocale);
			if (val == null)
			{
				Log.log.LogWarning((object)"LocalizationFiles: No localization file found.");
				return dictionary;
			}
			IOrderedDictionary<YamlNode, YamlNode> children = val.Children;
			foreach (string Id in Ids)
			{
				if (((IDictionary<YamlNode, YamlNode>)children).TryGetValue(YamlNode.op_Implicit(Id), out YamlNode value))
				{
					YamlMappingNode val2 = (YamlMappingNode)(object)((value is YamlMappingNode) ? value : null);
					if (val2 != null)
					{
						dictionary.Add(Id, Localization.CreatePropertyLocalizeTable(Id, val2));
						continue;
					}
				}
				if (addEmptyDic)
				{
					dictionary.Add(Id, new Dictionary<string, object>());
				}
			}
			return dictionary;
		}

		internal Dictionary<string, Dictionary<string, object>> LoadLocTable(IEnumerable<IdContainer> idContainers, bool addEmptyDic = true)
		{
			return LoadLocTable(idContainers.Select((IdContainer id) => id.ToString()), addEmptyDic);
		}

		public static void MissingValueError(string enityLogicId)
		{
			Log.log.LogWarning((object)(enityLogicId + " entity was registered but localization file contains no values for " + enityLogicId + ". Did you forget to add \"" + enityLogicId + ":\" entry to .yaml file?"));
		}

		public YamlMappingNode Load()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Load(fallbackLoc);
		}

		public Dictionary<string, YamlMappingNode> LoadMany()
		{
			return null;
		}

		public void DiscoverAndLoadLocFiles(string fileNamePrefix)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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)
			foreach (Locale item in Enum.GetValues(typeof(Locale)).Cast<Locale>())
			{
				string name = $"{fileNamePrefix}{item}";
				string id = Source.AddExtension(name, ".yaml");
				if (source.TryGetFileName(id, out var name2))
				{
					AddLocaleFile(item, name2);
				}
			}
		}
	}
	public abstract class LocalizationOption
	{
		internal static void FillLocalizationTables(Dictionary<string, Dictionary<string, object>> termDic, Type facType, bool mergeTerms)
		{
			if (termDic == null)
			{
				return;
			}
			foreach (KeyValuePair<string, Dictionary<string, object>> item in termDic)
			{
				if (CollectionsExtensions.Empty<KeyValuePair<string, object>>((IReadOnlyCollection<KeyValuePair<string, object>>)item.Value))
				{
					LocalizationFiles.MissingValueError(item.Key);
				}
				if (mergeTerms)
				{
					TypeFactoryReflection.AccessTypeLocalizers(facType).Invoke((object)null).TryAdd(item.Key, new Dictionary<string, object>());
					TypeFactoryReflection.AccessTypeLocalizers(facType).Invoke((object)null)[item.Key].Merge(item.Value);
				}
				else
				{
					TypeFactoryReflection.AccessTypeLocalizers(facType).Invoke((object)null).AlwaysAdd(item.Key, item.Value);
				}
			}
		}

		public static YamlMappingNode TermDic2YamlMapping(Dictionary<string, Dictionary<string, object>> termDic)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			YamlMappingNode val = new YamlMappingNode();
			foreach (string key in termDic.Keys)
			{
				YamlMappingNode val2 = new YamlMappingNode();
				foreach (KeyValuePair<string, object> item in termDic[key])
				{
					if (item.Value.GetType() != typeof(string) && item.Value.GetType().GetInterfaces().Any((Type i) => (i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>)) || i.GetType() == typeof(IEnumerable)))
					{
						val2.Add(item.Key, (YamlNode)new YamlSequenceNode());
						foreach (object item2 in (IEnumerable)item.Value)
						{
							YamlNode obj = ((YamlNode)val2)[YamlNode.op_Implicit(item.Key)];
							((YamlSequenceNode)((obj is YamlSequenceNode) ? obj : null)).Add((YamlNode)new YamlScalarNode(item2?.ToString()));
						}
					}
					else
					{
						val2.Add(item.Key, (YamlNode)new YamlScalarNode(item.Value?.ToString()));
					}
				}
				val.Add(key, (YamlNode)(object)val2);
			}
			return val;
		}

		internal static void FillUnitNameTable(YamlMappingNode yamlKeyValue, bool mergeTerms, HashSet<IdContainer> keysToInclude = null)
		{
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			foreach (KeyValuePair<YamlNode, YamlNode> item in yamlKeyValue)
			{
				item.Deconstruct(out var key, out var value);
				YamlScalarNode val = (YamlScalarNode)(object)((key is YamlScalarNode) ? key : null);
				if (val == null)
				{
					Log.log.LogError((object)$"[Localization] UnitName key {key} is not scalar");
				}
				else if (keysToInclude == null || keysToInclude.Contains(val.Value))
				{
					YamlMappingNode val2 = (YamlMappingNode)(object)((value is YamlMappingNode) ? value : null);
					if (val2 == null)
					{
						Log.log.LogError((object)$"[Localization] UnitName value of {val.Value} is not mapping: {value}");
					}
					else if (mergeTerms)
					{
						UnitName val3 = new UnitName(val2);
						UnitNameTable._table.TryAdd(val.Value, val3);
						UnitNameTable._table[val.Value]._table.Merge(val3._table);
					}
					else
					{
						UnitNameTable._table.AlwaysAdd(val.Value, new UnitName(val2));
					}
				}
			}
		}
	}
	public class ModelOption
	{
		public readonly ModelType modelType;

		public UniTask<Sprite> loadSprite;

		public UniTask<SkeletonDataAsset> loadSpine;

		public string effectName;

		public ModelOption(UniTask<Sprite> loadSprite)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			modelType = (ModelType)0;
			this.loadSprite = loadSprite;
		}

		public ModelOption(UniTask<SkeletonDataAsset> loadSpine)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			modelType = (ModelType)1;
			this.loadSpine = loadSpine;
		}

		public ModelOption(string effectName)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			modelType = (ModelType)2;
			this.effectName = effectName;
		}
	}
	public class PackIcons
	{
		public Sprite mainIcon;

		public Sprite disabledIcon;
	}
	public abstract class PieceTemplate : EntityDefinition, IConfigProvider<PieceConfig>
	{
		public override Type ConfigType()
		{
			return typeof(PieceConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(PieceTemplate);
		}

		public static int ConvertGunId(int gunId, int pieceNumber = 0)
		{
			if (pieceNumber < 0 || pieceNumber > 99)
			{
				throw new ArgumentException($"Exception while registering piece for GunId {gunId}: {pieceNumber} is out of range 0-99");
			}
			return gunId * 100 + pieceNumber;
		}

		public PieceConfig DefaultConfig()
		{
			//IL_009d: 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_00b7: Expected O, but got Unknown
			return new PieceConfig(0, false, "", 1, 0, false, true, 0, 0, 1, 6, false, new float[0][], new int[0][], 0, new float[0][], new float[0][], new float[0][], new float[0][], 0, 0, 0, 1, new int[0][], new float[0][], new float[0][], new int[0][], 0, new float[1][] { new float[1] { 10f } }, new float[0][], new float[0][], new int[0][][], new int[0][][], new float[0][][], new int[0][], new Vector3(0.08f, 0.08f, 0.08f), "", "", 1f);
		}

		public abstract PieceConfig MakeConfig();
	}
	public static class PISuffixes
	{
		public const string stand = "Stand";

		public const string defeatedStand = "DefeatedStand";

		public const string deckStand = "DeckStand";

		public const string winStand = "WinStand";

		public const string avatar = "Avatar";

		public const string defeatedIcon = "DefeatedIcon";

		public const string winIcon = "WinIcon";

		public const string perfectWinIcon = "PerfectWinIcon";

		public const string collectionIcon = "CollectionIcon";

		public const string selectionCircleIcon = "SelectionCircleIcon";

		public const string cardImprint = "CardImprint";
	}
	public class PlayerImages
	{
		public enum UseSame
		{
			None,
			StandAndDeck,
			StandDeckAndWinStand
		}

		[CompilerGenerated]
		private sealed class <LoadDeckStandAsync>d__21 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public PlayerImages <>4__this;

			private Sprite <s>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0094;
					}
					if (<>4__this.deckStandTask.HasValue)
					{
						val = <>4__this.deckStandTask.Value.GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadDeckStandAsync>d__21 <LoadDeckStandAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadDeckStandAsync>d__21>(ref val, ref <LoadDeckStandAsync>d__);
							return;
						}
						goto IL_0094;
					}
					result = null;
					goto end_IL_0007;
					IL_0094:
					<>s__2 = val.GetResult();
					<s>5__1 = <>s__2;
					<>s__2 = null;
					result = (((Object)(object)<s>5__1 == (Object)null) ? emptySprite : <s>5__1);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<s>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<s>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadDefeatedIconAsync>d__24 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public PlayerImages <>4__this;

			private Sprite <s>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0094;
					}
					if (<>4__this.defeatedIconTask.HasValue)
					{
						val = <>4__this.defeatedIconTask.Value.GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadDefeatedIconAsync>d__24 <LoadDefeatedIconAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadDefeatedIconAsync>d__24>(ref val, ref <LoadDefeatedIconAsync>d__);
							return;
						}
						goto IL_0094;
					}
					result = null;
					goto end_IL_0007;
					IL_0094:
					<>s__2 = val.GetResult();
					<s>5__1 = <>s__2;
					<>s__2 = null;
					result = (((Object)(object)<s>5__1 == (Object)null) ? emptySprite : <s>5__1);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<s>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<s>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadDefeatedStandAsync>d__23 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public PlayerImages <>4__this;

			private Sprite <s>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0094;
					}
					if (<>4__this.defeatedStandTask.HasValue)
					{
						val = <>4__this.defeatedStandTask.Value.GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadDefeatedStandAsync>d__23 <LoadDefeatedStandAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadDefeatedStandAsync>d__23>(ref val, ref <LoadDefeatedStandAsync>d__);
							return;
						}
						goto IL_0094;
					}
					result = null;
					goto end_IL_0007;
					IL_0094:
					<>s__2 = val.GetResult();
					<s>5__1 = <>s__2;
					<>s__2 = null;
					result = (((Object)(object)<s>5__1 == (Object)null) ? emptySprite : <s>5__1);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<s>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<s>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadPerfectWinIconAsync>d__26 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public PlayerImages <>4__this;

			private Sprite <s>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0094;
					}
					if (<>4__this.perfectWinIconTask.HasValue)
					{
						val = <>4__this.perfectWinIconTask.Value.GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadPerfectWinIconAsync>d__26 <LoadPerfectWinIconAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadPerfectWinIconAsync>d__26>(ref val, ref <LoadPerfectWinIconAsync>d__);
							return;
						}
						goto IL_0094;
					}
					result = null;
					goto end_IL_0007;
					IL_0094:
					<>s__2 = val.GetResult();
					<s>5__1 = <>s__2;
					<>s__2 = null;
					result = (((Object)(object)<s>5__1 == (Object)null) ? emptySprite : <s>5__1);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<s>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<s>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadStartPanelStandAsync>d__20 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public PlayerImages <>4__this;

			private Sprite <s>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0094;
					}
					if (<>4__this.startPanelStandTask.HasValue)
					{
						val = <>4__this.startPanelStandTask.Value.GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadStartPanelStandAsync>d__20 <LoadStartPanelStandAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadStartPanelStandAsync>d__20>(ref val, ref <LoadStartPanelStandAsync>d__);
							return;
						}
						goto IL_0094;
					}
					result = null;
					goto end_IL_0007;
					IL_0094:
					<>s__2 = val.GetResult();
					<s>5__1 = <>s__2;
					<>s__2 = null;
					result = (((Object)(object)<s>5__1 == (Object)null) ? emptySprite : <s>5__1);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<s>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<s>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadWinIconAsync>d__25 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public PlayerImages <>4__this;

			private Sprite <s>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0094;
					}
					if (<>4__this.winIconTask.HasValue)
					{
						val = <>4__this.winIconTask.Value.GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadWinIconAsync>d__25 <LoadWinIconAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadWinIconAsync>d__25>(ref val, ref <LoadWinIconAsync>d__);
							return;
						}
						goto IL_0094;
					}
					result = null;
					goto end_IL_0007;
					IL_0094:
					<>s__2 = val.GetResult();
					<s>5__1 = <>s__2;
					<>s__2 = null;
					result = (((Object)(object)<s>5__1 == (Object)null) ? emptySprite : <s>5__1);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<s>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<s>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadWinStandAsync>d__22 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public PlayerImages <>4__this;

			private Sprite <s>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num == 0)
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
						goto IL_0094;
					}
					if (<>4__this.winStandTask.HasValue)
					{
						val = <>4__this.winStandTask.Value.GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadWinStandAsync>d__22 <LoadWinStandAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadWinStandAsync>d__22>(ref val, ref <LoadWinStandAsync>d__);
							return;
						}
						goto IL_0094;
					}
					result = null;
					goto end_IL_0007;
					IL_0094:
					<>s__2 = val.GetResult();
					<s>5__1 = <>s__2;
					<>s__2 = null;
					result = (((Object)(object)<s>5__1 == (Object)null) ? emptySprite : <s>5__1);
					end_IL_0007:;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<s>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<s>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		internal UniTask<Sprite>? startPanelStandTask;

		internal Func<Sprite> startPanelStandFunc;

		internal UniTask<Sprite>? deckStandTask;

		internal Func<Sprite> deckStandFunc;

		internal UniTask<Sprite>? winStandTask;

		internal Func<Sprite> winStandFunc;

		internal UniTask<Sprite>? defeatedStandTask;

		internal Func<Sprite> defeatedStandFunc;

		internal Func<Sprite> inRunAvatarPic;

		internal Func<Sprite> cardImprint;

		internal UniTask<Sprite>? defeatedIconTask;

		internal Func<Sprite> defeatedIconFunc;

		internal UniTask<Sprite>? winIconTask;

		internal Func<Sprite> winIconFunc;

		internal UniTask<Sprite>? perfectWinIconTask;

		internal Func<Sprite> perfectWinIconFunc;

		internal Func<Sprite> collectionIcon;

		internal Func<Sprite> selectionCircleIcon;

		public static readonly Sprite emptySprite = Sprite.Create(new Texture2D(1, 1, (TextureFormat)5, false), default(Rect), new Vector2(0.5f, 0.5f));

		public void AutoLoad(string Id, Func<string, Sprite> loadingAction, [MaybeNull] Func<string, UniTask<Sprite>> asyncAction, UseSame useSame = UseSame.StandDeckAndWinStand, string fileSuffix = ".png", string pathPrefix = "")
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			Func<string, string> Wrap = (string s) => pathPrefix + Id + s + fileSuffix;
			SetStartPanelStand(asyncAction?.Invoke(Wrap("Stand")), () => loadingAction?.Invoke(Wrap("Stand")));
			string deckStand = Wrap((useSame > UseSame.None) ? "Stand" : "DeckStand");
			SetDeckStand(asyncAction?.Invoke(deckStand), () => loadingAction?.Invoke(deckStand));
			SetDefeatedStand(asyncAction?.Invoke(Wrap("DefeatedStand")), () => loadingAction?.Invoke(Wrap("DefeatedStand")));
			string winStand = Wrap((useSame > UseSame.StandAndDeck) ? "Stand" : "WinStand");
			SetWinStand(asyncAction?.Invoke(winStand), () => loadingAction?.Invoke(winStand));
			SetInRunAvatarPic(() => loadingAction?.Invoke(Wrap("Avatar")));
			SetCollectionIcon(() => loadingAction?.Invoke(Wrap("CollectionIcon")));
			SetSelectionCircleIcon(() => loadingAction?.Invoke(Wrap("SelectionCircleIcon")));
			SetPerfectWinIcon(asyncAction?.Invoke(Wrap("PerfectWinIcon")), () => loadingAction?.Invoke(Wrap("PerfectWinIcon")));
			SetWinIcon(asyncAction?.Invoke(Wrap("WinIcon")), () => loadingAction?.Invoke(Wrap("WinIcon")));
			SetDefeatedIcon(asyncAction?.Invoke(Wrap("DefeatedIcon")), () => loadingAction?.Invoke(Wrap("DefeatedIcon")));
			SetCardImprint(() => loadingAction?.Invoke(Wrap("CardImprint")));
		}

		public void SetStartPanelStand(UniTask<Sprite>? task, Func<Sprite> func = null)
		{
			startPanelStandTask = task;
			startPanelStandFunc = func;
		}

		public void SetDeckStand(UniTask<Sprite>? task, Func<Sprite> func = null)
		{
			deckStandTask = task;
			deckStandFunc = func;
		}

		public void SetWinStand(UniTask<Sprite>? task, Func<Sprite> func = null)
		{
			winStandTask = task;
			winStandFunc = func;
		}

		public void SetDefeatedStand(UniTask<Sprite>? task, Func<Sprite> func = null)
		{
			defeatedStandTask = task;
			defeatedStandFunc = func;
		}

		public void SetInRunAvatarPic(Func<Sprite> func)
		{
			inRunAvatarPic = func;
		}

		public void SetDefeatedIcon(UniTask<Sprite>? task, Func<Sprite> func = null)
		{
			defeatedIconTask = task;
			defeatedIconFunc = func;
		}

		public void SetWinIcon(UniTask<Sprite>? task, Func<Sprite> func = null)
		{
			winIconTask = task;
			winIconFunc = func;
		}

		public void SetPerfectWinIcon(UniTask<Sprite>? task, Func<Sprite> func = null)
		{
			perfectWinIconTask = task;
			perfectWinIconFunc = func;
		}

		public void SetCollectionIcon(Func<Sprite> func)
		{
			collectionIcon = func;
		}

		public void SetSelectionCircleIcon(Func<Sprite> func)
		{
			selectionCircleIcon = func;
		}

		public void SetCardImprint(Func<Sprite> func)
		{
			cardImprint = func;
		}

		internal Sprite LoadStartPanelStand()
		{
			Sprite val = startPanelStandFunc?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadDeckStand()
		{
			Sprite val = deckStandFunc?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadWinStand()
		{
			Sprite val = winStandFunc?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadDefeatedStand()
		{
			Sprite val = defeatedStandFunc?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadDefeatedIcon()
		{
			Sprite val = defeatedIconFunc?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadWinIcon()
		{
			Sprite val = winIconFunc?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadPerfectWinIcon()
		{
			Sprite val = perfectWinIconFunc?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		[AsyncStateMachine(typeof(<LoadStartPanelStandAsync>d__20))]
		[DebuggerStepThrough]
		internal UniTask<Sprite> LoadStartPanelStandAsync()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<LoadStartPanelStandAsync>d__20 <LoadStartPanelStandAsync>d__ = new <LoadStartPanelStandAsync>d__20();
			<LoadStartPanelStandAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadStartPanelStandAsync>d__.<>4__this = this;
			<LoadStartPanelStandAsync>d__.<>1__state = -1;
			<LoadStartPanelStandAsync>d__.<>t__builder.Start<<LoadStartPanelStandAsync>d__20>(ref <LoadStartPanelStandAsync>d__);
			return <LoadStartPanelStandAsync>d__.<>t__builder.Task;
		}

		[AsyncStateMachine(typeof(<LoadDeckStandAsync>d__21))]
		[DebuggerStepThrough]
		internal UniTask<Sprite> LoadDeckStandAsync()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<LoadDeckStandAsync>d__21 <LoadDeckStandAsync>d__ = new <LoadDeckStandAsync>d__21();
			<LoadDeckStandAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadDeckStandAsync>d__.<>4__this = this;
			<LoadDeckStandAsync>d__.<>1__state = -1;
			<LoadDeckStandAsync>d__.<>t__builder.Start<<LoadDeckStandAsync>d__21>(ref <LoadDeckStandAsync>d__);
			return <LoadDeckStandAsync>d__.<>t__builder.Task;
		}

		[AsyncStateMachine(typeof(<LoadWinStandAsync>d__22))]
		[DebuggerStepThrough]
		internal UniTask<Sprite> LoadWinStandAsync()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<LoadWinStandAsync>d__22 <LoadWinStandAsync>d__ = new <LoadWinStandAsync>d__22();
			<LoadWinStandAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadWinStandAsync>d__.<>4__this = this;
			<LoadWinStandAsync>d__.<>1__state = -1;
			<LoadWinStandAsync>d__.<>t__builder.Start<<LoadWinStandAsync>d__22>(ref <LoadWinStandAsync>d__);
			return <LoadWinStandAsync>d__.<>t__builder.Task;
		}

		[AsyncStateMachine(typeof(<LoadDefeatedStandAsync>d__23))]
		[DebuggerStepThrough]
		internal UniTask<Sprite> LoadDefeatedStandAsync()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<LoadDefeatedStandAsync>d__23 <LoadDefeatedStandAsync>d__ = new <LoadDefeatedStandAsync>d__23();
			<LoadDefeatedStandAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadDefeatedStandAsync>d__.<>4__this = this;
			<LoadDefeatedStandAsync>d__.<>1__state = -1;
			<LoadDefeatedStandAsync>d__.<>t__builder.Start<<LoadDefeatedStandAsync>d__23>(ref <LoadDefeatedStandAsync>d__);
			return <LoadDefeatedStandAsync>d__.<>t__builder.Task;
		}

		[AsyncStateMachine(typeof(<LoadDefeatedIconAsync>d__24))]
		[DebuggerStepThrough]
		internal UniTask<Sprite> LoadDefeatedIconAsync()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<LoadDefeatedIconAsync>d__24 <LoadDefeatedIconAsync>d__ = new <LoadDefeatedIconAsync>d__24();
			<LoadDefeatedIconAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadDefeatedIconAsync>d__.<>4__this = this;
			<LoadDefeatedIconAsync>d__.<>1__state = -1;
			<LoadDefeatedIconAsync>d__.<>t__builder.Start<<LoadDefeatedIconAsync>d__24>(ref <LoadDefeatedIconAsync>d__);
			return <LoadDefeatedIconAsync>d__.<>t__builder.Task;
		}

		[AsyncStateMachine(typeof(<LoadWinIconAsync>d__25))]
		[DebuggerStepThrough]
		internal UniTask<Sprite> LoadWinIconAsync()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<LoadWinIconAsync>d__25 <LoadWinIconAsync>d__ = new <LoadWinIconAsync>d__25();
			<LoadWinIconAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadWinIconAsync>d__.<>4__this = this;
			<LoadWinIconAsync>d__.<>1__state = -1;
			<LoadWinIconAsync>d__.<>t__builder.Start<<LoadWinIconAsync>d__25>(ref <LoadWinIconAsync>d__);
			return <LoadWinIconAsync>d__.<>t__builder.Task;
		}

		[AsyncStateMachine(typeof(<LoadPerfectWinIconAsync>d__26))]
		[DebuggerStepThrough]
		internal UniTask<Sprite> LoadPerfectWinIconAsync()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			<LoadPerfectWinIconAsync>d__26 <LoadPerfectWinIconAsync>d__ = new <LoadPerfectWinIconAsync>d__26();
			<LoadPerfectWinIconAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadPerfectWinIconAsync>d__.<>4__this = this;
			<LoadPerfectWinIconAsync>d__.<>1__state = -1;
			<LoadPerfectWinIconAsync>d__.<>t__builder.Start<<LoadPerfectWinIconAsync>d__26>(ref <LoadPerfectWinIconAsync>d__);
			return <LoadPerfectWinIconAsync>d__.<>t__builder.Task;
		}

		internal Sprite LoadInRunAvatarPic()
		{
			Sprite val = inRunAvatarPic?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadCollectionIcon()
		{
			Sprite val = collectionIcon?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}

		internal Sprite LoadSelectionCircleIcon()
		{
			Sprite val = selectionCircleIcon?.Invoke();
			return ((Object)(object)val == (Object)null) ? null : val;
		}

		internal Sprite LoadCardBack()
		{
			Sprite val = cardImprint?.Invoke();
			return ((Object)(object)val == (Object)null) ? emptySprite : val;
		}
	}
	public class ResourceLoader
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass7_0
		{
			public UnityWebRequest uwr;

			internal AudioClip <LoadAudioClip>b__0()
			{
				return DownloadHandlerAudioClip.GetContent(uwr);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadAudioClip>d__7 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<AudioClip> <>t__builder;

			public string name;

			public AudioType audioType;

			public DirectorySource source;

			public string protocol;

			private <>c__DisplayClass7_0 <>8__1;

			private string <path>5__2;

			private AudioClip <clip>5__3;

			private AudioClip <>s__4;

			private UnityWebRequestAsyncOperationAwaiter <>u__1;

			private Awaiter<AudioClip> <>u__2;

			private void MoveNext()
			{
				//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_011d: 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_016f: 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_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_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: 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_00de: 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_0194: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				AudioClip result;
				try
				{
					if ((uint)num > 1u)
					{
						<>8__1 = new <>c__DisplayClass7_0();
						<path>5__2 = "";
						if (source != null)
						{
							<path>5__2 = source.FullPath(name);
						}
						else
						{
							<path>5__2 = name;
						}
						ManualLogSource obj = Log.LogDevExtra();
						if (obj != null)
						{
							obj.LogInfo((object)("Loading audio from " + <path>5__2));
						}
						<>8__1.uwr = UnityWebRequestMultimedia.GetAudioClip(protocol + <path>5__2, audioType);
					}
					try
					{
						Awaiter<AudioClip> val;
						UnityWebRequestAsyncOperationAwaiter val2;
						if (num != 0)
						{
							if (num == 1)
							{
								val = <>u__2;
								<>u__2 = default(Awaiter<AudioClip>);
								num = (<>1__state = -1);
								goto IL_01ce;
							}
							<>8__1.uwr.timeout = 20;
							val2 = UnityAsyncExtensions.GetAwaiter(<>8__1.uwr.SendWebRequest());
							if (!((UnityWebRequestAsyncOperationAwaiter)(ref val2)).IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val2;
								<LoadAudioClip>d__7 <LoadAudioClip>d__ = this;
								<>t__builder.AwaitUnsafeOnCompleted<UnityWebRequestAsyncOperationAwaiter, <LoadAudioClip>d__7>(ref val2, ref <LoadAudioClip>d__);
								return;
							}
						}
						else
						{
							val2 = <>u__1;
							<>u__1 = default(UnityWebRequestAsyncOperationAwaiter);
							num = (<>1__state = -1);
						}
						((UnityWebRequestAsyncOperationAwaiter)(ref val2)).GetResult();
						if (string.IsNullOrEmpty(<>8__1.uwr.error))
						{
							val = UniTask.RunOnThreadPool<AudioClip>((Func<AudioClip>)(() => DownloadHandlerAudioClip.GetContent(<>8__1.uwr)), true, default(CancellationToken)).GetAwaiter();
							if (!val.IsCompleted)
							{
								num = (<>1__state = 1);
								<>u__2 = val;
								<LoadAudioClip>d__7 <LoadAudioClip>d__ = this;
								<>t__builder.AwaitUnsafeOnCompleted<Awaiter<AudioClip>, <LoadAudioClip>d__7>(ref val, ref <LoadAudioClip>d__);
								return;
							}
							goto IL_01ce;
						}
						BepinexPlugin.log.LogError((object)<>8__1.uwr.error);
						result = null;
						goto end_IL_00a4;
						IL_01ce:
						<>s__4 = val.GetResult();
						<clip>5__3 = <>s__4;
						<>s__4 = null;
						result = <clip>5__3;
						end_IL_00a4:;
					}
					finally
					{
						if (num < 0 && <>8__1.uwr != null)
						{
							((IDisposable)<>8__1.uwr).Dispose();
						}
					}
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<>8__1 = null;
					<path>5__2 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<>8__1 = null;
				<path>5__2 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		[CompilerGenerated]
		private sealed class <LoadSpriteAsync>d__4 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncUniTaskMethodBuilder<Sprite> <>t__builder;

			public string name;

			public DirectorySource source;

			public int ppu;

			public GraphicsFormat finalGraphicsFormat;

			public int anisoLevel;

			public FilterMode filterMode;

			public SpriteMeshType spriteMeshType;

			public Rect? rect;

			public Vector2? pivot;

			public string protocol;

			private string <path>5__1;

			private Sprite <>s__2;

			private Awaiter<Sprite> <>u__1;

			private void MoveNext()
			{
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				Sprite result;
				try
				{
					Awaiter<Sprite> val;
					if (num != 0)
					{
						<path>5__1 = "";
						if (source != null)
						{
							<path>5__1 = source.FullPath(name);
						}
						else
						{
							<path>5__1 = name;
						}
						val = ImageLoader.LoadSpriteMemoryOptimized(protocol + <path>5__1, ppu, finalGraphicsFormat, anisoLevel, filterMode, spriteMeshType, pivot, rect, (TextureFormat)5).GetAwaiter();
						if (!val.IsCompleted)
						{
							num = (<>1__state = 0);
							<>u__1 = val;
							<LoadSpriteAsync>d__4 <LoadSpriteAsync>d__ = this;
							<>t__builder.AwaitUnsafeOnCompleted<Awaiter<Sprite>, <LoadSpriteAsync>d__4>(ref val, ref <LoadSpriteAsync>d__);
							return;
						}
					}
					else
					{
						val = <>u__1;
						<>u__1 = default(Awaiter<Sprite>);
						num = (<>1__state = -1);
					}
					<>s__2 = val.GetResult();
					result = <>s__2;
				}
				catch (Exception exception)
				{
					<>1__state = -2;
					<path>5__1 = null;
					<>t__builder.SetException(exception);
					return;
				}
				<>1__state = -2;
				<path>5__1 = null;
				<>t__builder.SetResult(result);
			}

			void IAsyncStateMachine.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				this.MoveNext();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
			}

			void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
			{
				//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
				this.SetStateMachine(stateMachine);
			}
		}

		public static Texture2D LoadTexture(string name, IResourceSource source)
		{
			return LoadTexture(name, source, 1, (FilterMode)1, generateMipMaps: true);
		}

		public static Texture2D LoadTexture(string name, IResourceSource source, int anisoLevel, FilterMode filterMode, bool generateMipMaps)
		{
			//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_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_007e: Expected O, but got Unknown
			if (source.TryGetFileName(name, out var name2))
			{
				name = name2;
			}
			using Stream stream = source.Load(name);
			if (stream == null)
			{
				return null;
			}
			using MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[16384];
			int count;
			while ((count = stream.Read(array, 0, array.Length)) > 0)
			{
				memoryStream.Write(array, 0, count);
			}
			Texture2D val = new Texture2D(1, 1, (TextureFormat)5, generateMipMaps)
			{
				anisoLevel = anisoLevel,
				filterMode = filterMode
			};
			ImageConversion.LoadImage(val, memoryStream.ToArray());
			return val;
		}

		public static Sprite LoadSprite(string name, IResourceSource source, Rect? rect = null, int ppu = 1, Vector2? pivot = null)
		{
			return LoadSprite(name, source, ppu, 1, (FilterMode)1, generateMipMaps: true, rect, pivot);
		}

		public static Sprite LoadSprite(string name, IResourceSource source, int ppu, int anisoLevel, FilterMode filterMode, bool generateMipMaps = false, Rect? rect = null, Vector2? pivot = null)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0088: 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_0093: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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)
			if (source.TryGetFileName(name, out var name2))
			{
				name = name2;
			}
			using Stream stream = source.Load(name);
			if (stream == null)
			{
				return null;
			}
			using MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[16384];
			int count;
			while ((count = stream.Read(array, 0, array.Length)) > 0)
			{
				memoryStream.Write(array, 0, count);
			}
			TextureCreationFlags val = (TextureCreationFlags)0;
			if (generateMipMaps)
			{
				val = (TextureCreationFlags)(val | 1);
			}
			Texture2D val2 = new Texture2D(1, 1, (GraphicsFormat)4, val)
			{
				anisoLevel = anisoLevel,
				filterMode = filterMode
			};
			ImageConversion.LoadImage(val2, memoryStream.ToArray());
			if (!rect.HasValue)
			{
				rect = new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height);
			}
			if (!pivot.HasValue)
			{
				pivot = new Vector2(0.5f, 0.5f);
			}
			return Sprite.Create(val2, rect.Value, pivot.Value, (float)ppu);
		}

		[AsyncStateMachine(typeof(<LoadSpriteAsync>d__4))]
		[DebuggerStepThrough]
		public static UniTask<Sprite> LoadSpriteAsync(string name, DirectorySource source, int ppu = 100, GraphicsFormat finalGraphicsFormat = (GraphicsFormat)4, int anisoLevel = 1, FilterMode filterMode = (FilterMode)1, SpriteMeshType spriteMeshType = (SpriteMeshType)1, Rect? rect = null, Vector2? pivot = null, string protocol = "file://")
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0036: 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: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			<LoadSpriteAsync>d__4 <LoadSpriteAsync>d__ = new <LoadSpriteAsync>d__4();
			<LoadSpriteAsync>d__.<>t__builder = AsyncUniTaskMethodBuilder<Sprite>.Create();
			<LoadSpriteAsync>d__.name = name;
			<LoadSpriteAsync>d__.source = source;
			<LoadSpriteAsync>d__.ppu = ppu;
			<LoadSpriteAsync>d__.finalGraphicsFormat = finalGraphicsFormat;
			<LoadSpriteAsync>d__.anisoLevel = anisoLevel;
			<LoadSpriteAsync>d__.filterMode = filterMode;
			<LoadSpriteAsync>d__.spriteMeshType = spriteMeshType;
			<LoadSpriteAsync>d__.rect = rect;
			<LoadSpriteAsync>d__.pivot = pivot;
			<LoadSpriteAsync>d__.protocol = protocol;
			<LoadSpriteAsync>d__.<>1__state = -1;
			<LoadSpriteAsync>d__.<>t__builder.Start<<LoadSpriteAsync>d__4>(ref <LoadSpriteAsync>d__);
			return <LoadSpriteAsync>d__.<>t__builder.Task;
		}

		public static YamlMappingNode LoadYaml(string name, IResourceSource source)
		{
			if (source.TryGetFileName(name, out var name2))
			{
				name = name2;
			}
			using Stream stream = source.Load(name);
			if (stream == null)
			{
				BepinexPlugin.log.LogWarning((object)("[ResourceLoader] Could not load stream for yaml resource: " + name));
				return null;
			}
			using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8);
			string text = streamReader.ReadToEnd();
			try
			{
				return Localization.ParseYaml(text);
			}
			catch (Exception arg)
			{
				BepinexPlugin.log.LogWarning((object)("illegal yaml while loading " + name + ":"));
				BepinexPlugin.log.LogWarning((object)$"{arg}");
				return null;
			}
		}

		public static AssetBundle LoadAssetBundle(string name, DirectorySource source)
		{
			string text = "";
			text = ((source == null) ? name : source.FullPath(name));
			return AssetBundle.LoadFromFile(text);
		}

		[AsyncStateMachine(typeof(<LoadAudioClip>d__7))]
		[DebuggerStepThrough]
		public static UniTask<AudioClip> LoadAudioClip(string name, AudioType audioType, DirectorySource source, string protocol = "file://")
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			<LoadAudioClip>d__7 <LoadAudioClip>d__ = new <LoadAudioClip>d__7();
			<LoadAudioClip>d__.<>t__builder = AsyncUniTaskMethodBuilder<AudioClip>.Create();
			<LoadAudioClip>d__.name = name;
			<LoadAudioClip>d__.audioType = audioType;
			<LoadAudioClip>d__.source = source;
			<LoadAudioClip>d__.protocol = protocol;
			<LoadAudioClip>d__.<>1__state = -1;
			<LoadAudioClip>d__.<>t__builder.Start<<LoadAudioClip>d__7>(ref <LoadAudioClip>d__);
			return <LoadAudioClip>d__.<>t__builder.Task;
		}

		public static byte[] ResourceBinary(string name, IResourceSource source)
		{
			if (source.TryGetFileName(name, out var name2))
			{
				name = name2;
			}
			using Stream stream = source.Load(name);
			if (stream == null)
			{
				return null;
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			return array;
		}
	}
	public abstract class Source : IResourceSource
	{
		public abstract Stream Load(string id);

		public abstract bool TryGetFileName(string id, out string name, bool searchSubdirectories = true);

		public static string LegalizeFileName(string fileName)
		{
			string pattern = "[\\|\\>\\<:\"\\?\\*]";
			Regex regex = new Regex(pattern);
			return regex.Replace(fileName, "");
		}

		public static string AddExtension(string name, string extension)
		{
			if (!name.EndsWith(extension))
			{
				return name + extension;
			}
			return name;
		}
	}
	public class YarnData
	{
		public byte[] compiledBytes;

		public LocalizationFiles dialogueLocalization;

		public Locale fallbackLocale = (Locale)0;

		public YarnData()
		{
		}//IL_0002: Unknown result type (might be due to invalid IL or missing references)


		public YarnData(byte[] compiledBytes, LocalizationFiles dialogueLocalization, Locale fallbackLocale = (Locale)0)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			this.compiledBytes = compiledBytes;
			this.dialogueLocalization = dialogueLocalization;
			this.fallbackLocale = fallbackLocale;
			if (this.dialogueLocalization != null)
			{
				this.dialogueLocalization.fallbackLoc = fallbackLocale;
			}
		}

		public void AutoLoad(AdventureTemplate adventureTemplate, IResourceSource yarnSource, IResourceSource locSource, Locale fallbackLocale = (Locale)0)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			string text = adventureTemplate.GetId();
			compiledBytes = ResourceLoader.ResourceBinary(text + ".yarnc", yarnSource);
			dialogueLocalization = new LocalizationFiles(locSource, fallbackLocale);
			dialogueLocalization.DiscoverAndLoadLocFiles(text);
		}

		public Dictionary<string, string> GetStringTableForCurrentLocale()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			if (dialogueLocalization == null)
			{
				BepinexPlugin.log.LogWarning((object)"[YarnData] dialogueLocalization is NULL!");
				return dictionary;
			}
			Locale currentLocale = Localization.CurrentLocale;
			BepinexPlugin.log.LogInfo((object)$"[YarnData] GetStringTableForCurrentLocale called for locale: {currentLocale}");
			YamlMappingNode val = dialogueLocalization.Load(currentLocale);
			if (val != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in (IEnumerable<KeyValuePair<YamlNode, YamlNode>>)val.Children)
				{
					YamlNode key = item.Key;
					YamlScalarNode val2 = (YamlScalarNode)(object)((key is YamlScalarNode) ? key : null);
					string key2 = ((val2 != null) ? val2.Value : ((object)item.Key).ToString());
					YamlNode value = item.Value;
					YamlScalarNode val3 = (YamlScalarNode)(object)((value is YamlScalarNode) ? value : null);
					string value2 = ((val3 != null) ? val3.Value : ((object)item.Value).ToString());
					dictionary[key2] = value2;
				}
				BepinexPlugin.log.LogInfo((object)$"[YarnData] Loaded {dictionary.Count} dialogue entries from YAML.");
				foreach (KeyValuePair<string, string> item2 in dictionary)
				{
					BepinexPlugin.log.LogInfo((object)("   YAML Entry: '" + item2.Key + "' => '" + item2.Value + "'"));
				}
			}
			else
			{
				BepinexPlugin.log.LogWarning((object)$"[YarnData] Loaded YAML is NULL for locale: {currentLocale} and fallback locale: {dialogueLocalization.fallbackLoc}!");
			}
			return dictionary;
		}
	}
}
namespace LBoLEntitySideloader.ReflectionHelpers
{
	public class ConfigReflection
	{
		private static readonly ManualLogSource log = BepinexPlugin.log;

		private static readonly List<Assembly> configAssemblies = new List<Assembly> { typeof(CardConfig).Assembly };

		private static HashSet<Type> configTypeCache = new HashSet<Type>();

		private static readonly HashSet<Type> intAsIdTypes = new HashSet<Type>
		{
			typeof(PieceConfig),
			typeof(ExpConfig)
		};

		private static Dictionary<Type, FieldInfo> indexFields = new Dictionary<Type, FieldInfo>
		{
			{
				typeof(CardConfig),
				AccessTools.Field(typeof(CardConfig), BackingWrap("Index"))
			},
			{
				typeof(AdventureConfig),
				AccessTools.Field(typeof(AdventureConfig), BackingWrap("No"))
			},
			{
				typeof(BgmConfig),
				AccessTools.Field(typeof(BgmConfig), BackingWrap("No"))
			},
			{
				typeof(ExhibitConfig),
				AccessTools.Field(typeof(ExhibitConfig), BackingWrap("Index"))
			},
			{
				typeof(JadeBoxConfig),
				AccessTools.Field(typeof(JadeBoxConfig), BackingWrap("Index"))
			},
			{
				typeof(PlayerUnitConfig),
				AccessTools.Field(typeof(PlayerUnitConfig), BackingWrap("Order"))
			},
			{
				typeof(StatusEffectConfig),
				AccessTools.Field(typeof(StatusEffectConfig), BackingWrap("Index"))
			}
		};

		private static Dictionary<Type, Type> config2FactoryType = new Dictionary<Type, Type>();

		private static string[] potentialArrayNames = new string[1] { "_data" };

		private static Dictionary<Type, FieldInfo> arrayFieldCache = new Dictionary<Type, FieldInfo>();

		private static string[] potentialTableNames = new string[4] { "_IdTable", "_LevelTable", "_NameTable", "_IDTable" };

		private static Dictionary<Type, FieldInfo> tableFieldCache = new Dictionary<Type, FieldInfo>();

		private static Dictionary<Type, FieldInfo> idFieldCache = new Dictionary<Type, FieldInfo> { 
		{
			typeof(GunConfig),
			AccessTools.Field(typeof(GunConfig), BackingWrap("Name"))
		} };

		private static string[] potentialIdNames = new string[4]
		{
			BackingWrap("Id"),
			BackingWrap("ID"),
			BackingWrap("Level"),
			BackingWrap("Name")
		};

		private static string[] potentialFromIdNames = new string[4] { "FromId", "FromName", "FromLevel", "FromID" };

		private static Dictionary<Type, MethodInfo> fromIdCache = new Dictionary<Type, MethodInfo>();

		public static string BackingWrap(string s)
		{
			return "<" + s + ">k__BackingField";
		}

		public static FieldInfo HasIndex(Type configType)
		{
			if (!AllConfigTypes().Contains(configType))
			{
				log.LogWarning((object)$"HasIndex: {configType} is not a config type");
				return null;
			}
			if (indexFields.TryGetValue(configType, out var value))
			{
				return value;
			}
			return null;
		}

		public static Dictionary<Type, Type> GetConfig2FactoryType(bool debug = false, bool refresh = false)
		{
			if (CollectionsExtensions.Empty<KeyValuePair<Type, Type>>((IReadOnlyCollection<KeyValuePair<Type, Type>>)config2FactoryType) || refresh)
			{
				foreach (Type factoryType in TypeFactoryReflection.factoryTypes)
				{
					string potentialConfig = factoryType.Name + "Config";
					Type type = AllConfigTypes().FirstOrDefault((Type t) => t.Name == potentialConfig);
					if (type != null)
					{
						config2FactoryType.Add(type, factoryType);
					}
					else if (debug)
					{
						log.LogDebug((object)(factoryType.Name + " doesn't have corresponding config"));
					}
				}
			}
			return config2FactoryType;
		}

		public static FieldInfo GetArrayField(Type configType)
		{
			return GetFieldInfo(configType, potentialArrayNames, arrayFieldCache);
		}

		public static FieldInfo GetTableField(Type configType)
		{
			return GetFieldInfo(configType, potentialTableNames, tableFieldCache);
		}

		public static FieldInfo GetIdField(Type configType)
		{
			return GetFieldInfo(configType, potentialIdNames, idFieldCache);
		}

		private static FieldInfo GetFieldInfo(Type configType, string[] potentialNames, Dictionary<Type, FieldInfo> cache)
		{
			if (cache.TryGetValue(configType, out var value))
			{
				return value;
			}
			if (!AllConfigTypes().Contains(configType))
			{
				log.LogWarning((object)$"GetDataField: {configType} is not a config type");
				return null;
			}
			FieldInfo fieldInfo = null;
			foreach (string n in potentialNames)
			{
				FieldInfo fieldInfo2 = AccessTools.FindIncludingBaseTypes<FieldInfo>(configType, (Func<Type, FieldInfo>)((Type t) => t.GetField(n, AccessTools.all)));
				if (!(fieldInfo2 != null))
				{
					continue;
				}
				if (fieldInfo == null)
				{
					fieldInfo = fieldInfo2;
					continue;
				}
				ManualLogSource obj = Log.LogDev();
				if (obj != null)
				{
					obj.LogWarning((object)$"Potentially ambiguous fields found in {configType}: {fieldInfo.Name}, {fieldInfo2.Name}..");
				}
			}
			if (fieldInfo == null)
			{
				throw new MissingMemberException($"None of the potential names managed to reflect a field from {configType}");
			}
			cache.Add(configType, fieldInfo);
			return fieldInfo;
		}

		public static MethodInfo GetFromIdMethod(Type configType, bool verify = true)
		{
			if (fromIdCache.TryGetValue(configType, out var value))
			{
				return value;
			}
			if (!AllConfigTypes().Contains(configType))
			{
				log.LogWarning((object)$"GetFromIdMethod: {configType} is not a config type");
				return null;
			}
			MethodInfo methodInfo = null;
			string[] array = potentialFromIdNames;
			foreach (string n in array)
			{
				methodInfo = AccessTools.FindIncludingBaseTypes<MethodInfo>(configType, (Func<Type, MethodInfo>)((Type t) => t.GetMethod(n, AccessTools.all)));
				if (methodInfo != null)
				{
					break;
				}
			}
			if (methodInfo == null)
			{
				throw new MissingMemberException($"None of the potential fromId names managed to reflect a method from {configType}");
			}
			if (verify)
			{
				ParameterInfo[] parameters = methodInfo.GetParameters();
				if (parameters.Count() != 1)
				{
					throw new MissingMemberException($"{configType}: {methodInfo.Name} did not have expected number of parameters. {parameters.Count()} instead of 1.");
				}
				if (!parameters.All((ParameterInfo pi) => pi.ParameterType == typeof(string)))
				{
					throw new MissingMemberException($"{configType}: {methodInfo.Name} not all parameters are string type");
				}
			}
			fromIdCache.Add(configType, methodInfo);
			return methodInfo;
		}

		public static IEnumerable<Type> AllConfigTypes(IEnumerable<Assembly> assemblies = null, bool exclude = false, bool refresh = false)
		{
			if (assemblies == null)
			{
				assemblies = configAssemblies;
			}
			if (refresh)
			{
				configTypeCache.Clear();
			}
			if (CollectionsExtensions.Empty<Type>((IReadOnlyCollection<Type>)configTypeCache))
			{
				foreach (Assembly assembly in assemblies)
				{
					CollectionExtensions.Do<Type>(from t in assembly.GetExportedTypes()
						where t.IsSealed && t.Name.EndsWith("Config")
						select t, (Action<Type>)delegate(Type t)
					{
						configTypeCache.Add(t);
					});
				}
			}
			if (exclude)
			{
				return configTypeCache.Except(intAsIdTypes);
			}
			return configTypeCache;
		}

		internal void ClearCache()
		{
			fromIdCache = new Dictionary<Type, MethodInfo>();
			configTypeCache = new HashSet<Type>();
		}

		public static void LogFromIdNames()
		{
			IEnumerable<Type> enumerable = AllConfigTypes();
			CollectionExtensions.Do<Type>(enumerable, (Action<Type>)delegate(Type t)
			{
				log.LogInfo((object)t.Name);
			});
			log.LogInfo((object)$"----{enumerable.Count()}");
			CollectionExtensions.Do<MethodInfo>(from m in enumerable.SelectMany((Type t) => AccessTools.GetDeclaredMethods(t))
				where !m.IsSpecialName && !m.Name.StartsWith("<")
				select m, (Action<MethodInfo>)delegate(MethodInfo m)
			{
				log.LogInfo((object)$"{m.DeclaringType}: {m.Name}");
			});
			IEnumerable<HashSet<MethodInfo>> source = enumerable.Select((Type t) => (from m in AccessTools.GetDeclaredMethods(t)
				where !m.IsSpecialName && !m.Name.StartsWith("<")
				select m).ToHashSet(new CompareByMethodName()));
			HashSet<MethodInfo> first = source.Aggregate((HashSet<MethodInfo> s1, HashSet<MethodInfo> s2) => s1.Union(s2, new CompareByMethodName()).ToHashSet(new CompareByMethodName()));
			HashSet<MethodInfo> second = source.Aggregate((HashSet<MethodInfo> s1, HashSet<MethodInfo> s2) => s1.Intersect(s2, new CompareByMethodName()).ToHashSet(new CompareByMethodName()));
			log.LogInfo((object)"----");
			CollectionExtensions.Do<MethodInfo>(first.Except(second, new CompareByMethodName()), (Action<MethodInfo>)delegate(MethodInfo m)
			{
				log.LogInfo((object)$"{m.DeclaringType}: {m.Name}");
			});
		}

		public static void LogArrayNames()
		{
			LogFieldNames(AccessTools.Field(typeof(CardConfig), "_data").FieldType);
		}

		public static void LogTableNames()
		{
			LogFieldNames(AccessTools.Field(typeof(CardConfig), "_IdTable").FieldType);
		}

		public static void LogFieldNames(Type fieldType)
		{
			IEnumerable<Type> source = AllConfigTypes();
			IEnumerable<HashSet<FieldInfo>> enumerable = null;
			enumerable = ((!fieldType.IsGenericType) ? source.Select((Type t) => (from f in AccessTools.GetDeclaredFields(t)
				where f.FieldType == fieldType || f.FieldType.BaseType == fieldType.BaseType
				select f).ToHashSet(new CompareByFieldName())) : source.Select((Type t) => (from f in AccessTools.GetDeclaredFields(t)
				where f.FieldType.IsGenericType && f.FieldType.GetGenericTypeDefinition() == fieldType.GetGenericTypeDefinition()
				select f).ToHashSet(new CompareByFieldName())));
			CollectionExtensions.Do<HashSet<FieldInfo>>(enumerable, (Action<HashSet<FieldInfo>>)delegate(HashSet<FieldInfo> h)
			{
				CollectionExtensions.Do<FieldInfo>((IEnumerable<FieldInfo>)h, (Action<FieldInfo>)delegate(FieldInfo f)
				{
					log.LogInfo((object)$"{f.DeclaringType}: {f.Name}");
				});
			});
			log.LogInfo((object)"----");
			CollectionExtensions.Do<FieldInfo>((IEnumerable<FieldInfo>)enumerable.Aggregate((HashSet<FieldInfo> s1, HashSet<FieldInfo> s2) => s1.Union(s2, new CompareByFieldName()).ToHashSet(new CompareByFieldName())), (Action<FieldInfo>)delegate(FieldInfo f)
			{
				log.LogInfo((object)$"{f.DeclaringType}: {f.Name}");
			});
			log.LogInfo((object)"field names repeating only once: ");
			CollectionExtensions.Do<FieldInfo>((IEnumerable<FieldInfo>)enumerable.Aggregate((HashSet<FieldInfo> s1, HashSet<FieldInfo> s2) => s1.Union(s2, new CompareByFieldName()).Except(s1.Intersect(s2, new CompareByFieldName()), new CompareByFieldName()).ToHashSet(new CompareByFieldName())), (Action<FieldInfo>)delegate(FieldInfo f)
			{
				log.LogInfo((object)$"{f.DeclaringType}: {f.Name}");
			});
		}
	}
	public class CompareByMethodName : IEqualityComparer<MethodInfo>
	{
		public bool Equals(MethodInfo x, MethodInfo y)
		{
			return x.Name == y.Name;
		}

		public int GetHashCode(MethodInfo obj)
		{
			return obj.Name.GetHashCode();
		}
	}
	public class CompareByFieldName : IEqualityComparer<FieldInfo>
	{
		public bool Equals(FieldInfo x, FieldInfo y)
		{
			return x.Name == y.Name;
		}

		public int GetHashCode(FieldInfo obj)
		{
			return obj.Name.GetHashCode();
		}
	}
	public static class ExtraAccess
	{
		private static readonly ManualLogSource log = BepinexPlugin.log;

		public static Type MakeGenericType(Type type, Type[] genParameters)
		{
			if (!type.IsGenericType)
			{
				log.LogWarning((object)$"{type} is not generic");
				return null;
			}
			return type.GetGenericTypeDefinition().MakeGenericType(genParameters);
		}

		public static MethodInfo InnerMoveNext(Type type, string methodName)
		{
			Type type2 = (from t in type.GetNestedTypes(AccessTools.allDeclared)
				where t.Name.Contains("<" + methodName + ">")
				select t).Single();
			return AccessTools.Method(type2, "MoveNext", (Type[])null, (Type[])null);
		}

		public static MethodInfo InnerMoveNext(string typeName, string methodName)
		{
			return InnerMoveNext(AccessTools.TypeByName(typeName), methodName);
		}

		public static MethodInfo InnerMoveNext(string typeName, MethodInfo methodInfo)
		{
			return InnerMoveNext(AccessTools.TypeByName(typeName), methodInfo.Name);
		}

		public static MethodInfo InnerMoveNext(Type type, MethodInfo methodInfo)
		{
			return InnerMoveNext(type, methodInfo.Name);
		}
	}
	internal class TemplatesReflection
	{
		private static HashSet<Type> templateTypes = new HashSet<Type>();

		private static List<Type> templatesExpectingEntityLogic = new List<Type>();

		public static HashSet<Type> AllTemplateTypes(bool refresh = false)
		{
			if (CollectionsExtensions.Empty<Type>((IReadOnlyCollection<Type>)templateTypes) || refresh)
			{
				CollectionExtensions.Do<Type>(from t in typeof(EntityDefinition).Assembly.GetExportedTypes()
					where t.BaseType == typeof(EntityDefinition)
					select t, (Action<Type>)delegate(Type t)
				{
					templateTypes.Add(t);
				});
			}
			return templateTypes;
		}

		public static bool ExpectsEntityLogic(Type template, bool refresh = false)
		{
			if (CollectionsExtensions.Empty<Type>((IReadOnlyCollection<Type>)templatesExpectingEntityLogic) || refresh)
			{
				Type interfaceType = typeof(ITypeProvider<>).GetGenericTypeDefinition();
				CollectionExtensions.Do<Type>(from t in AllTemplateTypes()
					where t.GetInterfaces().Any((Type i) => TypeExtensions.IsSubclassOfGeneric(i, interfaceType))
					select t, (Action<Type>)delegate(Type t)
				{
					templatesExpectingEntityLogic.Add(t);
				});
			}
			return templatesExpectingEntityLogic.Any((Type t) => template.IsSubclassOf(t) || t == template);
		}

		public static Type Template2FacType(Type template, bool refresh = false)
		{
			if (!ExpectsEntityLogic(template))
			{
				return null;
			}
			Type interfaceType = typeof(ITypeProvider<>).GetGenericTypeDefinition();
			return template.GetInterfaces().First((Type i) => TypeExtensions.IsSubclassOfGeneric(i, interfaceType)).GetGenericArguments()
				.First();
		}

		public static bool IsTemplateType(Type type)
		{
			return AllTemplateTypes().Any((Type t) => type.IsSubclassOf(t));
		}

		public static bool DoOverwrite(Type definitionType, string methodName)
		{
			MethodInfo element = AccessTools.Method(definitionType, methodName, (Type[])null, (Type[])null);
			return element.GetCustomAttribute<DontOverwriteAttribute>(inherit: true) == null;
		}
	}
	public class TypeFactoryReflection
	{
		public enum TableFieldName
		{
			FullNameTypeDict,
			TypeDict
		}

		private static readonly ManualLogSource log = BepinexPlugin.log;

		public static HashSet<Type> factoryTypes = new HashSet<Type>
		{
			typeof(Stage),
			typeof(Card),
			typeof(UltimateSkill),
			typeof(Exhibit),
			typeof(PlayerUnit),
			typeof(EnemyUnit),
			typeof(StatusEffect),
			typeof(Doll),
			typeof(GapOption),
			typeof(Intention),
			typeof(Adventure),
			typeof(JadeBox)
		};

		private static Type genericTypeFactoryType = typeof(TypeFactory<>).GetGenericTypeDefinition();

		private static Dictionary<Type, Dictionary<TableFieldName, FieldRef<object, Dictionary<string, Type>>>> entityDicCache = new Dictionary<Type, Dictionary<TableFieldName, FieldRef<object, Dictionary<string, Type>>>>();

		private static Dictionary<Type, FieldRef<object, Dictionary<string, Dictionary<string, object>>>> typeLocalizerCache = new Dictionary<Type, FieldRef<object, Dictionary<string, Dictionary<string, object>>>>();

		public static FieldRef<object, Dictionary<string, Type>> AccessTypeDicts(Type facType, TableFieldName tableFieldName)
		{
			if (!factoryTypes.Contains(facType))
			{
				log.LogWarning((object)$"GetAccessRef: {facType} is not a type used by TypeFactory");
				return null;
			}
			if (entityDicCache.TryGetValue(facType, out var value) && value.TryGetValue(tableFieldName, out var value2))
			{
				return value2;
			}
			Type type = genericTypeFactoryType.MakeGenericType(facType);
			FieldRef<object, Dictionary<string, Type>> val = AccessTools.FieldRefAccess<Dictionary<string, Type>>(type, tableFieldName.ToString());
			entityDicCache.TryAdd(facType, new Dictionary<TableFieldName, FieldRef<object, Dictionary<string, Type>>>());
			entityDicCache[facType].TryAdd(tableFieldName, val);
			return val;
		}

		public static FieldRef<object, Dictionary<string, Dictionary<string, object>>> AccessTypeLocalizers(Type facType)
		{
			if (!factoryTypes.Contains(facType))
			{
				log.LogWarning((object)$"AccessTypeLocalizers: {facType} is not a type used by TypeFactory");
				return null;
			}
			if (typeLocalizerCache.TryGetValue(facType, out var value))
			{
				return value;
			}
			Type type = genericTypeFactoryType.MakeGenericType(facType);
			FieldRef<object, Dictionary<string, Dictionary<string, object>>> val = AccessTools.FieldRefAccess<Dictionary<string, Dictionary<string, object>>>(type, "_typeLocalizers");
			typeLocalizerCache.TryAdd(facType, val);
			return val;
		}

		public static void OutputVirtualMembers()
		{
			HashSet<Type> types = new HashSet<Type>();
			CollectionExtensions.Do<Type>((IEnumerable<Type>)factoryTypes, (Action<Type>)delegate(Type t)
			{
				types.Add(t);
				Type type = t;
				while (type != typeof(object))
				{
					types.Add(type);
					type = type.BaseType;
				}
			});
			List<MemberInfo> output = new List<MemberInfo>();
			CollectionExtensions.Do<Type>((IEnumerable<Type>)types, (Action<Type>)delegate(Type t)
			{
				CollectionExtensions.Do<MethodInfo>((IEnumerable<MethodInfo>)AccessTools.GetDeclaredMethods(t), (Action<MethodInfo>)delegate(MethodInfo m)
				{
					if (m.IsVirtual)
					{
						output.Add(m);
					}
				});
			});
			using FileStream stream = File.Open("VirtualMembers.txt", FileMode.Create, FileAccess.Write, FileShare.None);
			using StreamWriter streamWriter = new StreamWriter(stream, Encoding.UTF8);
			foreach (MemberInfo item in output)
			{
				streamWriter.WriteLine("<DoNotPublicize Include=\"" + item.DeclaringType.Assembly.GetName().Name + ":" + item.DeclaringType.FullName + "." + item.Name + "\"/>");
			}
		}
	}
	internal class AssignabilityComparer : IEqualityComparer<Type>
	{
		public bool Equals(Type x, Type y)
		{
			if ((object)x == y)
			{
				return true;
			}
			if (x == null || y == null)
			{
				return false;
			}
			return x.IsSubclassOf(y) || y.IsSubclassOf(x);
		}

		public int GetHashCode(Type obj)
		{
			return (!(obj == null)) ? obj.GetHashCode() : 0;
		}
	}
}
namespace LBoLEntitySideloader.PersistentValues
{
	public abstract class CustomGameRunSaveData
	{
		public const string filePrefix = "gr";

		public virtual string Name => "";

		internal virtual bool EncodeToBinary => true;

		public virtual bool DeleteFileOnGamerunEnd => true;

		public static void RegisterCustomSaveData(CustomGameRunSaveData customSaveData, string GUID)
		{
			SaveDataID iD = customSaveData.GetID(GUID);
			Assembly callingAssembly = Assembly.GetCallingAssembly();
			InternalRegisterCustomData(callingAssembly, iD, customSaveData);
		}

		public void RegisterSelf(string GUID)
		{
			SaveDataID iD = GetID(GUID);
			Assembly callingAssembly = Assembly.GetCallingAssembly();
			InternalRegisterCustomData(callingAssembly, iD, this);
		}

		public SaveDataID GetID(string GUID)
		{
			return new SaveDataID
			{
				GUID = GUID,
				Name = Name,
				midfix = "gr"
			};
		}

		private static void InternalRegisterCustomData(Assembly assembly, SaveDataID id, CustomGameRunSaveData customData)
		{
			if (assembly.IsLoadedFromDisk())
			{
				EntityManager.Instance.loadedFromDsikCustomGrSaveData.TryAdd(id, customData);
			}
			if (!UniqueTracker.Instance.customGrSaveData.TryAdd(id, customData))
			{
				Log.log.LogError((object)$"Failed to register custom save data {id}. Save data with the same name was already registered.");
			}
		}

		public virtual IEnumerable<IYamlTypeConverter> TypeConverters()
		{
			yield break;
		}

		public string ReasonableUniqueName()
		{
			return GetType().Name.Replace(".", "_");
		}

		public abstract void Save(GameRunController gameRun);

		public abstract void Restore(GameRunController gameRun);

		public virtual void OnGamerunEnded()
		{
		}
	}
	[HarmonyPatch(typeof(GameRunController), "Save")]
	[HarmonyPriority(100)]
	internal class GameRunController_Save_Patch
	{
		private static void Postfix(GameRunController __instance)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<SaveDataID, CustomGameRunSaveData> customGrSaveData = UniqueTracker.Instance.customGrSaveData;
			foreach (SaveDataID key in customGrSaveData.Keys)
			{
				CustomGameRunSaveData customGameRunSaveData = customGrSaveData[key];
				try
				{
					customGameRunSaveData.Save(__instance);
					using StringWriter stringWriter = new StringWriter
					{
						NewLine = "\n"
					};
					SerializerBuilder seBuilder = new SerializerBuilder().DisableAliases();
					CollectionExtensions.Do<IYamlTypeConverter>(customGameRunSaveData.TypeConverters(), (Action<IYamlTypeConverter>)delegate(IYamlTypeConverter tc)
					{
						seBuilder = ((BuilderSkeleton<SerializerBuilder>)(object)seBuilder).WithTypeConverter(tc);
					});
					seBuilder.Build().Serialize((TextWriter)stringWriter, (object)customGameRunSaveData);
					byte[] array = SaveDataHelper.EncodeYaml(stringWriter.ToString(), false);
					GameMaster.WriteSaveData(key.GetFileName(Singleton<GameMaster>.Instance.CurrentSaveIndex.Value), array);
				}
				catch (Exception arg)
				{
					BepinexPlugin.log.LogError((object)$"Error while saving custom save data {key}: {arg}");
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameRunController), "Restore")]
	[HarmonyPriority(700)]
	internal class GameRunController_Restore_Patch
	{
		private static void Postfix(GameRunController __result)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<SaveDataID, CustomGameRunSaveData> customGrSaveData = UniqueTracker.Instance.customGrSaveData;
			foreach (SaveDataID key in customGrSaveData.Keys)
			{
				CustomGameRunSaveData customGameRunSaveData = customGrSaveData[key];
				string fileName = key.GetFileName(Singleton<GameMaster>.Instance.CurrentSaveIndex.Value);
				string text = Path.Combine(GameMaster.PlatformHandler.GetSaveDataFolder(), fileName);
				if (!File.Exists(text))
				{
					break;
				}
				try
				{
					DeserializerBuilder deBuilder = new DeserializerBuilder().IgnoreUnmatchedProperties();
					CollectionExtensions.Do<IYamlTypeConverter>(customGameRunSaveData.TypeConverters(), (Action<IYamlTypeConverter>)delegate(IYamlTypeConverter tc)
					{
						deBuilder = ((BuilderSkeleton<DeserializerBuilder>)(object)deBuilder).WithTypeConverter(tc);
					});
					object obj = deBuilder.Build().Deserialize(SaveDataHelper.DecodeYaml(File.ReadAllBytes(text)), customGameRunSaveData.GetType());
					CustomGameRunSaveData customGameRunSaveData2 = (CustomGameRunSaveData)obj;
					customGameRunSaveData2.Restore(__result);
				}
				catch (Exception arg)
				{
					BepinexPlugin.log.LogError((object)$"Error while loading custom save data {text}: {arg}");
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameMaster), "TryDeleteSaveData")]
	internal class GameMaster_Patch
	{
		private static void Postfix(string filename)
		{
			int? currentSaveIndex = Singleton<GameMaster>.Instance.CurrentSaveIndex;
			if (!currentSaveIndex.HasValue || GameMaster.GetGameRunFileName(currentSaveIndex.Value) != filename)
			{
				return;
			}
			Dictionary<SaveDataID, CustomGameRunSaveData> customGrSaveData = UniqueTracker.Instance.customGrSaveData;
			foreach (SaveDataID key in customGrSaveData.Keys)
			{
				CustomGameRunSaveData customGameRunSaveData = customGrSaveData[key];
				string fileName = key.GetFileName(Singleton<GameMaster>.Instance.CurrentSaveIndex.Value);
				string path = Path.Combine(GameMaster.PlatformHandler.GetSaveDataFolder(), fileName);
				if (!File.Exists(path))
				{
					break;
				}
				try
				{
					customGameRunSaveData.OnGamerunEnded();
					if (customGameRunSaveData.DeleteFileOnGamerunEnd)
					{
						File.Delete(path);
					}
				}
				catch (Exception arg)
				{
					BepinexPlugin.log.LogError((object)$"Error while deleting custom save data {key}: {arg}");
				}
			}
		}
	}
	public struct SaveDataID
	{
		public string GUID;

		public string Name;

		public string midfix;

		public const string suffix = ".modd";

		public override string ToString()
		{
			return GUID + "_" + midfix + "_" + Name;
		}

		public string GetFileName(int profileIndex)
		{
			return string.Format("{0}_{1}{2}", this, profileIndex, ".modd");
		}
	}
}
namespace LBoLEntitySideloader.PersistentValues.TypeConverters
{
	public class RandomGenTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return type == typeof(RandomGen);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			ParserExtensions.Consume<MappingStart>(parser);
			ulong num = 0uL;
			while (true)
			{
				ParsingEvent current = parser.Current;
				Scalar val = (Scalar)(object)((current is Scalar) ? current : null);
				if (val == null)
				{
					break;
				}
				string value = val.Value;
				parser.MoveNext();
				if (value == "State")
				{
					num = ulong.Parse(((Scalar)parser.Current).Value);
					parser.MoveNext();
				}
			}
			ParserExtensions.Consume<MappingEnd>(parser);
			return RandomGen.FromState(num);
		}

		public void WriteYaml(IEmitter emitter, object value, Type type)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			RandomGen val = (RandomGen)value;
			ulong num = ((val != null) ? val.State : 0);
			emitter.Emit((ParsingEvent)new MappingStart());
			emitter.Emit((ParsingEvent)new Scalar("State"));
			emitter.Emit((ParsingEvent)new Scalar(num.ToString()));
			emitter.Emit((ParsingEvent)new MappingEnd());
		}
	}
}
namespace LBoLEntitySideloader.GameFixes
{
	[HarmonyPatch]
	internal class AllowDuplicateExhibits1_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return ExtraAccess.InnerMoveNext(typeof(GameRunController), "GainExhibitRunner");
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			CodeInstruction prevprevCi = null;
			CodeInstruction prevCi = null;
			MethodInfo logErrorMethod = AccessTools.Method(typeof(Debug), "LogError", new Type[1] { typeof(object) }, (Type[])null);
			foreach (CodeInstruction ci in instructions)
			{
				if (prevprevCi != null && prevCi != null && ci.opcode == OpCodes.Call && (MethodInfo)ci.operand == logErrorMethod && prevCi.opcode == OpCodes.Call && prevprevCi.opcode == OpCodes.Callvirt)
				{
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
				}
				else if (prevprevCi != null && prevCi != null && ci.opcode == OpCodes.Ret && prevCi.opcode == OpCodes.Ldc_I4_0 && prevprevCi.opcode == OpCodes.Call && (MethodInfo)prevprevCi.operand == logErrorMethod)
				{
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
				}
				else if (prevprevCi != null && prevCi != null && ci.opcode == OpCodes.Newobj && prevCi.opcode == OpCodes.Ldstr && prevprevCi.opcode == OpCodes.Ldstr && prevprevCi.operand.ToString() == "Cannot add duplicated Exhibit.")
				{
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
				}
				else if (prevprevCi != null && prevCi != null && ci.opcode == OpCodes.Throw && prevCi.opcode == OpCodes.Newobj && prevprevCi.opcode == OpCodes.Ldstr && prevprevCi.operand.ToString() == "exhibit")
				{
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
				}
				else
				{
					yield return ci;
				}
				prevprevCi = prevCi;
				prevCi = ci;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerUnit), "AddExhibit")]
	internal class AllowDuplicateExhibits2_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			CodeInstruction prevprevCi = null;
			CodeInstruction prevCi = null;
			foreach (CodeInstruction ci in instructions)
			{
				if (prevprevCi != null && prevCi != null && ci.opcode == OpCodes.Throw && prevCi.opcode == OpCodes.Newobj && prevprevCi.opcode == OpCodes.Ldstr && prevprevCi.operand.ToString() == "exhibit")
				{
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
				}
				else if (prevprevCi != null && prevCi != null && ci.opcode == OpCodes.Newobj && prevCi.opcode == OpCodes.Ldstr && prevprevCi.opcode == OpCodes.Ldstr && prevprevCi.operand.ToString() == "Cannot add duplicated Exhibit.")
				{
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
				}
				else
				{
					yield return ci;
				}
				prevprevCi = prevCi;
				prevCi = ci;
			}
		}
	}
	[HarmonyPatch(typeof(BossExhibitPanel), "OnClickExhibit")]
	internal class AllowSentinelAsBossReward_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			CodeInstruction prevCi = null;
			foreach (CodeInstruction ci in instructions)
			{
				if (prevCi != null && prevCi.opcode == OpCodes.Brfalse && ci.opcode == OpCodes.Ret)
				{
					yield return new CodeInstruction(OpCodes.Nop, (object)null);
				}
				else
				{
					yield return ci;
				}
				prevCi = ci;
			}
		}
	}
	[HarmonyPatch(typeof(BattleController), "CalculateBlockShield")]
	internal class CalculateBlockShield_RoundingFix_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: 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_0054: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).Start();
			while (val.IsValid)
			{
				val.MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MathExtensions), "RoundToInt", new Type[1] { typeof(float) }, (Type[])null))) });
				if (val.IsInvalid)
				{
					break;
				}
				val.SetInstruction(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MathExtensions), "RoundToInt", new Type[2]
				{
					typeof(float),
					typeof(MidpointRounding)
				}, (Type[])null))).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldc_I4_1, (object)null)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	internal class CardView_Patches
	{
		[HarmonyPatch(typeof(SelectCardPanel), "ViewMiniSelect")]
		private class ViewMiniSelect_Patch
		{
			private static void Prefix()
			{
				miniPanelShowing = true;
			}
		}

		[HarmonyPatch]
		private class SelectCardPanel_Patch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Method(typeof(SelectCardPanel), "ViewSelectHand", (Type[])null, (Type[])null);
				yield return AccessTools.Method(typeof(SelectCardPanel), "ViewSelectCard", (Type[])null, (Type[])null);
			}

			private static void Prefix()
			{
				miniPanelShowing = false;
			}
		}

		[HarmonyPatch]
		private class MiniPanelFadeDelegate_Patch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				Type[] nestedTypes = typeof(SelectCardPanel).GetNestedTypes(AccessTools.allDeclared);
				Type targetDelegateType = nestedTypes.SingleOrDefault((Type t) => t.Name.Contains("DisplayClass70_0"));
				if (targetDelegateType == null)
				{
					targetDelegateType = nestedTypes.SingleOrDefault((Type t) => t.Name.Contains("DisplayClass68_0"));
				}
				if (targetDelegateType == null)
				{
					throw new InvalidOperationException("No target delegate type found");
				}
				yield return AccessTools.Method(targetDelegateType, "<ViewMiniSelect>b__0", (Type[])null, (Type[])null);
			}

			private static bool PreCon()
			{
				return miniPanelShowing;
			}

			private static void PostFlip()
			{
				miniPanelShowing = false;
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0003: 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_0038: Expected O, but got Unknown
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Expected O, but got Unknown
				return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(GameObject), "SetActive", (Type[])null, (Type[])null), (string)null)
				}).Advance(-1).Set(OpCodes.Call, (object)AccessTools.Method(typeof(MiniPanelFadeDelegate_Patch), "PreCon", (Type[])null, (Type[])null))
					.Advance(2)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MiniPanelFadeDelegate_Patch), "PostFlip", (Type[])null, (Type[])null))
					})
					.InstructionEnumeration();
			}
		}

		public static bool miniPanelShowing;
	}
	[HarmonyPatch]
	internal static class Cost
	{
		[HarmonyPatch(typeof(Card), "CostChangeInUpgrading")]
		[HarmonyPrefix]
		private static bool FixCostChange(Card __instance)
		{
			//IL_0036: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_00a0: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//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)
			if (__instance.IsXCost || !__instance.Config.UpgradedCost.HasValue)
			{
				return true;
			}
			ManaGroup val = __instance.Config.Cost - __instance.Config.UpgradedCost.Value;
			if (ManaGroup.Empty == val)
			{
				return false;
			}
			ManaGroup val2 = ((__instance.Config.Cost != __instance.BaseCost) ? (__instance.BaseCost - val).GetCostCorrection() : ManaGroup.Empty);
			ManaGroup val3 = ((ManaGroup.Empty != __instance.TurnCostDelta) ? (__instance.BaseCost - val - val2 + __instance.TurnCostDelta).GetCostCorrection() : ManaGroup.Empty);
			__instance.DecreaseBaseCost(val + val2);
			__instance.DecreaseTurnCost(val3);
			return false;
		}
	}
	public static class ManaGroupExtensions
	{
		public static ManaGroup GetCostCorrection(this ManaGroup delta)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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_00f3: 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_00fc: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_012d: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: 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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup val = delta * -1;
			ManaGroup val2 = ((ManaGroup)(ref val)).Corrected;
			ManaGroup val3 = ((ManaGroup)(ref delta)).Corrected;
			ManaGroup val4 = ManaGroup.Empty;
			if (0 < ((ManaGroup)(ref val3)).Hybrid)
			{
				foreach (ManaColor getHybridColor in ((ManaGroup)(ref val3)).GetHybridColors)
				{
					int num = Math.Min(((ManaGroup)(ref val2))[getHybridColor], ((ManaGroup)(ref val3)).Hybrid);
					val2 -= ManaGroup.FromColor(getHybridColor, num);
					val4 -= ManaGroup.FromColor(getHybridColor, num);
					val3 -= ManaGroup.FromColor((ManaColor)8, num);
					val4 += ManaGroup.FromColor((ManaColor)8, num);
				}
			}
			foreach (ManaColor item in ((ManaGroup)(ref val2)).EnumerateColors())
			{
				int num2 = Math.Min(((ManaGroup)(ref val3))[(ManaColor)0], ((ManaGroup)(ref val2))[item]);
				val2 -= ManaGroup.FromColor(item, num2);
				val4 -= ManaGroup.FromColor(item, num2);
				val3 -= ManaGroup.Anys(num2);
				val4 += ManaGroup.Anys(num2);
			}
			if (0 < ((ManaGroup)(ref val2)).Hybrid)
			{
				int num3 = Math.Min(((ManaGroup)(ref val3))[(ManaColor)0], ((ManaGroup)(ref val2))[(ManaColor)8]);
				((ManaGroup)(ref val2)).Hybrid = ((ManaGroup)(ref val2)).Hybrid - num3;
				((ManaGroup)(ref val4)).Hybrid = ((ManaGroup)(ref val4)).Hybrid - num3;
				val3 -= ManaGroup.Anys(num3);
				val4 += ManaGroup.Anys(num3);
			}
			return val4;
		}
	}
	[HarmonyPatch(typeof(Card), "CardPerformAction")]
	internal class CardPerformAction_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int i = 0;
			List<CodeInstruction> ciList = instructions.ToList();
			ciList.Count();
			foreach (CodeInstruction ci in instructions)
			{
				int num;
				if (CodeInstructionExtensions.Is(ci, OpCodes.Ldc_R4, (object)0f))
				{
					CodeInstruction? obj = ciList.ElementAtOrDefault(i + 5);
					num = ((obj != null && CodeInstructionExtensions.Is(obj, OpCodes.Call, (MemberInfo)AccessTools.Method(typeof(PerformAction), "Effect", (Type[])null, (Type[])null))) ? 1 : 0);
				}
				else
				{
					num = 0;
				}
				if (num != 0)
				{
					yield return new CodeInstruction(OpCodes.Ldloc_2, (object)null);
				}
				else
				{
					int num2;
					if (CodeInstructionExtensions.Is(ci, OpCodes.Ldc_R4, (object)0f))
					{
						CodeInstruction? obj2 = ciList.ElementAtOrDefault(i + 1);
						num2 = ((obj2 != null && CodeInstructionExtensions.Is(obj2, OpCodes.Call, (MemberInfo)AccessTools.Method(typeof(PerformAction), "Sfx", (Type[])null, (Type[])null))) ? 1 : 0);
					}
					else
					{
						num2 = 0;
					}
					if (num2 != 0)
					{
						yield return new CodeInstruction(OpCodes.Ldloc_2, (object)null);
					}
					else
					{
						yield return ci;
					}
				}
				i++;
			}
		}
	}
	[HarmonyPatch(typeof(GameRunController), "BaseCardWeight")]
	internal class UncapColorLimitation_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int i = 0;
			List<CodeInstruction> ciList = instructions.ToList();
			ciList.Count();
			CodeInstruction prevCi = null;
			int patchCount = 0;
			bool skipMode = false;
			CodeInstruction jmpSwitchEnd = null;
			CodeInstruction numStore = null;
			int patchCasesTotal = 2;
			foreach (CodeInstruction ci in instructions)
			{
				if (CodeInstructionExtensions.Is(ci, OpCodes.Ldstr, (object)"Invalid cost pattern {0} of card '{1}'") && patchCount < patchCasesTotal)
				{
					skipMode = true;
					jmpSwitchEnd = prevCi;
					numStore = ciList[i - 2];
					yield return ci;
					yield return new CodeInstruction(OpCodes.Pop, (object)null);
				}
				else if (skipMode && ci.opcode == OpCodes.Throw && patchCount < patchCasesTotal)
				{
					switch (patchCount)
					{
					case 0:
						yield return new CodeInstruction(OpCodes.Ldc_R4, (object)1.2f);
						break;
					case 1:
						yield return new CodeInstruction(OpCodes.Ldc_R4, (object)1.2f);
						break;
					}
					yield return numStore;
					yield return jmpSwitchEnd;
					skipMode = false;
					patchCount++;
				}
				else if (!skipMode)
				{
					yield return ci;
				}
				prevCi = ci;
				i++;
			}
		}
	}
	[HarmonyPatch(typeof(GameRunController), "BaseCardWeight")]
	[HarmonyPriority(300)]
	internal class UncapColorLimitation_Patch2
	{
		private static float SetWeight(int trivialColors)
		{
			if (1 == 0)
			{
			}
			float result = trivialColors switch
			{
				4 => 1.3f, 
				5 => 1.4f, 
				_ => 1f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
			{
				CodeMatch.op_Implicit(OpCodes.Call),
				CodeMatch.op_Implicit(OpCodes.Call),
				CodeMatch.op_Implicit(OpCodes.Stloc_S)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Dup, (object)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(UncapColorLimitation_Patch2), "SetWeight", (Type[])null, (Type[])null))
			})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Stloc_3, (object)null)
				})
				.MatchForward(true, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(OpCodes.Throw) })
				.Set(OpCodes.Pop, (object)null)
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CardUi), "Awake")]
	internal class _13thCard_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			CodeInstruction prevCi = null;
			foreach (CodeInstruction ci in instructions)
			{
				if (ci.opcode == OpCodes.Ldc_I4_S && prevCi.opcode == OpCodes.Ldloc_0)
				{
					yield return new CodeInstruction(OpCodes.Ldc_I4, (object)99);
				}
				else
				{
					yield return ci;
				}
				prevCi = ci;
			}
		}
	}
	[HarmonyPatch(typeof(Sunny), "OnEnterBattle")]
	internal class SunnyCastBug_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction ci in instructions)
			{
				if (CodeInstructionExtensions.Is(ci, OpCodes.Castclass, (MemberInfo)typeof(LightFairy)))
				{
					yield return new CodeInstruction(OpCodes.Isinst, (object)typeof(LightFairy));
				}
				else
				{
					yield return ci;
				}
			}
		}
	}
	[HarmonyPatch(typeof(SpellPanel), "Awake")]
	internal class SpellPanel_ClearSpellCache_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			Label label = default(Label);
			return new CodeMatcher(instructions, generator).End().MatchBack(true, (CodeMatch[])(object)new CodeMatch[5]
			{
				CodeMatch.op_Implicit(OpCodes.Ldloc_1),
				CodeMatch.op_Implicit(OpCodes.Ldloc_0),
				CodeMatch.op_Implicit(OpCodes.Ldlen),
				CodeMatch.op_Implicit(OpCodes.Conv_I4),
				CodeMatch.op_Implicit(OpCodes.Blt)
			}).Advance(1)
				.CreateLabel(ref label)
				.AddLabels((IEnumerable<Label>)new Label[1] { label })
				.Start()
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"UI/Panels/SpellDeclare", (string)null)
				})
				.Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Br, (object)label)
				})
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CardUi), "SetPendingCardsAlpha")]
	internal class CardUi_SetPendingCardsAlpha_Patch
	{
		private static bool Prefix(CardUi __instance, float alpha)
		{
			try
			{
				if (__instance._pendingUseWidgets != null)
				{
					foreach (HandCard pendingUseWidget in __instance._pendingUseWidgets)
					{
						if ((Object)(object)pendingUseWidget != (Object)null && (Object)(object)pendingUseWidget.CanvasGroup != (Object)null)
						{
							pendingUseWidget.CanvasGroup.alpha = alpha;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Log.log.LogWarning((object)ex);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(AudioManager), "EnterStage")]
	internal class AudioManagerEnterStage_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0003: 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 O, but got Unknown
			return new CodeMatcher(instructions, generator).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ret, (object)null, (string)null)
			}).RemoveInstruction().InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(Debut), "ExchangeExhibit")]
	internal class DebutCantLoseFix_Patch
	{
		private static bool Prefix(Debut __instance)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			GameRunController currentGameRun = Singleton<GameMaster>.Instance.CurrentGameRun;
			if (currentGameRun != null)
			{
				Exhibit? obj = currentGameRun.Player.Exhibits.FirstOrDefault();
				if ((int)((obj != null) ? new ExhibitLosableType?(obj.LosableType) : ((ExhibitLosableType?)null)).GetValueOrDefault() == 2)
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(LimitedDamage), "OnDamageReceived")]
	internal class LimitedDamageFix_Patch
	{
		private static bool Prefix(LimitedDamage __instance, ref DamageEventArgs args)
		{
			//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)
			int count = ((StatusEffect)__instance).Count;
			DamageInfo damageInfo = args.DamageInfo;
			((StatusEffect)__instance).Count = count - Math.Min(MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage), ((StatusEffect)__instance).Count);
			return false;
		}
	}
	[HarmonyPatch(typeof(BattleManaPanel), "ViewLoseMana")]
	internal class ViewLoseManaEarrapeFix_Patch
	{
		private static List<AudioClip> audioClips;

		private static void Prefix(BattleManaPanel __instance, ref LoseManaAction action)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			if (audioClips == null || CollectionsExtensions.Empty<AudioClip>((IReadOnlyCollection<AudioClip>)audioClips))
			{
				try
				{
					audioClips = new List<AudioClip>
					{
						ResourcesHelper.LoadUiSound("Zackary/ManaLose_1.wav"),
						ResourcesHelper.LoadUiSound("Zackary/ManaLose_2.wav"),
						ResourcesHelper.LoadUiSound("Zackary/ManaLose_3.wav")
					};
				}
				catch (Exception)
				{
					BepinexPlugin.log.LogWarning((object)"Audio files not found, lose mana sound fix not applied.");
					return;
				}
			}
			AudioManager instance = Singleton<AudioManager>.Instance;
			if (instance != null && instance._uiTable.ContainsKey("ManaLose"))
			{
				ManaGroup value = ((EventBattleAction<ManaEventArgs>)(object)action).Args.Value;
				UiEntry val = new UiEntry(0.3f / (1f + (float)(((ManaGroup)(ref value)).Amount - 1) * 0.1f));
				val.Clips.AddRange(audioClips);
				Singleton<AudioManager>.Instance._uiTable.Remove("ManaLose");
				Singleton<AudioManager>.Instance._uiTable.Add("ManaLose", val);
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class BaseDeckInBossRemoveReward_Patch
	{
		private static void Postfix(ref IEnumerable<Card> __result)
		{
			__result = __result.Where((Card c) => !c.Unremovable);
		}
	}
	[HarmonyPatch(typeof(HealAction), "GetPhases")]
	internal class HealActionFix_Patch
	{
		private static bool Prefix(HealAction __instance, ref IEnumerable<Phase> __result)
		{
			if (((EventBattleAction<HealEventArgs>)(object)__instance).Args.Source == null)
			{
				__result = GetPhases(__instance);
				return false;
			}
			return true;
		}

		private static IEnumerable<Phase> GetPhases(HealAction __instance)
		{
			((GameEventArgs)((EventBattleAction<HealEventArgs>)(object)__instance).Args).ForceCancelBecause((CancelCause)2);
			yield break;
		}
	}
	[HarmonyPatch(typeof(ApplyStatusEffectAction), "PreEventPhase")]
	internal class ApplyStatusEffectActionFix_Patch
	{
		private static bool Prefix(ApplyStatusEffectAction __instance)
		{
			if (((EventBattleAction<StatusEffectApplyEventArgs>)(object)__instance).Args.Unit == null)
			{
				((GameEventArgs)((EventBattleAction<StatusEffectApplyEventArgs>)(object)__instance).Args).ForceCancelBecause((CancelCause)2);
				return false;
			}
			return true;
		}
	}
	internal class ReTargeting_Patch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: 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_0057: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).Start();
			val.MatchEndForward((CodeMatch[])(object)new CodeMatch[3]
			{
				CodeMatch.op_Implicit(OpCodes.Ldloc_2),
				CodeMatch.op_Implicit(OpCodes.Ldc_I4_3),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => ci.opcode == OpCodes.Bne_Un_S || ci.opcode == OpCodes.Bne_Un), (string)null)
			});
			if (val.IsValid)
			{
				val.Set(OpCodes.Br, val.Instruction.operand).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Pop, (object)null)
				}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Pop, (object)null)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	internal class ReimuSilencePatch
	{
		private static int CheckUpgrade(ReimuSilence reimuSilence)
		{
			return ((Card)reimuSilence).IsUpgraded ? ((Card)reimuSilence).Config.UpgradedDamage.Value : ((Card)reimuSilence).Config.Damage.Value;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(CardConfig), "Damage"))) });
			if (val.IsValid)
			{
				val.MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Call, (object)AccessTools.PropertyGetter(typeof(int?), "Value"))) }).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Pop, (object)null)
				})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldloc_1, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ReimuSilencePatch), "CheckUpgrade", (Type[])null, (Type[])null))
					});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(ShopStation), "OnEnter")]
	internal class ShopStation_Patch
	{
		private static int CheckDiscountIndex(ShopStation shopStation, int dIndex, List<ShopItem<Card>> cards)
		{
			if (dIndex >= 0 && dIndex < cards.Count)
			{
				return dIndex;
			}
			GameRunController gameRun = ((Station)shopStation).GameRun;
			return shopStation.DiscountCardNo = gameRun.ShopRng.NextInt(0, cards.Count);
		}

		private static ShopItem<Card> IndexGuard(List<ShopItem<Card>> shopCards, int index)
		{
			return CollectionsExtensions.TryGetValue<ShopItem<Card>>((IReadOnlyList<ShopItem<Card>>)shopCards, index) ?? new ShopItem<Card>((GameRunController)null, (Card)null, 420, false, false);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0003: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => ci.opcode == OpCodes.Callvirt && ci.operand is MethodBase methodBase && methodBase.Name == "get_Item"), (string)null)
			}).MatchEndBackwards((CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			})
				.Advance(1)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ShopStation_Patch), "CheckDiscountIndex", (Type[])null, (Type[])null))
				})
				.MatchEndForward((CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => ci.opcode == OpCodes.Callvirt && ci.operand is MethodBase methodBase && methodBase.Name == "get_Item"), (string)null)
				})
				.SetInstruction(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ShopStation_Patch), "IndexGuard", (Type[])null, (Type[])null)))
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(ShopPanel), "SetShop")]
	internal class ShopPanel_Patch
	{
		private static ShopItem<Card> CardIndexGuard(List<ShopItem<Card>> shopCards, int index)
		{
			return CollectionsExtensions.TryGetValue<ShopItem<Card>>((IReadOnlyList<ShopItem<Card>>)shopCards, index);
		}

		private static ShopItem<Exhibit> ExhibitIndexGuard(List<ShopItem<Exhibit>> shopExhibits, int index)
		{
			return CollectionsExtensions.TryGetValue<ShopItem<Exhibit>>((IReadOnlyList<ShopItem<Exhibit>>)shopExhibits, index);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => ci.opcode == OpCodes.Callvirt && ci.operand is MethodBase methodBase && methodBase.Name == "get_Item"), (string)null)
			}).SetInstruction(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ShopPanel_Patch), "CardIndexGuard", (Type[])null, (Type[])null))).MatchEndForward((CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => ci.opcode == OpCodes.Ldstr && ci.operand.ToString().Contains("shopExhibits")), (string)null)
			})
				.ThrowIfInvalid("shopExhibits is no longer a magic string")
				.MatchEndForward((CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => ci.opcode == OpCodes.Callvirt && ci.operand is MethodBase methodBase && methodBase.Name == "get_Item"), (string)null)
				})
				.SetInstruction(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ShopPanel_Patch), "ExhibitIndexGuard", (Type[])null, (Type[])null)))
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch]
	internal class TooltipSource_BetterFit_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.PropertyGetter(typeof(StatusTooltipSource), "TooltipPositions");
			yield return AccessTools.PropertyGetter(typeof(ExhibitTooltipSource), "TooltipPositions");
			yield return AccessTools.PropertyGetter(typeof(UltimateSkillTooltipSource), "TooltipPositions");
		}

		private static void Postfix(ref TooltipPosition[] __result)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			__result = __result.Concat((IEnumerable<TooltipPosition>)(object)new TooltipPosition[3]
			{
				new TooltipPosition((TooltipDirection)2, (TooltipAlignment)1),
				new TooltipPosition((TooltipDirection)0, (TooltipAlignment)1),
				new TooltipPosition((TooltipDirection)3, (TooltipAlignment)1)
			}).ToArray();
		}
	}
}
namespace LBoLEntitySideloader.ExtraFunc
{
	public static class CardHelper
	{
		private class SkipConsumeMana
		{
			public bool skip;

			public SkipConsumeMana(bool val)
			{
				skip = val;
			}
		}

		private class UseCardAction_Patch
		{
			private static Type delegateType = typeof(UseCardAction).GetNestedTypes(AccessTools.allDeclared).Single((Type t) => t.Name.Contains("DisplayClass17_0"));

			private static FieldInfo useCardAtionInstField = AccessTools.Field(delegateType, "<>4__this");

			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Method(delegateType, "<GetPhases>b__1", (Type[])null, (Type[])null);
			}

			private static bool CheckArgs(UseCardAction useCardAction)
			{
				if (wt_skipConsumeMana.TryGetValue(useCardAction, out var value))
				{
					return value.skip;
				}
				return false;
			}

			private static void ConsumeArgs(BattleController battle, Reactor reactor, GameEntity gameEntity, ActionCause actionCause)
			{
			}

			private static int AdjustMoney(int money, UseCardAction useCardAction)
			{
				if (wt_skipConsumeMana.TryGetValue(useCardAction, out var _))
				{
					GameMaster instance = Singleton<GameMaster>.Instance;
					int? obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						GameRunController currentGameRun = instance.CurrentGameRun;
						obj = ((currentGameRun != null) ? new int?(currentGameRun.Money) : ((int?)null));
					}
					int? num = obj;
					if (num.HasValue)
					{
						return Math.Min(money, num.Value);
					}
				}
				return money;
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0003: 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_0048: Expected O, but got Unknown
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: 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_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Expected O, but got Unknown
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Expected O, but got Unknown
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Expected O, but got Unknown
				//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Expected O, but got Unknown
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Expected O, but got Unknown
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Expected O, but got Unknown
				//IL_021d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Expected O, but got Unknown
				//IL_023a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Expected O, but got Unknown
				//IL_0268: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Expected O, but got Unknown
				Label label = default(Label);
				Label label2 = default(Label);
				return new CodeMatcher(instructions, generator).End().MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Newobj, (object)AccessTools.Constructor(typeof(ConsumeManaAction), new Type[1] { typeof(ManaGroup) }, false))) }).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(BattleController), "React", new Type[3]
				{
					typeof(Reactor),
					typeof(GameEntity),
					typeof(ActionCause)
				}, (Type[])null))) })
					.Advance(1)
					.CreateLabel(ref label)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1] { CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(UseCardAction_Patch), "ConsumeArgs", (Type[])null, (Type[])null)), new Label[1] { label }) })
					.Advance(1)
					.CreateLabel(ref label2)
					.Advance(-1)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Br, (object)label2)
					})
					.Advance(-1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldfld, (object)useCardAtionInstField)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(UseCardAction_Patch), "CheckArgs", (Type[])null, (Type[])null))
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4_0, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Bne_Un, (object)label)
					})
					.MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Newobj, (object)AccessTools.Constructor(typeof(ConsumeMoneyAction), new Type[1] { typeof(int) }, false))) })
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldfld, (object)useCardAtionInstField)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(UseCardAction_Patch), "AdjustMoney", (Type[])null, (Type[])null))
					})
					.InstructionEnumeration();
			}
		}

		private static ConditionalWeakTable<UseCardAction, SkipConsumeMana> wt_skipConsumeMana;

		[Obsolete("Use vanilla PlayCardAction instead", true)]
		public static UseCardAction AutoCastAction(Card card, UnitSelector unitSelector, ManaGroup consmingMana, bool skipConsumeManaAction = true)
		{
			throw new NotSupportedException("Don't use AutoCastAction, use vanilla PlayCardAction instead");
		}

		[Obsolete("Why are you using this", true)]
		public static void FakeQueueConsumingMana()
		{
			throw new NotSupportedException("Why are you using this");
		}
	}
	public class CoroutineExtender : IEnumerable
	{
		public IEnumerator target_enumerator;

		public IEnumerator preEnum;

		public IEnumerator postEnum;

		public List<IEnumerator> midEnums = new List<IEnumerator>();

		public CoroutineExtender()
		{
		}

		public CoroutineExtender(IEnumerator target_enumerator)
		{
			this.target_enumerator = target_enumerator;
		}

		public IEnumerator GetEnumerator()
		{
			while (preEnum?.MoveNext() ?? false)
			{
				yield return preEnum.Current;
			}
			int i = 0;
			while (target_enumerator.MoveNext())
			{
				yield return target_enumerator.Current;
				if (i < midEnums.Count && midEnums[i] != null)
				{
					while (midEnums[i].MoveNext())
					{
						yield return midEnums[i].Current;
					}
				}
				i++;
			}
			while (postEnum?.MoveNext() ?? false)
			{
				yield return preEnum.Current;
			}
		}
	}
}
namespace LBoLEntitySideloader.ExtraFunc.GunHelpers
{
	public enum PieceColor
	{
		Default,
		Red,
		RedOrange,
		Orange,
		Yellow,
		YellowGreen,
		Lime,
		Cyan,
		SkyBlue,
		Blue,
		Purple,
		Magenta,
		Pink,
		Grayscale,
		RandomHue,
		RandomPalette
	}
	public enum ColorMode
	{
		CycleByGroup = 1,
		CycleByWay,
		RandomPerBullet
	}
	public static class PieceColorHelper
	{
		public static int[][] Constant(PieceColor color)
		{
			return new int[1][] { new int[1] { (int)color } };
		}

		public static int[][] CycleByGroup(params PieceColor[] colors)
		{
			return CreateCyclingPattern(ColorMode.CycleByGroup, colors);
		}

		public static int[][] CycleByWay(params PieceColor[] colors)
		{
			return CreateCyclingPattern(ColorMode.CycleByWay, colors);
		}

		public static int[][] RandomPerBullet(params PieceColor[] colors)
		{
			return CreateCyclingPattern(ColorMode.RandomPerBullet, colors);
		}

		public static int[][] RainbowByGroup()
		{
			return CycleByGroup(PieceColor.Red, PieceColor.RedOrange, PieceColor.Orange, PieceColor.Yellow, PieceColor.YellowGreen, PieceColor.Lime, PieceColor.Cyan, PieceColor.SkyBlue, PieceColor.Blue, PieceColor.Purple, PieceColor.Magenta, PieceColor.Pink);
		}

		public static int[][] RainbowByWay()
		{
			return CycleByWay(PieceColor.Red, PieceColor.RedOrange, PieceColor.Orange, PieceColor.Yellow, PieceColor.YellowGreen, PieceColor.Lime, PieceColor.Cyan, PieceColor.SkyBlue, PieceColor.Blue, PieceColor.Purple, PieceColor.Magenta, PieceColor.Pink);
		}

		public static int[][] CompletelyRandom()
		{
			return Constant(PieceColor.RandomHue);
		}

		public static int[][] RandomFromPalette()
		{
			return Constant(PieceColor.RandomPalette);
		}

		private static int[][] CreateCyclingPattern(ColorMode mode, PieceColor[] colors)
		{
			if (colors == null || colors.Length == 0)
			{
				throw new ArgumentException("Must provide at least one color");
			}
			int[] array = colors.Select((PieceColor c) => (int)c).ToArray();
			return new int[2][]
			{
				new int[1] { (int)mode },
				array
			};
		}
	}
	public class PieceEvent
	{
		public PieceEventType Type { get; set; }

		public EventMode Mode { get; set; }

		public float[][] Number { get; set; }

		public int[][] Start { get; set; }

		public int[][] Duration { get; set; }

		public PieceEvent(PieceEventType type, float[][] number, int[][] start, int[][] duration, EventMode mode = EventMode.Add)
		{
			Type = type;
			Mode = mode;
			Number = number;
			Start = start;
			Duration = duration;
		}
	}
	public static class PieceConfigExtensions
	{
		public static PieceConfig ConfigureEvents(this PieceConfig config, Action<PieceEventBuilder> configure)
		{
			PieceEventBuilder pieceEventBuilder = new PieceEventBuilder();
			configure(pieceEventBuilder);
			pieceEventBuilder.ApplyTo(config);
			return config;
		}
	}
	public class PieceEventBuilder
	{
		private readonly List<PieceEvent> _events = new List<PieceEvent>();

		public int Count => _events.Count;

		public PieceEventBuilder Add(PieceEvent pieceEvent)
		{
			_events.Add(pieceEvent);
			return this;
		}

		public PieceEventBuilder Add(PieceEventType type, float value = 1f, int startTime = 0, int duration = 1, EventMode mode = EventMode.Add)
		{
			_events.Add(new PieceEvent(type, PieceMatrixHelper.Constant(value), PieceMatrixHelper.ConstantInt(startTime), PieceMatrixHelper.ConstantInt(duration), mode));
			return this;
		}

		public PieceEventBuilder Add(PieceEventType type, float[][] number, int[][] start, int[][] duration, EventMode mode = EventMode.Add)
		{
			_events.Add(new PieceEvent(type, number, start, duration, mode));
			return this;
		}

		public PieceEventBuilder AddComplex(PieceEventType type, float valueBase = 1f, float valuePerGroup = 0f, float valuePerWay = 0f, int startBase = 0, int startPerGroup = 0, int startPerWay = 0, int durationBase = 60, int durationPerGroup = 0, int durationPerWay = 0, EventMode mode = EventMode.Add)
		{
			_events.Add(new PieceEvent(type, PieceMatrixHelper.Matrix(valueBase, valuePerGroup, valuePerWay), PieceMatrixHelper.MatrixInt(startBase, startPerGroup, startPerWay), PieceMatrixHelper.MatrixInt(durationBase, durationPerGroup, durationPerWay), mode));
			return this;
		}

		public PieceEventBuilder Clear()
		{
			_events.Clear();
			return this;
		}

		public void ApplyTo(PieceConfig config)
		{
			if (_events.Count == 0)
			{
				config.EvStart = Array.Empty<int[][]>();
				config.EvDuration = Array.Empty<int[][]>();
				config.EvNumber = Array.Empty<float[][]>();
				config.EvType = Array.Empty<int[]>();
				return;
			}
			int count = _events.Count;
			config.EvStart = new int[count][][];
			config.EvDuration = new int[count][][];
			config.EvNumber = new float[count][][];
			config.EvType = new int[count][];
			for (int i = 0; i < count; i++)
			{
				PieceEvent pieceEvent = _events[i];
				config.EvStart[i] = pieceEvent.Start;
				config.EvDuration[i] = pieceEvent.Duration;
				config.EvNumber[i] = pieceEvent.Number;
				config.EvType[i] = ((pieceEvent.Mode == EventMode.Add) ? new int[1] { (int)pieceEvent.Type } : new int[2]
				{
					(int)pieceEvent.Type,
					(int)pieceEvent.Mode
				});
			}
		}

		public static void ApplyEvents(PieceConfig config, PieceEventBuilder builder)
		{
			builder?.ApplyTo(config);
		}

		public PieceEventBuilder AddSpeed(float speed, int startTime = 0, int duration = 1, EventMode mode = EventMode.Add)
		{
			return Add(PieceEventType.Speed, speed, startTime, duration, mode);
		}

		public PieceEventBuilder AddAngle(float angle, int startTime = 0, int duration = 1, EventMode mode = EventMode.Add)
		{
			return Add(PieceEventType.Angle, angle, startTime, duration, mode);
		}

		public PieceEventBuilder AddScale(float scale, int startTime = 0, int duration = 1, EventMode mode = EventMode.Add)
		{
			return Add(PieceEventType.ScaleUniform, scale, startTime, duration, mode);
		}

		public PieceEventBuilder AddHoming(int startTime, int duration = 1, float turnRate = 0f, bool snapToTarget = false)
		{
			EventMode mode = ((turnRate == 0f && snapToTarget) ? EventMode.Transition : EventMode.Add);
			return Add(PieceEventType.Homing, turnRate, startTime, duration, mode);
		}

		public PieceEventBuilder AddBounce(int startTime, int bounceCount = 0, bool useCardinalDirections = false, bool aimAtTargetOnBounce = false)
		{
			PieceEventType type = (useCardinalDirections ? PieceEventType.BounceCardinal : PieceEventType.BounceReflect);
			EventMode mode = (aimAtTargetOnBounce ? EventMode.Transition : EventMode.Add);
			return Add(type, bounceCount, startTime, 120, mode);
		}
	}
	public enum PieceEventType
	{
		Speed = 1,
		Angle = 2,
		Acceleration = 3,
		AccelerationAngle = 4,
		Homing = 5,
		BounceReflect = 9,
		BounceCardinal = 10,
		PositionX = 11,
		PositionY = 12,
		ScaleUniform = 13,
		ScaleY = 14,
		ScaleX = 15,
		MoveForward = 16,
		MovePerpendicular = 17,
		MoveAccAngleForward = 18,
		MoveAccAnglePerpendicular = 19,
		Huali = 99
	}
	public enum EventMode
	{
		Add,
		Transition,
		Multiply
	}
	public static class PieceMatrixHelper
	{
		public static float[][] Matrix(float baseValue = 0f, float baseRandom = 0f, float perGroup = 0f, float perGroupRandom = 0f, float perGroupSquared = 0f, float perGroupSquaredRandom = 0f, float perWay = 0f, float perWayRandom = 0f)
		{
			List<float[]> list = new List<float[]>();
			AddRow(list, baseValue, baseRandom);
			AddRow(list, perGroup, perGroupRandom);
			AddRow(list, perGroupSquared, perGroupSquaredRandom);
			AddRow(list, perWay, perWayRandom);
			while (list.Count > 1 && IsZeroRow(list[list.Count - 1]))
			{
				list.RemoveAt(list.Count - 1);
			}
			return (list.Count > 0) ? list.ToArray() : new float[1][] { new float[1] };
		}

		public static int[][] MatrixInt(int baseValue = 0, int baseRandom = 0, int perGroup = 0, int perGroupRandom = 0, int perGroupSquared = 0, int perGroupSquaredRandom = 0, int perWay = 0, int perWayRandom = 0)
		{
			List<int[]> list = new List<int[]>();
			AddRow(list, baseValue, baseRandom);
			AddRow(list, perGroup, perGroupRandom);
			AddRow(list, perGroupSquared, perGroupSquaredRandom);
			AddRow(list, perWay, perWayRandom);
			while (list.Count > 1 && IsZeroRow(list[list.Count - 1]))
			{
				list.RemoveAt(list.Count - 1);
			}
			return (list.Count > 0) ? list.ToArray() : new int[1][] { new int[1] };
		}

		public static int[][] Way(int baseCount = 1, int baseRandom = 0, int perGroup = 0, int perGroupRandom = 0)
		{
			List<int[]> list = new List<int[]>();
			AddRow(list, baseCount, baseRandom);
			AddRow(list, perGroup, perGroupRandom);
			while (list.Count > 1 && IsZeroRow(list[list.Count - 1]))
			{
				list.RemoveAt(list.Count - 1);
			}
			return list.ToArray();
		}

		private static void AddRow(List<float[]> rows, float value, float random)
		{
			if (random != 0f)
			{
				rows.Add(new float[2] { value, random });
			}
			else
			{
				rows.Add(new float[1] { value });
			}
		}

		private static void AddRow(List<int[]> rows, int value, int random)
		{
			if (random != 0)
			{
				rows.Add(new int[2] { value, random });
			}
			else
			{
				rows.Add(new int[1] { value });
			}
		}

		private static bool IsZeroRow(float[] row)
		{
			return row.All((float v) => v == 0f);
		}

		private static bool IsZeroRow(int[] row)
		{
			return row.All((int v) => v == 0);
		}

		public static float[][] Constant(float value)
		{
			return new float[1][] { new float[1] { value } };
		}

		public static int[][] ConstantInt(int value)
		{
			return new int[1][] { new int[1] { value } };
		}

		public static float[][] Random(float baseValue, float randomRange)
		{
			return new float[1][] { new float[2] { baseValue, randomRange } };
		}

		public static int[][] RandomInt(int baseValue, int randomRange)
		{
			return new int[1][] { new int[2] { baseValue, randomRange } };
		}

		public static float[][] LinearSpread(float baseValue, float perGroup)
		{
			return new float[2][]
			{
				new float[1] { baseValue },
				new float[1] { perGroup }
			};
		}

		public static float[][] WaySpread(float baseValue, float perWay)
		{
			return new float[4][]
			{
				new float[1] { baseValue },
				new float[1],
				new float[1],
				new float[1] { perWay }
			};
		}

		public static float[][] Zero()
		{
			return new float[1][] { new float[1] };
		}

		public static int[][] ZeroInt()
		{
			return new int[1][] { new int[1] };
		}
	}
}
namespace LBoLEntitySideloader.Entities
{
	public abstract class AdventureTemplate : EntityDefinition, IConfigProvider<AdventureConfig>, IAdventureProvider<Adventure>, ITypeProvider<Adventure>, IResourceConsumer<LocalizationOption>, IResourceConsumer<AdventureImages>, IResourceConsumer<YarnData>
	{
		public override Type ConfigType()
		{
			return typeof(AdventureConfig);
		}

		public override Type TemplateType()
		{
			return typeof(AdventureTemplate);
		}

		public override Type EntityType()
		{
			return typeof(Adventure);
		}

		public AdventureConfig DefaultConfig()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			return new AdventureConfig(0, (string)GetId(), "", "", 0, false, false);
		}

		public abstract AdventureConfig MakeConfig();

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption resource)
		{
			ProcessLocalization(resource, EntityType());
		}

		public abstract AdventureImages LoadAdventureImages();

		public void Consume(AdventureImages resource)
		{
			if (resource == null)
			{
				return;
			}
			if ((Object)(object)resource.main != (Object)null)
			{
				AdventureRegistry.RegisterAdventureImage(base.UniqueId, resource.main);
			}
			foreach (KeyValuePair<string, Texture2D> extraImage in resource.extraImages)
			{
				if ((Object)(object)extraImage.Value != (Object)null)
				{
					AdventureRegistry.RegisterAdventureImage(extraImage.Key, extraImage.Value);
				}
			}
		}

		public abstract YarnData LoadYarnData();

		public void Consume(YarnData resource)
		{
			if (resource != null)
			{
				AdventureRegistry.RegisterYarnData(base.UniqueId, resource);
			}
		}
	}
	public abstract class BgmTemplate : EntityDefinition, IConfigProvider<BgmConfig>
	{
		[HarmonyPatch(typeof(ResourcesHelper), "LoadBgmAsync")]
		internal class BgmLoad_Patch
		{
			private static bool Prefix(string path, ref UniTask<AudioClip> __result)
			{
				//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)
				string id = path.TrimStart('/');
				if (UniqueTracker.Instance.IsLoadedOnDemand(typeof(BgmTemplate), id, out var entityDefinition))
				{
					if (entityDefinition is BgmTemplate bgmTemplate && EntityManager.HandleOverwriteWrap(delegate
					{
					}, bgmTemplate, "LoadAudioClipAsync", bgmTemplate.user))
					{
						__result = bgmTemplate.LoadAudioClipAsync();
						return false;
					}
					return true;
				}
				return true;
			}
		}

		public override Type TemplateType()
		{
			return typeof(BgmTemplate);
		}

		public override Type ConfigType()
		{
			return typeof(BgmConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public BgmConfig DefaultConfig()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			return new BgmConfig("", 0, "", "", "", 1f, (float?)null, (float?)null, (float?)null, "", "", "", "");
		}

		public abstract BgmConfig MakeConfig();

		public abstract UniTask<AudioClip> LoadAudioClipAsync();
	}
	public abstract class BulletTemplate : EntityDefinition, IConfigProvider<BulletConfig>
	{
		public override Type ConfigType()
		{
			return typeof(BulletConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(BulletTemplate);
		}

		public BulletConfig DefaultConfig()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			return new BulletConfig("", "", "FireCommon", "CommonLaunchLight", "HitBody", "CommonHitBody", "HitShield", "CommonHitShield", "HitBlock", "CommonHitShield", "", "CommonGraze");
		}

		public abstract BulletConfig MakeConfig();
	}
	public abstract class CardTemplate : EntityDefinition, IConfigProvider<CardConfig>, IGameEntityProvider<Card>, ITypeProvider<Card>, IResourceConsumer<CardImages>, IResourceConsumer<LocalizationOption>
	{
		public static class VanillaCharNames
		{
			public const string Reimu = "Reimu";

			public const string Marisa = "Marisa";

			public const string Sakuya = "Sakuya";

			public const string Cirno = "Cirno";

			public const string Koishi = "Koishi";
		}

		public override Type TemplateType()
		{
			return typeof(CardTemplate);
		}

		public override Type ConfigType()
		{
			return typeof(CardConfig);
		}

		public override Type EntityType()
		{
			return typeof(Card);
		}

		public CardConfig DefaultConfig()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			return new CardConfig(0, "", 10, true, new string[0][], "", "", 0, false, true, false, true, true, (Rarity)0, (CardType)0, (TargetType?)null, (IReadOnlyList<ManaColor>)new List<ManaColor>(), false, default(ManaGroup), (ManaGroup?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)0, (Keyword)0, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (string)null, "", "", "", false, (string)null, (IReadOnlyList<string>)new List<string>());
		}

		public abstract CardConfig MakeConfig();

		public abstract CardImages LoadCardImages();

		public void Consume(CardImages cardImages)
		{
			if (cardImages == null)
			{
				return;
			}
			ResourcesHelper.CardImages.AlwaysAdd(base.UniqueId, (Texture)(object)cardImages.main);
			if ((Object)(object)cardImages.upgrade != (Object)null)
			{
				ResourcesHelper.CardImages.AlwaysAdd(string.Concat(base.UniqueId, CardImages.upgradeString), (Texture)(object)cardImages.upgrade);
			}
			IReadOnlyList<string> subIllustrator = CardConfig.FromId((string)base.UniqueId).SubIllustrator;
			int num = subIllustrator.Count();
			if (num < cardImages.subs.Count)
			{
				BepinexPlugin.log.LogWarning((object)$"{base.UniqueId}: more subImages than subArtists' names");
			}
			foreach (KeyValuePair<string, Texture2D> sub in cardImages.subs)
			{
				if ((Object)(object)sub.Value != (Object)null)
				{
					ResourcesHelper.CardImages.AlwaysAdd(sub.Key, (Texture)(object)sub.Value);
				}
			}
		}

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption locOptions)
		{
			ProcessLocalization(locOptions, EntityType());
		}
	}
	public abstract class EffectTemplate : EntityDefinition, IConfigProvider<EffectConfig>, IResourceConsumer<EffectWidgetData>
	{
		[HarmonyPatch(typeof(EffectWidget), "Awake")]
		private class EffectWidget_InitArrays_Patch
		{
			private static void Prefix(EffectWidget __instance)
			{
				if (__instance.particleSystemElements == null)
				{
					__instance.particleSystemElements = (ParticleSystemElement[])(object)new ParticleSystemElement[0];
				}
				if (__instance.trailRendererElements == null)
				{
					__instance.trailRendererElements = (TrailRendererElement[])(object)new TrailRendererElement[0];
				}
			}
		}

		public override Type ConfigType()
		{
			return typeof(EffectConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(EffectTemplate);
		}

		public EffectConfig DefaultConfig()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return new EffectConfig("", "", 0f);
		}

		public abstract EffectConfig MakeConfig();

		public abstract EffectWidgetData LoadEffectData();

		public void Consume(EffectWidgetData effectData)
		{
			EffectWidget value = default(EffectWidget);
			if (effectData.effectGo.TryGetComponent<EffectWidget>(ref value))
			{
				Singleton<EffectManager>.Instance._effectDictionary.AlwaysAdd(EffectConfig.FromName((string)base.UniqueId).Path, value);
			}
			else
			{
				Log.log.LogWarning((object)string.Format("Failed to get {0} for Effect with Name: {1}", "EffectWidget", base.UniqueId));
			}
		}
	}
	public abstract class EnemyGroupTemplate : EntityDefinition, IConfigProvider<EnemyGroupConfig>
	{
		public static class VanillaFormations
		{
			public const string Single = "Single";

			public const string Heng = "Heng";

			public const string Shu = "Shu";

			public const string Triangle = "Triangle";

			public const string Triangle2 = "Triangle2";

			public const string Summoner = "Summoner";

			public const string Diamond = "Diamond";

			public const string Square = "Square";

			public const string Five = "Five";

			public const string Five2 = "Five2";

			public const string Lore = "Lore";

			public const string Reimu = "Reimu";

			public const string Yuyuko = "Yuyuko";

			public const string Siji = "Siji";

			public const string Doremy = "Doremy";

			public const string Seija = "Seija";
		}

		public static HashSet<string> customFormations = new HashSet<string>();

		public static HashSet<Action> loadedFromDiskCustomFormations = new HashSet<Action>();

		public override Type ConfigType()
		{
			return typeof(EnemyGroupConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(EnemyGroupTemplate);
		}

		public static void AddFormation(string name, Dictionary<int, Vector2> enemyLocations, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			Action item = delegate
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				//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)
				if (!Singleton<GameDirector>.Instance.Formations.ContainsKey(name))
				{
					GameObject val = new GameObject(name);
					EnemyFormation val2 = val.AddComponent<EnemyFormation>();
					customFormations.Add(name);
					val.transform.SetParent(Singleton<GameDirector>.Instance.unitRoot);
					val.transform.position = Singleton<GameDirector>.Instance.unitRoot.position;
					Singleton<GameDirector>.Instance.Formations.Add(name, val2);
					val2.enemyLocations = new AssociationList<int, Transform>();
					{
						foreach (KeyValuePair<int, Vector2> enemyLocation in enemyLocations)
						{
							GameObject val3 = new GameObject(enemyLocation.Key.ToString());
							val3.transform.SetParent(((Component)val2).transform);
							val3.transform.localPosition = Vector2.op_Implicit(enemyLocation.Value);
							val2.enemyLocations.Add(enemyLocation.Key, val3.transform);
						}
						return;
					}
				}
				Log.log.LogError((object)("Formation with name " + name + " is already present"));
			};
			if (callingAssembly.IsLoadedFromDisk())
			{
				loadedFromDiskCustomFormations.Add(item);
			}
			UniqueTracker.Instance.formationAddActions.Add(item);
		}

		internal static void ReloadFormations()
		{
			List<GameObject> formationsToDestroy = FindFormationsToUnload();
			UnloadCustomFormations(formationsToDestroy);
			LoadCustomFormations();
		}

		internal static void LoadCustomFormations()
		{
			CollectionExtensions.Do<Action>((IEnumerable<Action>)UniqueTracker.Instance.formationAddActions, (Action<Action>)delegate(Action a)
			{
				a();
			});
		}

		internal static List<GameObject> FindFormationsToUnload()
		{
			List<GameObject> list = new List<GameObject>();
			EnemyFormation val = default(EnemyFormation);
			foreach (object item in Singleton<GameDirector>.Instance.unitRoot)
			{
				GameObject gameObject = ((Component)((item is Transform) ? item : null)).gameObject;
				if (gameObject.TryGetComponent<EnemyFormation>(ref val) && customFormations.Contains(((Object)gameObject).name))
				{
					list.Add(gameObject);
				}
			}
			customFormations.Clear();
			return list;
		}

		internal static void UnloadCustomFormations(List<GameObject> formationsToDestroy)
		{
			foreach (GameObject item in formationsToDestroy)
			{
				Singleton<GameDirector>.Instance.Formations.Remove(((Object)item).name);
				Object.Destroy((Object)(object)item);
			}
		}

		public EnemyGroupConfig DefaultConfig()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			return new EnemyGroupConfig("", false, (IReadOnlyList<string>)new List<string>(), "", "Single", (IReadOnlyList<string>)new List<string>(), (EnemyType)1, false, 1f, false, new Vector2(-4f, 0.5f), "", "", "");
		}

		public abstract EnemyGroupConfig MakeConfig();
	}
	public abstract class EnemyUnitTemplate : EntityDefinition, IConfigProvider<EnemyUnitConfig>, IGameEntityProvider<EnemyUnit>, ITypeProvider<EnemyUnit>, IResourceConsumer<LocalizationOption>
	{
		public override Type ConfigType()
		{
			return typeof(EnemyUnitConfig);
		}

		public override Type EntityType()
		{
			return typeof(EnemyUnit);
		}

		public override Type TemplateType()
		{
			return typeof(EnemyUnitTemplate);
		}

		public static void AddBossNodeIcon(string enemyUnitId, Func<Sprite> getSprite, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			Action action = delegate
			{
				Sprite value = getSprite();
				ResourcesHelper.BossIcons.AlwaysAdd(enemyUnitId, value);
			};
			EntityManager.Instance.addBossIconsActions.AddAction(enemyUnitId, action, callingAssembly);
		}

		public EnemyUnitConfig DefaultConfig()
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			return new EnemyUnitConfig("", false, false, (IReadOnlyList<ManaColor>)new List<ManaColor>(), 10, "", "", (EnemyType)1, false, (float?)null, (int?)null, 1, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, default(MinMax), new MinMax(5, 5), (IReadOnlyList<string>)new List<string> { "Simple1" }, (IReadOnlyList<string>)new List<string> { "Simple2" }, (IReadOnlyList<string>)new List<string> { "Simple3" }, (IReadOnlyList<string>)new List<string> { "Simple4" });
		}

		public abstract EnemyUnitConfig MakeConfig();

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption resource)
		{
			ProcessLocalization(resource, EntityType());
		}
	}
	public interface IConfigProvider<out C> where C : class
	{
		C DefaultConfig();

		C MakeConfig();
	}
	public interface ITypeProvider<T> where T : class
	{
	}
	public interface IGameEntityProvider<E> : ITypeProvider<E> where E : GameEntity
	{
	}
	public interface IAdventureProvider<A> : ITypeProvider<A> where A : Adventure
	{
	}
	public abstract class EntityDefinition
	{
		public Assembly userAssembly;

		public UserInfo user;

		public IdContainer UniqueId => UniqueTracker.GetUniqueId(this);

		public abstract IdContainer GetId();

		public abstract Type ConfigType();

		public abstract Type TemplateType();

		public abstract Type EntityType();

		internal void ProcessLocalization(LocalizationOption locOption, Type facType)
		{
			if (locOption == null)
			{
				return;
			}
			Type entityLogicType = SideloaderUsers.GetEntityLogicType(userAssembly, GetType());
			if (locOption is GlobalLocalization globalLocalization)
			{
				UniqueTracker.Instance.typesToLocalize.TryAdd(userAssembly, new Dictionary<Type, LocalizationInfo>());
				Dictionary<Type, LocalizationInfo> dictionary = UniqueTracker.Instance.typesToLocalize[userAssembly];
				dictionary.TryAdd(EntityType(), new LocalizationInfo());
				LocalizationInfo localizationInfo = dictionary[EntityType()];
				if (CollectionsExtensions.NotEmpty<KeyValuePair<Locale, Func<YamlMappingNode>>>((IReadOnlyCollection<KeyValuePair<Locale, Func<YamlMappingNode>>>)globalLocalization.LocalizationFiles.locTable))
				{
					if (localizationInfo.locFiles == null)
					{
						localizationInfo.locFiles = globalLocalization.LocalizationFiles;
					}
					else
					{
						ManualLogSource obj = Log.LogDevExtra();
						if (obj != null)
						{
							obj.LogWarning((object)$"{userAssembly.GetName().Name}: {GetType()} tries to set global localization files but they've already been set by another {TemplateType().Name}.");
						}
					}
				}
				localizationInfo.entityLogicTypes.Add(entityLogicType);
			}
			else if (locOption is LocalizationFiles localizationFiles)
			{
				Dictionary<string, Dictionary<string, object>> termDic = localizationFiles.LoadLocTable(EntityType(), new Type[1] { entityLogicType });
				LocalizationOption.FillLocalizationTables(termDic, facType, localizationFiles.mergeTerms);
			}
			else if (locOption is DirectLocalization directLocalization)
			{
				Dictionary<string, Dictionary<string, object>> termDic2 = directLocalization.WrapTermDic(UniqueId);
				LocalizationOption.FillLocalizationTables(termDic2, facType, directLocalization.mergeTerms);
			}
			else if (locOption is BatchLocalization batchLocalization)
			{
				batchLocalization.RegisterSelf(userAssembly);
			}
		}
	}
	public abstract class ExhibitTemplate : EntityDefinition, IConfigProvider<ExhibitConfig>, IGameEntityProvider<Exhibit>, ITypeProvider<Exhibit>, IResourceConsumer<LocalizationOption>, IResourceConsumer<ExhibitSprites>
	{
		public override Type TemplateType()
		{
			return typeof(ExhibitTemplate);
		}

		public override Type ConfigType()
		{
			return typeof(ExhibitConfig);
		}

		public override Type EntityType()
		{
			return typeof(Exhibit);
		}

		public ExhibitConfig DefaultConfig()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			return new ExhibitConfig(0, "", 10, false, true, false, false, (AppearanceType)2, "", (ExhibitLosableType)0, (Rarity)0, (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (ManaColor?)null, (ManaColor?)null, 0, false, (int?)null, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}

		public abstract ExhibitConfig MakeConfig();

		public abstract ExhibitSprites LoadSprite();

		public void Consume(ExhibitSprites sprites)
		{
			if (sprites == null)
			{
				return;
			}
			if ((Object)(object)sprites.main != (Object)null)
			{
				ResourcesHelper.Sprites[typeof(Exhibit)].AlwaysAdd(base.UniqueId, sprites.main);
			}
			else
			{
				ManualLogSource obj = Log.LogDev();
				if (obj != null)
				{
					obj.LogWarning((object)$"Exhibit {base.UniqueId} of {GetType().Name} definition doesn't have the main sprite set.");
				}
			}
			foreach (KeyValuePair<string, Sprite> item in sprites.LoadMany())
			{
				if ((Object)(object)item.Value != (Object)null)
				{
					ResourcesHelper.Sprites[typeof(Exhibit)].AlwaysAdd(string.Concat(base.UniqueId, item.Key), item.Value);
				}
			}
		}

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption locOptions)
		{
			ProcessLocalization(locOptions, EntityType());
		}
	}
	public abstract class GunTemplate : EntityDefinition, IConfigProvider<GunConfig>
	{
		public override Type ConfigType()
		{
			return typeof(GunConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(GunTemplate);
		}

		public GunConfig DefaultConfig()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			return new GunConfig(120000, "", "", "", "shoot1", (float?)null, false, 0f, (float?)null, "Direct", 1f);
		}

		public abstract GunConfig MakeConfig();
	}
	public abstract class IntentionTemplate : EntityDefinition, IGameEntityProvider<Intention>, ITypeProvider<Intention>, IResourceConsumer<LocalizationOption>, IResourceConsumer<IntentionImages>
	{
		public override Type ConfigType()
		{
			return typeof(IntentionMockConfig);
		}

		public override Type EntityType()
		{
			return typeof(Intention);
		}

		public override Type TemplateType()
		{
			return typeof(IntentionTemplate);
		}

		public static Intention CreateIntention(Type intentionType)
		{
			return TypeFactory<Intention>.TryCreateInstance(intentionType);
		}

		public static T CreateIntention<T>() where T : Intention
		{
			return (T)(object)CreateIntention(typeof(T));
		}

		public virtual string SelectAltIconsSuffix(Intention intention)
		{
			return "";
		}

		public abstract LocalizationOption LoadLocalization();

		public abstract IntentionImages LoadSprites();

		public void Consume(LocalizationOption locOptions)
		{
			ProcessLocalization(locOptions, EntityType());
		}

		public void Consume(IntentionImages sprites)
		{
			if (sprites == null)
			{
				return;
			}
			string text = base.UniqueId.ToString();
			if (text.EndsWith("Intention"))
			{
				text = BasicTypeExtensions.RemoveEnd(text, "Intention");
			}
			if ((Object)(object)sprites.main != (Object)null)
			{
				ResourcesHelper.IntentionSprites.AlwaysAdd(text, sprites.main);
			}
			else
			{
				ManualLogSource obj = Log.LogDev();
				if (obj != null)
				{
					obj.LogWarning((object)("Intention " + text + " of " + GetType().Name + " definition doesn't have the main sprite set."));
				}
			}
			foreach (KeyValuePair<string, Sprite> item in sprites.LoadMany())
			{
				if ((Object)(object)item.Value != (Object)null)
				{
					ResourcesHelper.IntentionSprites.AlwaysAdd(text + item.Key, item.Value);
				}
			}
		}
	}
	public abstract class JadeBoxTemplate : EntityDefinition, IConfigProvider<JadeBoxConfig>, IGameEntityProvider<JadeBox>, ITypeProvider<JadeBox>, IResourceConsumer<LocalizationOption>
	{
		public override Type ConfigType()
		{
			return typeof(JadeBoxConfig);
		}

		public override Type EntityType()
		{
			return typeof(JadeBox);
		}

		public override Type TemplateType()
		{
			return typeof(JadeBoxTemplate);
		}

		public static void AddExhibitAtTheStart(GameRunController gameRun, HashSet<Type> exhibits)
		{
			GameMaster instance = Singleton<GameMaster>.Instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(GainExhibits(gameRun, exhibits));
			}
		}

		private static IEnumerator GainExhibits(GameRunController gameRun, HashSet<Type> exhibits)
		{
			foreach (Type et in exhibits)
			{
				yield return gameRun.GainExhibitRunner(Library.CreateExhibit(et), false, (VisualSourceData)null);
			}
			gameRun.ExhibitPool.RemoveAll((Type e) => exhibits.Contains(e));
		}

		public JadeBoxConfig DefaultConfig()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			return new JadeBoxConfig(0, "", 10, (IReadOnlyList<string>)new List<string>(), (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}

		public abstract JadeBoxConfig MakeConfig();

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption resource)
		{
			ProcessLocalization(resource, EntityType());
		}
	}
	public abstract class LaserTemplate : EntityDefinition, IConfigProvider<LaserConfig>
	{
		public override Type ConfigType()
		{
			return typeof(LaserConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(LaserTemplate);
		}

		public LaserConfig DefaultConfig()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			return new LaserConfig("", "", "Empty", new Vector2(20f, 0f), new Vector2(10f, 0f), 0, "HitBody", "CommonHitBody", "HitShield", "CommonHitShield", "HitBlock", "CommonHitShield", "", "CommonGraze");
		}

		public abstract LaserConfig MakeConfig();
	}
	public abstract class PackTemplate : EntityDefinition, IConfigProvider<PackConfig>, IResourceConsumer<PackIcons>, IResourceConsumer<LocalizationOption>
	{
		public override Type TemplateType()
		{
			return typeof(PackTemplate);
		}

		public override Type ConfigType()
		{
			return typeof(PackConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public PackConfig DefaultConfig()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new PackConfig("", (IReadOnlyList<string>)new string[0]);
		}

		public PackConfig MakeConfig()
		{
			return DefaultConfig();
		}

		public abstract PackIcons LoadPackIcon();

		public abstract LocalizationOption LoadLocalization();

		public void Consume(PackIcons icons)
		{
			if (icons != null)
			{
				if ((Object)(object)icons.mainIcon != (Object)null)
				{
					ResourcesHelper.StickerSprites.AlwaysAdd(string.Concat(GetId(), "Sticker"), icons.mainIcon);
				}
				if ((Object)(object)icons.disabledIcon != (Object)null)
				{
					ResourcesHelper.StickerSprites.AlwaysAdd(string.Concat(GetId(), "StickerOff"), icons.disabledIcon);
				}
			}
		}

		public void Consume(LocalizationOption locOption)
		{
			if (locOption != null)
			{
				if (locOption is GlobalLocalization)
				{
					throw new InvalidOperationException("GlobalLocalization LocalizationOption not supported for PackTemplate");
				}
				if (locOption is LocalizationFiles localizationFiles)
				{
					Dictionary<string, Dictionary<string, object>> termDic = localizationFiles.LoadLocTable(new string[1] { GetId() });
					FillPacksLocTable(termDic, localizationFiles.mergeTerms);
				}
				else if (locOption is DirectLocalization directLocalization)
				{
					Dictionary<string, Dictionary<string, object>> termDic2 = directLocalization.WrapTermDic(base.UniqueId);
					FillPacksLocTable(termDic2, directLocalization.mergeTerms);
				}
				else if (locOption is BatchLocalization batchLocalization)
				{
					batchLocalization.RegisterSelf(userAssembly);
				}
			}
		}

		internal static void FillPacksLocTable(Dictionary<string, Dictionary<string, object>> termDic, bool mergeTerms)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			Dictionary<string, PackDisplayWord> table = Packs._table;
			foreach (KeyValuePair<string, Dictionary<string, object>> item in termDic)
			{
				string key = item.Key;
				Dictionary<string, object> value = item.Value;
				PackDisplayWord val = new PackDisplayWord(key, value.GetValueOrDefault("Name") as string, value.GetValueOrDefault("Description") as string);
				if (mergeTerms)
				{
					if (table.TryGetValue(key, out var value2))
					{
						string text = null;
						text = ((val.Name == null) ? value2.Name : val.Name);
						string text2 = null;
						text2 = ((val.Description == null) ? value2.Description : val.Description);
						table[key] = new PackDisplayWord(key, text, text2);
					}
					else
					{
						table.Add(key, val);
					}
				}
				else
				{
					table.AlwaysAdd(key, val);
				}
			}
		}
	}
	public abstract class PlayerUnitTemplate : EntityDefinition, IConfigProvider<PlayerUnitConfig>, IGameEntityProvider<PlayerUnit>, ITypeProvider<PlayerUnit>, IResourceConsumer<LocalizationOption>, IResourceConsumer<PlayerImages>
	{
		public class EikiSummonInfo
		{
			public Type summonType;

			public string spellcardId = "净颇梨审判";

			public EikiSummonInfo(Type summonType, string spellcardId = null)
			{
				this.summonType = summonType;
				if (spellcardId != null)
				{
					this.spellcardId = spellcardId;
				}
			}
		}

		[HarmonyPatch(typeof(ResourcesHelper), "LoadCharacterAvatarSprite")]
		private class LoadCharacterAvatarSprite_Patch
		{
			private static bool Prefix(string characterName, ref Sprite __result)
			{
				if (UniqueTracker.Instance.IsLoadedOnDemand(typeof(PlayerUnitTemplate), characterName, out var entityDefinition))
				{
					if (entityDefinition is PlayerUnitTemplate playerUnitTemplate && EntityManager.HandleOverwriteWrap(delegate
					{
					}, playerUnitTemplate, PlayerSpriteLoader.OverwriteName("Avatar"), playerUnitTemplate.user))
					{
						__result = playerUnitTemplate.LoadPlayerImages().LoadInRunAvatarPic();
						return false;
					}
					return true;
				}
				return true;
			}
		}

		public override Type ConfigType()
		{
			return typeof(PlayerUnitConfig);
		}

		public override Type EntityType()
		{
			return typeof(PlayerUnit);
		}

		public override Type TemplateType()
		{
			return typeof(PlayerUnitTemplate);
		}

		public static void AddLoadout(string charId, Type ultimateSkill, Type exhibit, List<Type> deck, int complexity, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			AddLoadout(charId, ultimateSkill.Name, exhibit.Name, deck.Select((Type t) => t.Name).ToList(), complexity, callingAssembly);
		}

		public static void AddLoadout(string charId, string ultimateSkill, string exhibit, List<string> deck, int complexity, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			Action item = delegate
			{
				Dictionary<string, List<UniqueTracker.CharLoadoutInfo>> loadoutInfos = UniqueTracker.Instance.loadoutInfos;
				loadoutInfos.TryAdd(charId, new List<UniqueTracker.CharLoadoutInfo>());
				string text = Numbers.DecimalToABC(2 + loadoutInfos[charId].Count);
				string typeName = "Type" + text;
				loadoutInfos[charId].Add(new UniqueTracker.CharLoadoutInfo
				{
					ultimateSkill = ultimateSkill,
					exhibit = exhibit,
					deck = deck,
					complexity = complexity,
					typeName = typeName,
					typeSuffix = text
				});
			};
			if (callingAssembly.IsLoadedFromDisk())
			{
				EntityManager.Instance.loadedFromDiskCharLoadouts.Add(item);
			}
			UniqueTracker.Instance.populateLoadoutInfosActions.Add(item);
		}

		public virtual EikiSummonInfo AssociateEikiSummon()
		{
			return null;
		}

		public PlayerUnitConfig DefaultConfig()
		{
			//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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			return new PlayerUnitConfig("", false, "", 0, 0, (int?)0, true, (int?)null, (ManaColor)1, (ManaColor)4, default(ManaGroup), "#f241a8", 1, 1, 0, "", "", "", "", (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), 1, 1);
		}

		public abstract PlayerUnitConfig MakeConfig();

		public abstract PlayerImages LoadPlayerImages();

		public void Consume(PlayerImages resource)
		{
			UniqueTracker.Instance.user2PlayerTemplates.TryAdd(userAssembly, new List<PlayerUnitTemplate>());
			UniqueTracker.Instance.user2PlayerTemplates[userAssembly].Add(this);
			EntityManager.HandleOverwriteWrap(delegate
			{
				CardWidget._ownerSpriteTable.AlwaysAdd(base.UniqueId, resource.LoadCardBack());
			}, this, PlayerSpriteLoader.OverwriteName("CardImprint"), user);
		}

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption locOptions)
		{
			ProcessLocalization(locOptions, EntityType());
		}
	}
	public abstract class SfxTemplate : EntityDefinition, IConfigProvider<SfxConfig>, IResourceConsumer<List<UniTask<AudioClip>>>
	{
		public override Type ConfigType()
		{
			return typeof(SfxConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(SfxTemplate);
		}

		public SfxConfig DefaultConfig()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			return new SfxConfig("", "", "", 0.08, 1f);
		}

		public abstract SfxConfig MakeConfig();

		public abstract List<UniTask<AudioClip>> LoadSfxListAsync();

		public async void Consume(List<UniTask<AudioClip>> audioClips)
		{
			SfxConfig config = SfxConfig.FromName((string)base.UniqueId);
			SfxEntry sfxEntry = null;
			if (audioClips.Count == 1)
			{
				double rep = config.Rep;
				float volume = config.Volume;
				sfxEntry = new SfxEntry(rep, volume, await audioClips[0]);
			}
			if (audioClips.Count > 1)
			{
				sfxEntry = new SfxEntry(config.Rep, config.Volume);
				foreach (UniTask<AudioClip> acTask in audioClips)
				{
					List<AudioClip> clips = sfxEntry.Clips;
					clips.Add(await acTask);
				}
			}
			if (sfxEntry == null)
			{
				Log.log.LogError((object)$"{GetType()}: failed to load any sfx AudioClips");
			}
			Singleton<AudioManager>.Instance._sfxTable.AlwaysAdd(base.UniqueId, sfxEntry);
		}
	}
	public abstract class SpellTemplate : EntityDefinition, IConfigProvider<SpellConfig>, IResourceConsumer<LocalizationOption>
	{
		public const string OnCastTitle = "OnCastTitle";

		public const string OnCastName = "OnCastName";

		public override Type ConfigType()
		{
			return typeof(SpellConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(SpellTemplate);
		}

		public SpellConfig DefaultConfig()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new SpellConfig("", "");
		}

		public abstract SpellConfig MakeConfig();

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption locOption)
		{
			if (locOption is GlobalLocalization globalLocalization)
			{
				if (CollectionsExtensions.NotEmpty<KeyValuePair<Locale, Func<YamlMappingNode>>>((IReadOnlyCollection<KeyValuePair<Locale, Func<YamlMappingNode>>>)globalLocalization.LocalizationFiles.locTable))
				{
					UniqueTracker.Instance.spellEntriesLocFiles.TryAdd(userAssembly, new HashSet<LocalizationFiles>());
					UniqueTracker.Instance.spellEntriesLocFiles[userAssembly].Add(globalLocalization.LocalizationFiles);
				}
				UniqueTracker.Instance.spellIdsToLocalize.TryAdd(userAssembly, new HashSet<string>());
				UniqueTracker.Instance.spellIdsToLocalize[userAssembly].Add(GetId());
			}
			else if (locOption is BatchLocalization batchLocalization)
			{
				batchLocalization.RegisterSelf(userAssembly);
			}
		}

		internal static void LoadAllSpecialLoc(SpellPanel spellPanel = null)
		{
			foreach (Dictionary<string, SpellTemplate> value in UniqueTracker.Instance.spellTemplates.Values)
			{
				foreach (SpellTemplate value2 in value.Values)
				{
					value2.LoadSpecialLoc(value2.LoadLocalization(), spellPanel);
				}
			}
		}

		internal void LoadSpecialLoc(LocalizationOption locOption, SpellPanel spellPanel)
		{
			if (locOption is GlobalLocalization)
			{
				if (!UniqueTracker.Instance.spellEntriesLocFiles.TryGetValue(user.assembly, out var value))
				{
					return;
				}
				{
					foreach (LocalizationFiles item in value)
					{
						FillSpellPanelLocTable(item.LoadLocTable(UniqueTracker.Instance.spellIdsToLocalize[user.assembly], addEmptyDic: false), item.mergeTerms, spellPanel);
					}
					return;
				}
			}
			if (locOption is LocalizationFiles localizationFiles)
			{
				Dictionary<string, Dictionary<string, object>> termDic = localizationFiles.LoadLocTable(new string[1] { GetId() });
				FillSpellPanelLocTable(termDic, localizationFiles.mergeTerms, spellPanel);
			}
			else if (locOption is DirectLocalization directLocalization)
			{
				Dictionary<string, Dictionary<string, object>> termDic2 = directLocalization.WrapTermDic(base.UniqueId);
				FillSpellPanelLocTable(termDic2, directLocalization.mergeTerms, spellPanel);
			}
			else if (locOption is BatchLocalization { localizationFiles: var localizationFiles2 } batchLocalization)
			{
				FillSpellPanelLocTable(localizationFiles2.LoadLocTable(batchLocalization.entityIds, addEmptyDic: false), localizationFiles2.mergeTerms, spellPanel);
			}
		}

		internal static void FillSpellPanelLocTable(Dictionary<string, Dictionary<string, object>> termDic, bool mergeTerms, SpellPanel spellPanel)
		{
			//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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			if ((Object)(object)spellPanel == (Object)null)
			{
				try
				{
					spellPanel = UiManager.GetPanel<SpellPanel>();
				}
				catch (InvalidOperationException)
				{
					return;
				}
			}
			Dictionary<string, Entry> dictionary = (Dictionary<string, Entry>)spellPanel._l10nTable;
			foreach (KeyValuePair<string, Dictionary<string, object>> item in termDic)
			{
				Entry val = new Entry
				{
					Title = null,
					Name = null
				};
				string key = item.Key;
				Dictionary<string, object> value = item.Value;
				object value3;
				if (value.TryGetValue("OnCastTitle", out var value2))
				{
					val.Title = value2.ToString() ?? "";
				}
				else if (value.TryGetValue("Title", out value3))
				{
					val.Title = value3.ToString() ?? "";
				}
				object value5;
				object value6;
				if (value.TryGetValue("OnCastName", out var value4))
				{
					val.Name = value4.ToString() ?? "";
				}
				else if (value.TryGetValue("Name", out value5))
				{
					val.Name = value5.ToString() ?? "";
				}
				else if (value.TryGetValue("Content", out value6))
				{
					val.Name = value6.ToString() ?? "";
				}
				if (mergeTerms)
				{
					if (dictionary.TryGetValue(key, out var value7))
					{
						if (val.Title != null)
						{
							value7.Title = val.Title;
						}
						if (val.Name != null)
						{
							value7.Name = val.Name;
						}
					}
					else
					{
						dictionary.Add(key, val);
					}
				}
				else
				{
					dictionary.AlwaysAdd(key, val);
				}
			}
		}
	}
	public abstract class StageTemplate : EntityDefinition, IConfigProvider<StageConfig>, IGameEntityProvider<Stage>, ITypeProvider<Stage>
	{
		public static class VanillaEnvironments
		{
			public const string BambooForest0 = "BambooForest0";

			public const string BambooForest1 = "BambooForest1";

			public const string BambooForest2 = "BambooForest2";

			public const string BambooForest3 = "BambooForest3";

			public const string XuanwuRavine1 = "XuanwuRavine1";

			public const string XuanwuRavine3 = "XuanwuRavine3";

			public const string WindGodLake1 = "WindGodLake1";

			public const string WindGodLake2 = "WindGodLake2";
		}

		[HarmonyPatch(typeof(StartGamePanel), "OnShowing")]
		private class AddStage_Patch
		{
			private static Stage[] ModStageArray(Stage[] stages)
			{
				List<Stage> list = stages.ToList();
				foreach (Func<List<Stage>, List<Stage>> modifyStageListFunc in UniqueTracker.Instance.modifyStageListFuncs)
				{
					list = modifyStageListFunc(list);
				}
				Dictionary<string, List<int>> dictionary = new Dictionary<string, List<int>>();
				int num = 0;
				foreach (Stage item in list)
				{
					dictionary.TryAdd(((GameEntity)item).Id, new List<int>());
					dictionary[((GameEntity)item).Id].Add(num);
					num++;
				}
				foreach (UniqueTracker.StageModAction modifyStageAction in UniqueTracker.Instance.modifyStageActions)
				{
					if (!dictionary.ContainsKey(modifyStageAction.Id))
					{
						ManualLogSource obj = Log.LogDev();
						if (obj != null)
						{
							obj.LogWarning((object)("Trying to modify stage with Id:" + modifyStageAction.Id + " but it wasn't loaded. It either doesn't exist or was removed from stage list"));
						}
						continue;
					}
					foreach (int item2 in dictionary[modifyStageAction.Id])
					{
						Stage arg = list[item2];
						list[item2] = modifyStageAction.mod(arg);
					}
				}
				return list.ToArray();
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0003: 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_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Expected O, but got Unknown
				return new CodeMatcher(instructions, generator).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(StartGameData), "StagesCreateFunc"), (string)null)
				}).Advance(2).Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(AddStage_Patch), "ModStageArray", (Type[])null, (Type[])null))
				})
					.InstructionEnumeration();
			}
		}

		[HarmonyPatch]
		private class EnableCustomBg_Patch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				MethodInfo enumMethod = AccessTools.EnumeratorMoveNext((MethodBase)AccessTools.Method(typeof(Environment), "LoadEnvironment", new Type[1] { typeof(string) }, (Type[])null));
				if (enumMethod == null)
				{
					throw new InvalidOperationException("Inner enumeration method not found");
				}
				yield return enumMethod;
			}

			private static void Postfix()
			{
				((Component)Environment.CurrentEnvironment).gameObject.SetActive(true);
			}
		}

		internal static HashSet<string> customEnvs = new HashSet<string>();

		internal static HashSet<Action> loadedFromDiskEnvironments = new HashSet<Action>();

		internal static HashSet<string> currentEnvs = new HashSet<string>();

		public override Type ConfigType()
		{
			return typeof(StageConfig);
		}

		public override Type EntityType()
		{
			return typeof(Stage);
		}

		public override Type TemplateType()
		{
			return typeof(StageTemplate);
		}

		public static void ModifyStage(string Id, Func<Stage, Stage> stageMod, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			UniqueTracker.StageModAction item = new UniqueTracker.StageModAction
			{
				Id = Id,
				mod = stageMod
			};
			if (callingAssembly.IsLoadedFromDisk())
			{
				EntityManager.Instance.loadedFromModifyStageActions.Add(item);
			}
			UniqueTracker.Instance.modifyStageActions.Add(item);
		}

		public static void ModifyStageList(Func<List<Stage>, List<Stage>> listMod, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			if (callingAssembly.IsLoadedFromDisk())
			{
				EntityManager.Instance.loadedFromDiskmodifyStageListFuncs.Add(listMod);
			}
			UniqueTracker.Instance.modifyStageListFuncs.Add(listMod);
		}

		public static void CopyFromVanilla(Type vanillaType, Stage moddedStage)
		{
			if (vanillaType != typeof(Stage))
			{
				BepinexPlugin.log.LogError((object)("The stage type being copied: " + vanillaType.Name + " is not a stage at all."));
			}
			Stage val = Library.CreateStage(vanillaType);
			moddedStage.Level = val.Level;
			moddedStage.CardUpgradedChance = val.CardUpgradedChance;
			moddedStage.IsSelectingBoss = val.IsSelectingBoss;
			moddedStage.StoryBossId = val.StoryBossId;
			moddedStage.EnemyPoolAct1 = val.EnemyPoolAct1;
			moddedStage.EnemyPoolAct2 = val.EnemyPoolAct2;
			moddedStage.EnemyPoolAct3 = val.EnemyPoolAct3;
			moddedStage.EliteEnemyPool = val.EliteEnemyPool;
			moddedStage.BossPool = val.BossPool;
			moddedStage.AdventurePool = val.AdventurePool;
			moddedStage.FirstAdventurePool = val.FirstAdventurePool;
		}

		public static void CopyFromVanilla<T>(Stage moddedStage) where T : Stage
		{
			CopyFromVanilla(typeof(T), moddedStage);
		}

		public void ListenToVanilla<T>(Stage moddedStage) where T : Stage
		{
			string name = typeof(T).Name;
			foreach (UniqueTracker.StageModAction modifyStageAction in UniqueTracker.Instance.modifyStageActions)
			{
				if (modifyStageAction.Id == name)
				{
					modifyStageAction.mod(moddedStage);
				}
			}
		}

		public static GameObject TryGetEnvObject(string name, Assembly userAssembly = null)
		{
			if (userAssembly == null)
			{
				userAssembly = Assembly.GetCallingAssembly();
			}
			GameObject value = null;
			if (UniqueTracker.Instance.createdEnvObjectCache.TryGetValue(userAssembly, out var value2))
			{
				value2.TryGetValue(name, out value);
			}
			return value;
		}

		public static Func<GameObject> CreateSimpleEnvObject(string name, Sprite background)
		{
			return delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Expected O, but got Unknown
				GameObject val = new GameObject(name);
				EnvironmentObject val2 = val.AddComponent<EnvironmentObject>();
				((Object)val2).name = ((Object)val).name;
				if ((Object)(object)background != (Object)null)
				{
					SpriteRenderer val3 = val.AddComponent<SpriteRenderer>();
					val3.sprite = background;
				}
				return val;
			};
		}

		public static void AddEvironmentGameobject(Func<GameObject> getEvnGo, bool managedByEnvironment, Func<GameObject, GameObject> adjustAfterSettingRoot = null, string overwriteName = null, Assembly callingAssembly = null)
		{
			if (callingAssembly == null)
			{
				callingAssembly = Assembly.GetCallingAssembly();
			}
			Action item = delegate
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Environment.Instance != (Object)null)
				{
					GameObject val = getEvnGo();
					if (!string.IsNullOrEmpty(overwriteName))
					{
						((Object)val).name = overwriteName;
					}
					val.transform.SetParent(Environment.Instance.stageRoot);
					val.transform.position = Environment.Instance.stageRoot.position;
					val.SetActive(false);
					GameObject val2 = adjustAfterSettingRoot?.Invoke(val);
					if ((Object)(object)val2 != (Object)null)
					{
						val = val2;
					}
					customEnvs.Add(((Object)val).name);
					if (managedByEnvironment)
					{
						EnvironmentObject val3 = default(EnvironmentObject);
						if (!val.TryGetComponent<EnvironmentObject>(ref val3))
						{
							val3 = val.AddComponent<EnvironmentObject>();
							((Object)val3).name = ((Object)val).name;
						}
						if (currentEnvs.Count == 0)
						{
							CollectionExtensions.Do<EnvironmentObject>((IEnumerable<EnvironmentObject>)Environment.Instance.simpleTemplates, (Action<EnvironmentObject>)delegate(EnvironmentObject eo)
							{
								currentEnvs.Add(((Object)eo).name);
							});
							CollectionExtensions.Do<EnvironmentObject>((IEnumerable<EnvironmentObject>)Environment.Instance.templates, (Action<EnvironmentObject>)delegate(EnvironmentObject eo)
							{
								currentEnvs.Add(((Object)eo).name);
							});
						}
						if (!currentEnvs.Contains(((Object)val3).name))
						{
							Environment.Instance.simpleTemplates.Add(val3);
							Environment.Instance.templates.Add(val3);
							currentEnvs.Add(((Object)val3).name);
						}
						else
						{
							Log.log.LogWarning((object)("EnvironmentObject with name " + ((Object)val3).name + " is already managed by Environment and will not be added."));
						}
					}
					UniqueTracker.Instance.createdEnvObjectCache.TryAdd(callingAssembly, new Dictionary<string, GameObject>());
					if (!UniqueTracker.Instance.createdEnvObjectCache[callingAssembly].TryAdd(((Object)val).name, val))
					{
						Log.log.LogError((object)("Caching environmental object " + ((Object)val).name + " failed. GameObject reference will be inaccessible"));
					}
				}
			};
			if (callingAssembly.IsLoadedFromDisk())
			{
				loadedFromDiskEnvironments.Add(item);
			}
			UniqueTracker.Instance.environmentsAddActions.Add(item);
		}

		internal static void ReloadEnvs()
		{
			List<GameObject> goToDestroy = FindEnvsToUnload();
			UnloadCustomEnvs(goToDestroy);
			LoadCustomEnvironments();
		}

		internal static void LoadCustomEnvironments()
		{
			CollectionExtensions.Do<Action>((IEnumerable<Action>)UniqueTracker.Instance.environmentsAddActions, (Action<Action>)delegate(Action a)
			{
				a();
			});
		}

		internal static void UnloadCustomEnvs(List<GameObject> goToDestroy)
		{
			Environment instance = Environment.Instance;
			HashSet<EnvironmentObject> envOs = new HashSet<EnvironmentObject>();
			EnvironmentObject val = default(EnvironmentObject);
			foreach (GameObject item in goToDestroy)
			{
				if (item.TryGetComponent<EnvironmentObject>(ref val))
				{
					envOs.Add(val);
					currentEnvs.Remove(((Object)val).name);
				}
				Object.Destroy((Object)(object)item);
			}
			if ((Object)(object)instance != (Object)null)
			{
				instance.simpleTemplates = instance.simpleTemplates.Where((EnvironmentObject eo) => !envOs.Contains(eo)).ToList();
				instance.templates = instance.templates.Where((EnvironmentObject eo) => !envOs.Contains(eo)).ToList();
			}
		}

		internal static List<GameObject> FindEnvsToUnload()
		{
			List<GameObject> list = new List<GameObject>();
			Transform val = Environment.Instance?.stageRoot;
			if ((Object)(object)val == (Object)null)
			{
				return list;
			}
			foreach (object item in val)
			{
				GameObject gameObject = ((Component)((item is Transform) ? item : null)).gameObject;
				if (customEnvs.Contains(((Object)gameObject).name))
				{
					list.Add(gameObject);
				}
			}
			customEnvs.Clear();
			return list;
		}

		public StageConfig DefaultConfig()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			return new StageConfig("", "BambooForest0", "", 1, "", 0, "", 0, "WindGodLake2", 0);
		}

		public abstract StageConfig MakeConfig();
	}
	public abstract class StatusEffectTemplate : EntityDefinition, IConfigProvider<StatusEffectConfig>, IGameEntityProvider<StatusEffect>, ITypeProvider<StatusEffect>, IResourceConsumer<LocalizationOption>, IResourceConsumer<Sprite>
	{
		public override Type TemplateType()
		{
			return typeof(StatusEffectTemplate);
		}

		public override Type ConfigType()
		{
			return typeof(StatusEffectConfig);
		}

		public override Type EntityType()
		{
			return typeof(StatusEffect);
		}

		public StatusEffectConfig DefaultConfig()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			return new StatusEffectConfig(0, "", 10, (StatusEffectType)0, false, true, (int?)null, false, (StackType?)(StackType)0, false, (StackType?)(StackType)0, (DurationDecreaseTiming)0, false, (StackType?)(StackType)3, (StackType?)(StackType)3, false, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (string)null, "Default", "Default", "Default");
		}

		public abstract StatusEffectConfig MakeConfig();

		public abstract Sprite LoadSprite();

		public virtual ExtraIcons LoadExtraIcons()
		{
			return null;
		}

		public void Consume(Sprite sprite)
		{
			if ((Object)(object)sprite != (Object)null)
			{
				ResourcesHelper.Sprites[typeof(StatusEffect)].AlwaysAdd(base.UniqueId, sprite);
			}
			ExtraIcons extraIcons = LoadExtraIcons();
			if (extraIcons == null)
			{
				return;
			}
			foreach (KeyValuePair<string, Sprite> item in extraIcons.LoadMany())
			{
				if (item.Key != "" && (Object)(object)item.Value != (Object)null)
				{
					ResourcesHelper.Sprites[typeof(StatusEffect)].AlwaysAdd(string.Concat(base.UniqueId, item.Key), item.Value);
				}
			}
		}

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption locOptions)
		{
			ProcessLocalization(locOptions, EntityType());
		}
	}
	public abstract class UiSoundTemplate : EntityDefinition, IConfigProvider<UiSoundConfig>, IResourceConsumer<List<UniTask<AudioClip>>>
	{
		public override Type ConfigType()
		{
			return typeof(UiSoundConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(UiSoundTemplate);
		}

		public UiSoundConfig DefaultConfig()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			return new UiSoundConfig("", "", "", 1f);
		}

		public abstract UiSoundConfig MakeConfig();

		public abstract List<UniTask<AudioClip>> LoadSfxListAsync();

		public async void Consume(List<UniTask<AudioClip>> audioClips)
		{
			UiSoundConfig config = UiSoundConfig.FromName((string)base.UniqueId);
			UiEntry uiEntry = null;
			if (audioClips.Count == 1)
			{
				uiEntry = new UiEntry(await audioClips[0], config.Volume);
			}
			if (audioClips.Count > 1)
			{
				uiEntry = new UiEntry(config.Volume);
				foreach (UniTask<AudioClip> acTask in audioClips)
				{
					List<AudioClip> clips = uiEntry.Clips;
					clips.Add(await acTask);
				}
			}
			if (uiEntry == null)
			{
				Log.log.LogError((object)$"{GetType()}: failed to load any ui AudioClips");
			}
			Singleton<AudioManager>.Instance._uiTable.AlwaysAdd(base.UniqueId, uiEntry);
		}
	}
	public abstract class UltimateSkillTemplate : EntityDefinition, IConfigProvider<UltimateSkillConfig>, IGameEntityProvider<UltimateSkill>, ITypeProvider<UltimateSkill>, IResourceConsumer<LocalizationOption>, IResourceConsumer<Sprite>
	{
		public override Type ConfigType()
		{
			return typeof(UltimateSkillConfig);
		}

		public override Type EntityType()
		{
			return typeof(UltimateSkill);
		}

		public override Type TemplateType()
		{
			return typeof(UltimateSkillTemplate);
		}

		public UltimateSkillConfig DefaultConfig()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 1, 0, 0, (Keyword)256, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}

		public abstract UltimateSkillConfig MakeConfig();

		public abstract LocalizationOption LoadLocalization();

		public abstract Sprite LoadSprite();

		public void Consume(LocalizationOption locOption)
		{
			ProcessLocalization(locOption, EntityType());
		}

		public void Consume(Sprite sprite)
		{
			if (!((Object)(object)sprite == (Object)null))
			{
				ResourcesHelper.Sprites[EntityType()].AlwaysAdd(base.UniqueId, sprite);
			}
		}

		internal SpellTemplate CreateSpellTemplate()
		{
			DynamicSpell dynamicSpell = new DynamicSpell
			{
				CreateLoadLoc = () => LoadLocalization(),
				CreateMakeConfig = () => new SpellConfig((string)base.UniqueId, "")
			};
			dynamicSpell.Create(base.UniqueId, user);
			return dynamicSpell;
		}
	}
	public abstract class UnitModelTemplate : EntityDefinition, IConfigProvider<UnitModelConfig>, IResourceConsumer<LocalizationOption>
	{
		[HarmonyPatch(typeof(ResourcesHelper), "LoadSpineUnitAsync")]
		private class LoadSpineUnitAsync_Patch
		{
			private static bool Prefix(string characterName, ref UniTask<SkeletonDataAsset> __result)
			{
				//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)
				if (UniqueTracker.Instance.IsLoadedOnDemand(typeof(UnitModelTemplate), characterName, out var entityDefinition))
				{
					if (entityDefinition is UnitModelTemplate unitModelTemplate && EntityManager.HandleOverwriteWrap(delegate
					{
					}, unitModelTemplate, "LoadModelOptions", unitModelTemplate.user) && unitModelTemplate.CheckModelOptions())
					{
						__result = unitModelTemplate.LoadModelOptions().loadSpine;
						return false;
					}
					return true;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ResourcesHelper), "LoadSimpleUnitSpriteAsync")]
		private class LoadSimpleUnitSpriteAsync_Patch
		{
			private static bool Prefix(string characterName, ref UniTask<Sprite> __result)
			{
				//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)
				if (UniqueTracker.Instance.IsLoadedOnDemand(typeof(UnitModelTemplate), characterName, out var entityDefinition))
				{
					if (entityDefinition is UnitModelTemplate unitModelTemplate && EntityManager.HandleOverwriteWrap(delegate
					{
					}, unitModelTemplate, "LoadModelOptions", unitModelTemplate.user) && unitModelTemplate.CheckModelOptions())
					{
						__result = unitModelTemplate.LoadModelOptions().loadSprite;
						return false;
					}
					return true;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ResourcesHelper), "LoadSpellPortraitAsync")]
		private class LoadSpellPortraitAsync_Patch
		{
			private static bool Prefix(string characterName, ref UniTask<Sprite> __result)
			{
				//IL_0069: 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)
				if (UniqueTracker.Instance.IsLoadedOnDemand(typeof(UnitModelTemplate), characterName, out var entityDefinition))
				{
					if (entityDefinition is UnitModelTemplate unitModelTemplate && EntityManager.HandleOverwriteWrap(delegate
					{
					}, unitModelTemplate, "LoadSpellSprite", unitModelTemplate.user) && unitModelTemplate.CheckSpellSpriteEnabled())
					{
						__result = unitModelTemplate.LoadSpellSprite();
						return false;
					}
					return true;
				}
				return true;
			}
		}

		public override Type ConfigType()
		{
			return typeof(UnitModelConfig);
		}

		public override Type EntityType()
		{
			throw new InvalidDataException();
		}

		public override Type TemplateType()
		{
			return typeof(UnitModelTemplate);
		}

		public UnitModelConfig DefaultConfig()
		{
			//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)
			//IL_0040: 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_0063: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			return new UnitModelConfig("", 0, "", new Vector2(0f, 0f), false, 0, new Vector2(0.8f, 1.8f), 1.2f, 1.3f, new Vector2(0f, -1.3f), 480f, new Vector2(0f, 1.2f), new Vector2(1.6f, 2f), (IReadOnlyList<float>)new List<float> { 0.1f }, (IReadOnlyList<Vector2>)new List<Vector2>
			{
				new Vector2(0.6f, 0.3f)
			}, (IReadOnlyList<Vector2>)new List<Vector2>
			{
				new Vector2(0.6f, 0.3f)
			}, new Vector2(0.3f, 0f), 0.1f, 0.1f, new Vector2(0.4f, 0.8f), new Vector2(-0.8f, -0.58f), new Vector2(0.6f, 0.5f), false, new Vector2(0f, 0f), 1f, (IReadOnlyList<Color32>)new List<Color32>
			{
				new Color32((byte)101, (byte)229, (byte)71, byte.MaxValue),
				new Color32((byte)131, (byte)221, (byte)117, byte.MaxValue),
				new Color32((byte)137, (byte)221, (byte)117, (byte)150),
				new Color32((byte)153, (byte)220, (byte)127, byte.MaxValue)
			});
		}

		public abstract UnitModelConfig MakeConfig();

		public abstract ModelOption LoadModelOptions();

		public abstract UniTask<Sprite> LoadSpellSprite();

		public abstract LocalizationOption LoadLocalization();

		public void Consume(LocalizationOption locOption)
		{
			//IL_00f6: 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_0114: Expected O, but got Unknown
			//IL_0171: 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_0165: Expected O, but got Unknown
			if (locOption == null)
			{
				return;
			}
			if (locOption is GlobalLocalization globalLocalization)
			{
				if (CollectionsExtensions.NotEmpty<KeyValuePair<Locale, Func<YamlMappingNode>>>((IReadOnlyCollection<KeyValuePair<Locale, Func<YamlMappingNode>>>)globalLocalization.LocalizationFiles.locTable) && !UniqueTracker.Instance.unitNamesGlobalLocalizationFiles.TryAdd(userAssembly, globalLocalization.LocalizationFiles))
				{
					ManualLogSource obj = Log.LogDev();
					if (obj != null)
					{
						obj.LogWarning((object)$"{userAssembly.GetName().Name}: {GetType()} tries to set global unit name localization files but they've already been set by another {TemplateType().Name}.");
					}
				}
				UniqueTracker.Instance.unitIdsToLocalize.TryAdd(userAssembly, new HashSet<IdContainer>());
				UniqueTracker.Instance.unitIdsToLocalize[userAssembly].Add(GetId());
			}
			else if (locOption is LocalizationFiles localizationFiles)
			{
				YamlMappingNode val = localizationFiles.Load(Localization.CurrentLocale);
				YamlScalarNode key = new YamlScalarNode((string)GetId());
				if (((IDictionary<YamlNode, YamlNode>)val.Children).TryGetValue((YamlNode)(object)key, out YamlNode value))
				{
					YamlMappingNode val2 = (YamlMappingNode)(object)((value is YamlMappingNode) ? value : null);
					if (val2 != null)
					{
						LocalizationOption.FillUnitNameTable(new YamlMappingNode(new KeyValuePair<YamlNode, YamlNode>[1]
						{
							new KeyValuePair<YamlNode, YamlNode>((YamlNode)(object)key, (YamlNode)(object)val2)
						}), localizationFiles.mergeTerms);
						return;
					}
				}
				localizationFiles.fileNames.TryGetValue(localizationFiles.GetAvailableLocale(), out var value2);
				Log.log.LogWarning((object)$"{GetId()} not found in {value2}");
			}
			else if (locOption is DirectLocalization directLocalization)
			{
				Dictionary<string, Dictionary<string, object>> termDic = directLocalization.WrapTermDic(base.UniqueId);
				LocalizationOption.FillUnitNameTable(LocalizationOption.TermDic2YamlMapping(termDic), directLocalization.mergeTerms);
			}
			else if (locOption is BatchLocalization batchLocalization)
			{
				batchLocalization.RegisterSelf(userAssembly);
			}
		}

		private bool CheckModelOptions()
		{
			//IL_003e: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			ModelOption modelOption = LoadModelOptions();
			if (modelOption == null)
			{
				Log.LogDev().LogWarning((object)("ModelOption not provided by " + GetType().Name + "."));
				return false;
			}
			ModelType val = (ModelType)0;
			try
			{
				val = (ModelType)UnitModelConfig.FromName((string)base.UniqueId).Type;
			}
			catch (Exception arg)
			{
				Log.log.LogError((object)$"UnitModelConfig.Type should be number from 0 to 2 : {arg}");
				return false;
			}
			if (val != modelOption.modelType)
			{
				Log.log.LogError((object)(GetType().Name + ": UnitModelConfig.Type mismatches options supplied by " + typeof(ModelOption).Name));
				return false;
			}
			return true;
		}

		private bool CheckSpellSpriteEnabled()
		{
			if (!UnitModelConfig.FromName((string)base.UniqueId).HasSpellPortrait)
			{
				Log.log.LogWarning((object)(GetType().Name + ": UnitModelConfig.HasSpellPortrait is false but HasSpellPortrait is being loaded anyway"));
				return false;
			}
			return true;
		}
	}
}
namespace LBoLEntitySideloader.Entities.Patches
{
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class EikiSummonPatch
	{
		private static void CheckSummon(ref Type summonType, ref string spellcardId)
		{
			string currentPcId = ((GameEntity)Singleton<GameMaster>.Instance.CurrentGameRun.Player).Id;
			PlayerUnitTemplate playerUnitTemplate = (from d in EntityManager.Instance.AllUsers.Select(((Assembly ass, UserInfo userInfo) tu) => tu.userInfo).SelectMany((UserInfo ui) => ui.definitionInstances.Values)
				where d is PlayerUnitTemplate
				select d).Cast<PlayerUnitTemplate>().FirstOrDefault((PlayerUnitTemplate put) => (IdContainer)currentPcId == put.UniqueId);
			if (playerUnitTemplate == null)
			{
				return;
			}
			try
			{
				PlayerUnitTemplate.EikiSummonInfo eikiSummonInfo = playerUnitTemplate.AssociateEikiSummon();
				if (eikiSummonInfo != null)
				{
					if (!eikiSummonInfo.summonType.IsSubclassOf(typeof(EnemyUnit)))
					{
						throw new InvalidOperationException(eikiSummonInfo.summonType.Name + " is not subclass of EnemyUnit");
					}
					summonType = eikiSummonInfo.summonType;
					spellcardId = eikiSummonInfo.spellcardId;
				}
			}
			catch (Exception arg)
			{
				BepinexPlugin.log.LogError((object)string.Format("Error invoking {0}.{1}: {2}", playerUnitTemplate.GetType().Name, "AssociateEikiSummon", arg));
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase originalMethod)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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
			Type declaringType = originalMethod.DeclaringType;
			FieldInfo fieldInfo = AccessTools.GetDeclaredFields(declaringType).First((FieldInfo fi) => fi.Name.Contains("type"));
			FieldInfo fieldInfo2 = AccessTools.GetDeclaredFields(declaringType).First((FieldInfo fi) => fi.Name.Contains("spellcard"));
			return new CodeMatcher(instructions, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Ldstr, (object)"Chat.Siji1")) }).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldflda, (object)fieldInfo)
			})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldflda, (object)fieldInfo2)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EikiSummonPatch), "CheckSummon", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(IntentionWidget), "UpdateProperties")]
	internal class IntentionWidgetPatch
	{
		private static void ChangeSuffix(Intention intention, ref string suffix)
		{
			if (!UniqueTracker.Instance.IntentionSuffixFuncs.TryGetValue(((GameEntity)intention).Id, out var value))
			{
				return;
			}
			try
			{
				suffix = value(intention);
			}
			catch (Exception arg)
			{
				BepinexPlugin.log.LogError((object)string.Format("Error invoking {0} with {1}: {2}", "SelectAltIconsSuffix", ((object)intention).GetType().Name, arg));
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0003: 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_0020: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Stloc_1, (object)null)) }).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(IntentionWidget), "_intention"))
			})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloca, (object)0)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(IntentionWidgetPatch), "ChangeSuffix", (Type[])null, (Type[])null))
				})
				.InstructionEnumeration();
		}
	}
	internal class PlayerSpriteLoader
	{
		internal static void ReloadForMainMenu()
		{
			if (Singleton<GameMaster>.Instance.CurrentGameRun == null)
			{
				if (UiManager.Instance._panelTable.ContainsKey(typeof(StartGamePanel)))
				{
					LoadForStartPanel(UiManager.GetPanel<StartGamePanel>());
				}
				if (UiManager.Instance._panelTable.ContainsKey(typeof(HistoryPanel)))
				{
					LoadForHistoryPanel(UiManager.GetPanel<HistoryPanel>());
				}
				if (UiManager.Instance._panelTable.ContainsKey(typeof(MuseumPanel)))
				{
					LoadForMuseumPanel(UiManager.GetPanel<MuseumPanel>());
				}
				if (UiManager.Instance._panelTable.ContainsKey(typeof(GameResultPanel)))
				{
					LoadForGameResultPanel(UiManager.GetPanel<GameResultPanel>());
				}
				if (UiManager.Instance._panelTable.ContainsKey(typeof(ProfilePanel)))
				{
					LoadForProfilePanel(UiManager.GetPanel<ProfilePanel>());
				}
			}
		}

		internal static void LoadForProfilePanel(ProfilePanel profilePanel)
		{
			Wrap(delegate(PlayerUnitTemplate puT)
			{
				EntityManager.HandleOverwriteWrap(delegate
				{
					Sprite val = puT.LoadPlayerImages().LoadSelectionCircleIcon();
					if ((Object)(object)val != (Object)null)
					{
						profilePanel.headPicList.AlwaysAdd<string, Sprite>(puT.UniqueId, val);
					}
				}, puT, OverwriteName("SelectionCircleIcon"), puT.user);
			});
		}

		internal static void LoadForStartPanel(StartGamePanel startGamePanel)
		{
			Wrap(delegate(PlayerUnitTemplate puT)
			{
				PlayerImages sprites = puT.LoadPlayerImages();
				EntityManager.HandleOverwriteWrap(async delegate
				{
					if (sprites.startPanelStandTask.HasValue)
					{
						AssociationList<string, Sprite> standPicList = startGamePanel.standPicList;
						string key = puT.UniqueId;
						standPicList.AlwaysAdd<string, Sprite>(key, await sprites.LoadStartPanelStandAsync());
					}
					else
					{
						startGamePanel.standPicList.AlwaysAdd<string, Sprite>(puT.UniqueId, sprites.LoadStartPanelStand());
					}
				}, puT, OverwriteName("Stand"), puT.user);
				EntityManager.HandleOverwriteWrap(delegate
				{
					Sprite val = sprites.LoadSelectionCircleIcon();
					if ((Object)(object)val != (Object)null)
					{
						startGamePanel.headPicList.AlwaysAdd<string, Sprite>(puT.UniqueId, val);
					}
				}, puT, OverwriteName("SelectionCircleIcon"), puT.user);
			});
		}

		internal static void LoadForHistoryPanel(HistoryPanel historyPanel)
		{
			Wrap(delegate(PlayerUnitTemplate puT)
			{
				PlayerImages sprites = puT.LoadPlayerImages();
				EntityManager.HandleOverwriteWrap(async delegate
				{
					AvatarGroup avatarGroup = new AvatarGroup();
					if (sprites.defeatedIconTask.HasValue)
					{
						AvatarGroup val = avatarGroup;
						val.Failure = await sprites.LoadDefeatedIconAsync();
					}
					else
					{
						avatarGroup.Failure = sprites.LoadDefeatedIcon();
					}
					if (sprites.winIconTask.HasValue)
					{
						AvatarGroup val2 = avatarGroup;
						val2.Normal = await sprites.LoadWinIconAsync();
					}
					else
					{
						avatarGroup.Normal = sprites.LoadWinIcon();
					}
					if (sprites.perfectWinIconTask.HasValue)
					{
						AvatarGroup val3 = avatarGroup;
						val3.TrueEnd = await sprites.LoadPerfectWinIconAsync();
					}
					else
					{
						avatarGroup.TrueEnd = sprites.LoadPerfectWinIcon();
					}
					historyPanel.avatarTable.AlwaysAdd<string, AvatarGroup>(puT.UniqueId, avatarGroup);
				}, puT, OverwriteName("AvatarGroup"), puT.user);
			});
		}

		internal static void LoadForGameResultPanel(GameResultPanel gameResultPanel)
		{
			Wrap(delegate(PlayerUnitTemplate puT)
			{
				PlayerImages sprites = puT.LoadPlayerImages();
				EntityManager.HandleOverwriteWrap(async delegate
				{
					if (sprites.winStandTask.HasValue)
					{
						AssociationList<string, Sprite> characterPortraits = gameResultPanel.characterPortraits;
						string key = puT.UniqueId;
						characterPortraits.AlwaysAdd<string, Sprite>(key, await sprites.LoadWinStandAsync());
					}
					else
					{
						gameResultPanel.characterPortraits.AlwaysAdd<string, Sprite>(puT.UniqueId, sprites.LoadWinStand());
					}
				}, puT, OverwriteName("WinStand"), puT.user);
				EntityManager.HandleOverwriteWrap(async delegate
				{
					if (sprites.defeatedStandTask.HasValue)
					{
						AssociationList<string, Sprite> characterDefeatPortraits = gameResultPanel.characterDefeatPortraits;
						string key = puT.UniqueId;
						characterDefeatPortraits.AlwaysAdd<string, Sprite>(key, await sprites.LoadDefeatedStandAsync());
					}
					else
					{
						gameResultPanel.characterDefeatPortraits.AlwaysAdd<string, Sprite>(puT.UniqueId, sprites.LoadDefeatedStand());
					}
				}, puT, OverwriteName("DefeatedStand"), puT.user);
			});
		}

		internal static void LoadForDeckPanel(ShowCardsPanel showCardsPanel)
		{
			Wrap(delegate(PlayerUnitTemplate puT)
			{
				PlayerImages sprites = puT.LoadPlayerImages();
				EntityManager.HandleOverwriteWrap(async delegate
				{
					if (sprites.deckStandTask.HasValue)
					{
						AssociationList<string, Sprite> characterPortraits = showCardsPanel.characterPortraits;
						string key = puT.UniqueId;
						characterPortraits.AlwaysAdd<string, Sprite>(key, await sprites.LoadDeckStandAsync());
					}
					else
					{
						showCardsPanel.characterPortraits.AlwaysAdd<string, Sprite>(puT.UniqueId, sprites.LoadDeckStand());
					}
				}, puT, OverwriteName("DeckStand"), puT.user);
			});
		}

		internal static void LoadForMuseumPanel(MuseumPanel museumPanel)
		{
			Wrap(delegate(PlayerUnitTemplate puT)
			{
				PlayerImages sprites = puT.LoadPlayerImages();
				Stopwatch stopwatch = new Stopwatch();
				EntityManager.HandleOverwriteWrap(delegate
				{
					museumPanel.portraitList.AlwaysAdd<string, Sprite>(puT.UniqueId, sprites.LoadCollectionIcon());
				}, puT, OverwriteName("CollectionIcon"), puT.user);
			});
		}

		internal static string OverwriteName(string name)
		{
			return "LoadPlayerImages." + name;
		}

		internal static void Wrap(Action<PlayerUnitTemplate> action)
		{
			foreach (List<PlayerUnitTemplate> value in UniqueTracker.Instance.user2PlayerTemplates.Values)
			{
				foreach (PlayerUnitTemplate item in value)
				{
					if (!UniqueTracker.Instance.invalidRegistrations.Contains(item.GetType()))
					{
						action(item);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(ProfilePanel), "Awake")]
	internal class ProfilePanel_Patch
	{
		private static void Prefix(ProfilePanel __instance)
		{
			PlayerSpriteLoader.LoadForProfilePanel(__instance);
		}
	}
	[HarmonyPatch(typeof(HistoryPanel), "Awake")]
	internal class HistoryPanel_Patch
	{
		private static void Prefix(HistoryPanel __instance)
		{
			PlayerSpriteLoader.LoadForHistoryPanel(__instance);
		}
	}
	[HarmonyPatch(typeof(GameResultPanel), "Awake")]
	internal class GameResultPanel_Patch
	{
		private static void Prefix(GameResultPanel __instance)
		{
			PlayerSpriteLoader.LoadForGameResultPanel(__instance);
		}
	}
	[HarmonyPatch(typeof(ShowCardsPanel), "Awake")]
	internal class ShowCardsPanel_Patch
	{
		private static void Prefix(ShowCardsPanel __instance)
		{
			PlayerSpriteLoader.LoadForDeckPanel(__instance);
		}
	}
	[HarmonyPatch(typeof(MuseumPanel), "Awake")]
	internal class MuseumPanel_Patch
	{
		private static void Prefix(MuseumPanel __instance)
		{
			PlayerSpriteLoader.LoadForMuseumPanel(__instance);
		}
	}
	public class StartGamePanel_Patches
	{
		[HarmonyPatch(typeof(StartGamePanel), "Awake")]
		private class Awake_Patch
		{
			[HarmonyPatch(typeof(StartGamePanel), "<Awake>b__71_7")]
			private class StartRunButton_Patch
			{
				private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
				{
					//IL_0003: Unknown result type (might be due to invalid IL or missing references)
					//IL_002c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Expected O, but got Unknown
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_0038: Expected O, but got Unknown
					//IL_0040: Unknown result type (might be due to invalid IL or missing references)
					//IL_004b: 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
					return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
					{
						new CodeMatch(new CodeInstruction(OpCodes.Newobj, (object)AccessTools.Constructor(typeof(ArgumentOutOfRangeException), new Type[0], false)), (string)null),
						new CodeMatch(new CodeInstruction(OpCodes.Throw, (object)null), (string)null)
					}).Advance(1).Set(OpCodes.Pop, (object)null)
						.InstructionEnumeration();
				}
			}

			public static void Prefix(StartGamePanel __instance)
			{
				PlayerSpriteLoader.LoadForStartPanel(__instance);
				GameObject gameObject = ((Component)__instance.characterSetupRoot).gameObject;
				CreateScrollRect(gameObject);
			}

			private static GameObject CreateScrollRect(GameObject loadoutGo)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: 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_00df: 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_0193: Expected O, but got Unknown
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("loadoutScroll");
				val.layer = 5;
				val.transform.position = loadoutGo.transform.position;
				val.transform.SetParent(loadoutGo.transform.parent);
				val.transform.localScale = new Vector3(1f, 1f, 1f);
				loadoutGo.transform.SetParent(val.transform);
				ScrollRect val2 = val.AddComponent<ScrollRect>();
				RectTransform loadoutRectT = loadoutGo.GetComponent<RectTransform>();
				Image val3 = val.AddComponent<Image>();
				((Graphic)val3).color = new Color(0f, 0f, 0f, 0f);
				val.GetComponent<RectTransform>().anchorMax = new Vector2(0.5f, 0.5f);
				val.GetComponent<RectTransform>().anchorMin = new Vector2(0.5f, 0.5f);
				val.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, rectWidth);
				val.GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)1, 1206f);
				val2.content = loadoutRectT;
				val2.horizontal = true;
				val2.vertical = false;
				val2.scrollSensitivity = 25f;
				val2.elasticity = 0.08f;
				val2.movementType = (MovementType)2;
				loadoutGo.transform.KeepPositionAfterAction(delegate
				{
					//IL_0011: 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)
					loadoutRectT.anchorMax = new Vector2(0f, 0.5f);
					loadoutRectT.anchorMin = new Vector2(0f, 0.5f);
				});
				StartSetupWidget val4 = default(StartSetupWidget);
				foreach (object item in loadoutGo.transform)
				{
					RectTransform rt = (RectTransform)item;
					if (((Component)rt).TryGetComponent<StartSetupWidget>(ref val4))
					{
						((Transform)(object)rt).KeepPositionAfterAction(delegate
						{
							//IL_0011: 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)
							rt.anchorMax = new Vector2(0.5f, 1f);
							rt.anchorMin = new Vector2(0.5f, 1f);
						});
					}
				}
				loadoutRectT.SetSizeWithCurrentAnchors((Axis)0, rectWidth);
				scrollGameObject = val;
				loadoutRectTransform = loadoutRectT;
				contentLocalPos = loadoutGo.transform.localPosition;
				return val;
			}

			internal static void TyrCreateLoadoutWidget(int index, UniqueTracker.CharLoadoutInfo loadoutInfo, StartGamePanel startGamePanel)
			{
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Expected O, but got Unknown
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Expected O, but got Unknown
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: 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_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				GameObject gameObject = ((Component)startGamePanel.characterSetupList[0]).gameObject;
				GameObject gameObject2 = ((Component)startGamePanel.characterSetupList[1]).gameObject;
				if (index == startGamePanel.characterSetupList.Count)
				{
					float num = -1f;
					GameObject val;
					if (startGamePanel.characterSetupList.Count % 2 == 0)
					{
						val = gameObject;
						num = -1f;
					}
					else
					{
						val = gameObject2;
						num = 1f;
					}
					GameObject val2 = Object.Instantiate<GameObject>(val, val.transform.parent);
					val2.transform.position = val.transform.position;
					RectTransform rt = val2.GetComponent<RectTransform>();
					((Transform)(object)rt).KeepPositionAfterAction(delegate
					{
						//IL_0011: 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)
						rt.anchorMax = new Vector2(0.5f, 1f);
						rt.anchorMin = new Vector2(0.5f, 1f);
					});
					Transform transform = val2.transform;
					transform.localPosition += new Vector3(700f, 0f, 0f) * (float)((startGamePanel.characterSetupList.Count - 2) / 2 + 1) * num;
					startGamePanel.characterSetupList.Add(val2.GetComponent<StartSetupWidget>());
				}
				StartSetupWidget val3 = startGamePanel.characterSetupList[index];
				((Component)val3).gameObject.SetActive(true);
				((UnityEventBase)((Component)val3).GetComponent<Button>().onClick).RemoveAllListeners();
				((UnityEvent)((Component)val3).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
				{
					startGamePanel.SelectType(index);
				});
				((UnityEventBase)((Component)val3).GetComponent<StartSetupWidget>().DeckButton.onClick).RemoveAllListeners();
				((UnityEvent)((Component)val3).GetComponent<StartSetupWidget>().DeckButton.onClick).AddListener((UnityAction)delegate
				{
					startGamePanel.deckHolder.Clear();
					CollectionExtensions.Do<string>((IEnumerable<string>)loadoutInfo.deck, (Action<string>)delegate(string c)
					{
						startGamePanel.deckHolder.AddCardWidget(Library.CreateCard(c), true);
					});
					string text = ((Unit)startGamePanel._player).ShortName + LocalizationExtensions.Localize("Game.Deck", true) + loadoutInfo.typeSuffix;
					startGamePanel.deckHolder.SetTitle(text, LocalizationExtensions.Localize("Cards.Show", true));
					CanvasGroup component = ((Component)startGamePanel.deckHolder).GetComponent<CanvasGroup>();
					ShortcutExtensions.DOKill((Component)(object)component, false);
					TweenSettingsExtensions.SetUpdate<TweenerCore<float, float, FloatOptions>>(TweenSettingsExtensions.From<float, float, FloatOptions>(DOTweenModuleUI.DOFade(component, 1f, 0.4f), 0f, true, false), true);
					((Component)startGamePanel.deckHolder).gameObject.SetActive(true);
					((Selectable)startGamePanel.deckReturnButton).interactable = true;
				});
			}
		}

		[HarmonyPatch(typeof(StartGamePanel), "SelectPlayer")]
		internal class SelectPlayer_Patch
		{
			private static void Expand_typeCandidates(StartGamePanel startGamePanel)
			{
				//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Expected O, but got Unknown
				string id = ((GameEntity)startGamePanel._player).Id;
				int numberOfWidgets = 2;
				index2complexity.Clear();
				index2complexity.Add(startGamePanel._player.Config.DifficultyA);
				index2complexity.Add(startGamePanel._player.Config.DifficultyB);
				if (UniqueTracker.Instance.loadoutInfos.ContainsKey(id))
				{
					int num = 2;
					foreach (UniqueTracker.CharLoadoutInfo item in UniqueTracker.Instance.loadoutInfos[id])
					{
						Awake_Patch.TyrCreateLoadoutWidget(num, item, startGamePanel);
						startGamePanel._typeCandidates = CollectionExtensions.AddToArray<TypeCandidate>(startGamePanel._typeCandidates, new TypeCandidate
						{
							Name = item.typeName,
							Us = Library.CreateUs(item.ultimateSkill),
							Exhibit = Library.CreateExhibit(item.exhibit),
							Deck = item.deck.Select((string c) => Library.CreateCard(c)).ToArray()
						});
						index2complexity.Add(item.complexity);
						num++;
					}
					numberOfWidgets += UniqueTracker.Instance.loadoutInfos[id].Count;
				}
				CollectionExtensions.Do<StartSetupWidget>(startGamePanel.characterSetupList.Where((StartSetupWidget w, int i) => i + 1 > numberOfWidgets), (Action<StartSetupWidget>)delegate(StartSetupWidget w)
				{
					((Component)w).gameObject.SetActive(false);
				});
				((Component)loadoutRectTransform).gameObject.transform.localPosition = contentLocalPos;
				loadoutRectTransform.SetSizeWithCurrentAnchors((Axis)0, rectWidth + (float)(numberOfWidgets - 2) * 650f);
				ScrollRect component = scrollGameObject.GetComponent<ScrollRect>();
				if (numberOfWidgets > 2)
				{
					component.movementType = (MovementType)1;
				}
				else
				{
					component.movementType = (MovementType)2;
				}
			}

			private static void Prefix(StartGamePanel __instance)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				GameObject gameObject = ((Component)__instance.characterStandPicList[0]).gameObject;
				int count = __instance.characterStandPicList.Count;
				for (int i = 0; i < __instance._players.Count - count; i++)
				{
					GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
					val.transform.localScale = Vector3.one;
					__instance.characterStandPicList.Add(val.GetComponent<CanvasGroup>());
					val.SetActive(false);
				}
			}

			private static int PlayerNumber(StartGamePanel startGamePanel)
			{
				return startGamePanel._players.Count;
			}

			private static int PlayerNumberMinus1(StartGamePanel startGamePanel)
			{
				return startGamePanel._players.Count - 1;
			}

			internal static int ModuloStandNum(int i, StartGamePanel startGamePanel)
			{
				return i % startGamePanel._standPicAlpha.Length;
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0003: 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
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: 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
				return new CodeMatcher(instructions, (ILGenerator)null).End().MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(StartGamePanel), "_typeCandidates"), (string)null)
				}).Advance(1)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null)
					})
					.Advance(1)
					.Insert((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SelectPlayer_Patch), "Expand_typeCandidates", (Type[])null, (Type[])null))
					})
					.InstructionEnumeration();
			}
		}

		[HarmonyPatch(typeof(StartGamePanel), "SelectType")]
		private class SetLoadoutComplexity_Patch
		{
			private static int GetComplexity(int index)
			{
				try
				{
					return index2complexity[index];
				}
				catch (Exception arg)
				{
					Log.log.LogError((object)$"Get loadout complexity: {arg}");
				}
				return 2;
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected O, but got Unknown
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Expected O, but got Unknown
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Expected O, but got Unknown
				Label label = default(Label);
				return new CodeMatcher(instructions, generator).End().MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(StartStatusWidget), "SetSetup", (Type[])null, (Type[])null), (string)null)
				}).CreateLabel(ref label)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1] { CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Pop, (object)null), new Label[1] { label }) })
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_1, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SetLoadoutComplexity_Patch), "GetComplexity", (Type[])null, (Type[])null))
					})
					.MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(OpCodes.Br) })
					.Set(OpCodes.Br, (object)label)
					.InstructionEnumeration();
			}
		}

		public static GameObject scrollGameObject;

		public static RectTransform loadoutRectTransform;

		public static List<int> index2complexity = new List<int>();

		private static float rectWidth = 4200f;

		private static Vector3 contentLocalPos;
	}
	[HarmonyPatch(typeof(ShowCardsPanel), "OnShowing")]
	internal class FixLoadDeckStand_Patch
	{
		private static void Prefix(ShowCardsPanel __instance)
		{
			__instance._currentCharacterIndex = -999;
		}
	}
	internal static class MiniMatcherExtension
	{
		internal static readonly OpCode op_iteratorStore = OpCodes.Stloc_2;

		internal static readonly OpCode op_iteratorLoad = OpCodes.Ldloc_2;

		internal static CodeMatcher Wrap_i(this CodeMatcher _this, bool justMatch = false)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			_this.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
			{
				CodeMatch.op_Implicit(op_iteratorLoad),
				CodeMatch.op_Implicit(OpCodes.Ldelem_R4)
			});
			if (!justMatch)
			{
				_this.Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null)
				}).Insert((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(StartGamePanel_Patches.SelectPlayer_Patch), "ModuloStandNum", (Type[])null, (Type[])null))
				});
			}
			return _this;
		}

		internal static CodeMatcher Wrap_iPlusNum(this CodeMatcher _this)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			return _this.MatchForward(true, (CodeMatch[])(object)new CodeMatch[4]
			{
				CodeMatch.op_Implicit(op_iteratorLoad),
				CodeMatch.op_Implicit(OpCodes.Ldloc_0),
				CodeMatch.op_Implicit(OpCodes.Add),
				CodeMatch.op_Implicit(OpCodes.Ldelem_R4)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			}).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(StartGamePanel_Patches.SelectPlayer_Patch), "ModuloStandNum", (Type[])null, (Type[])null))
			});
		}
	}
}
namespace LBoLEntitySideloader.Entities.MockConfigs
{
	internal class IntentionMockConfig : MockConfig
	{
	}
	internal abstract class MockConfig
	{
	}
}
namespace LBoLEntitySideloader.Entities.DynamicTemplates
{
	public class DynamicSpell : SpellTemplate, IDynamicTemplate<SpellTemplate>
	{
		public Func<IdContainer> CreateId { get; set; }

		public Func<LocalizationOption> CreateLoadLoc { get; set; }

		public Func<SpellConfig> CreateMakeConfig { get; set; }

		public SpellTemplate Create(IdContainer Id, UserInfo user)
		{
			IDynamicTemplate<SpellTemplate>.SetUser(this, user);
			CreateId = () => Id;
			try
			{
				EntityManager.Instance.RegisterConfig(this, user);
			}
			catch (Exception ex)
			{
				Log.log.LogError((object)ex);
			}
			try
			{
				Consume(LoadLocalization());
			}
			catch (Exception ex2)
			{
				Log.log.LogError((object)ex2);
			}
			UniqueTracker.Instance.spellTemplates.TryAdd(userAssembly, new Dictionary<string, SpellTemplate>());
			UniqueTracker.Instance.spellTemplates[userAssembly].Add(GetId(), this);
			return this;
		}

		public override IdContainer GetId()
		{
			return CreateId();
		}

		public override LocalizationOption LoadLocalization()
		{
			return CreateLoadLoc();
		}

		public override SpellConfig MakeConfig()
		{
			return CreateMakeConfig();
		}
	}
	public interface IDynamicTemplate<T> where T : EntityDefinition
	{
		T Create(IdContainer Id, UserInfo user);

		static void SetUser(T template, UserInfo user)
		{
			template.user = user;
			template.userAssembly = user.assembly;
		}
	}
}
namespace LBoLEntitySideloader.CustomKeywords
{
	public enum KwDescPos
	{
		DoNotDisplay,
		First,
		Last
	}
	public enum CloningMethod
	{
		DoesntMatter,
		NonBattle,
		Copy,
		TwiceToken
	}
	public class CardKeyword
	{
		public readonly string kwSEid;

		public KwDescPos descPos = KwDescPos.Last;

		public readonly bool isVerbose = false;

		public bool hasExtendedKeywordName = false;

		public virtual CardKeyword CloneWithCard(Card og, [MaybeNull] Card other, CloningMethod cloningMethod)
		{
			return Clone(cloningMethod);
		}

		[return: MaybeNull]
		public virtual CardKeyword Clone(CloningMethod cloningMethod)
		{
			return new CardKeyword(kwSEid, isVerbose)
			{
				descPos = descPos
			};
		}

		public virtual void Merge(CardKeyword other)
		{
		}

		public CardKeyword(string kwSEid, bool isVerbose = false)
		{
			this.kwSEid = kwSEid;
			this.isVerbose = isVerbose;
		}

		public override bool Equals(object obj)
		{
			return obj is CardKeyword cardKeyword && kwSEid == cardKeyword.kwSEid;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(kwSEid);
		}
	}
	[HarmonyPatch]
	internal class Clone_Patch
	{
		[HarmonyPatch(typeof(Card), "Clone", new Type[] { typeof(bool) })]
		[HarmonyPostfix]
		private static void NonBattle(Card __instance, Card __result)
		{
			CopyKeywords(__instance, __result, CloningMethod.NonBattle);
			if (__instance is IExtendedCardClone extendedCardClone)
			{
				extendedCardClone.ExtendedCardClone(__result, CloningMethod.NonBattle);
			}
		}

		[HarmonyPatch(typeof(Card), "CloneBattleCard")]
		[HarmonyPostfix]
		private static void Copy(Card __instance, Card __result)
		{
			CopyKeywords(__instance, __result, CloningMethod.Copy);
			if (__instance is IExtendedCardClone extendedCardClone)
			{
				extendedCardClone.ExtendedCardClone(__result, CloningMethod.Copy);
			}
		}

		[HarmonyPatch(typeof(Card), "CloneTwiceToken")]
		[HarmonyPostfix]
		private static void TwiceToken(Card __instance, Card __result)
		{
			CopyKeywords(__instance, __result, CloningMethod.TwiceToken);
			if (__instance is IExtendedCardClone extendedCardClone)
			{
				extendedCardClone.ExtendedCardClone(__result, CloningMethod.TwiceToken);
			}
		}

		private static void CopyKeywords(Card og, Card copy, CloningMethod cloningMethod)
		{
			foreach (CardKeyword item in og.AllCustomKeywords())
			{
				CardKeyword cardKeyword = item.CloneWithCard(og, copy, cloningMethod);
				if (cardKeyword != null)
				{
					copy.AddCustomKeyword(cardKeyword);
				}
			}
		}
	}
	public static class KeywordManager
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class Card_Tooltip_Patch
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase originalMethod)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Expected O, but got Unknown
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Expected O, but got Unknown
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Expected O, but got Unknown
				return new CodeMatcher(instructions, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Library), "InternalEnumerateDisplayWords", (Type[])null, (Type[])null))) }).MatchEndBackwards((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(OpCodes.Ldloc_S) }).Advance(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(originalMethod.DeclaringType, "verbose"))
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldloc_2, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Card_Tooltip_Patch), "AppendCustomKeywords", (Type[])null, (Type[])null))
					})
					.MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
					{
						CodeMatch.op_Implicit(OpCodes.Ldloc_S),
						CodeMatch.op_Implicit(OpCodes.Stfld)
					})
					.Advance(1)
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldloc_2, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Card_Tooltip_Patch), "InvokeOnTooltipDisplay", (Type[])null, (Type[])null))
					})
					.InstructionEnumeration();
			}

			private static IDisplayWord InvokeOnTooltipDisplay(IDisplayWord displayWord, Card card)
			{
				if (displayWord is IOnTooltipDisplay onTooltipDisplay)
				{
					onTooltipDisplay.OnTooltipDisplay(card);
				}
				return displayWord;
			}

			private static IEnumerable<string> AppendCustomKeywords(IReadOnlyList<string> keywords, bool displayVerbose, Card card)
			{
				return keywords.Concat(from kw in card.AllCustomKeywords()
					where !kw.isVerbose || displayVerbose
					select kw.kwSEid);
			}
		}

		[HarmonyPatch(typeof(Card), "EnumerateAutoAppendKeywordNames")]
		private class Card_Description_Patch
		{
			private static void Postfix(Card __instance, ref IEnumerable<string> __result)
			{
				IEnumerable<IGrouping<KwDescPos, string>> source = (from kw in __instance.AllCustomKeywords()
					where kw.descPos != KwDescPos.DoNotDisplay
					select kw).GroupBy((CardKeyword kw) => kw.descPos, delegate(CardKeyword kw)
				{
					if (kw.hasExtendedKeywordName)
					{
						StatusEffect val = TypeFactory<StatusEffect>.CreateInstance(kw.kwSEid);
						if (val is IExtendedKeywordName extendedKeywordName)
						{
							return extendedKeywordName.ExtendedKeywordName(__instance);
						}
						ManualLogSource obj = Log.LogDev();
						if (obj != null)
						{
							obj.LogWarning((object)("Keyword kw expects extended keyword name but " + kw.kwSEid + " does not implement IExtendedKeywordName"));
						}
					}
					return TypeFactory<StatusEffect>.LocalizeProperty(kw.kwSEid, "Name", true, false);
				});
				__result = source.SelectMany(delegate(IGrouping<KwDescPos, string> g)
				{
					object result;
					if (g.Key != KwDescPos.First)
					{
						result = Enumerable.Empty<string>();
					}
					else
					{
						result = g;
					}
					return (IEnumerable<string>)result;
				}).Concat(__result).Concat(source.SelectMany(delegate(IGrouping<KwDescPos, string> g)
				{
					object result;
					if (g.Key != KwDescPos.Last)
					{
						result = Enumerable.Empty<string>();
					}
					else
					{
						result = g;
					}
					return (IEnumerable<string>)result;
				}));
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class DescCheckCustomKw_Patch
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0003: 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_0033: Expected O, but got Unknown
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				return new CodeMatcher(instructions, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredPropertyGetter(typeof(Card), "Keywords"))) }).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null)
				})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(DescCheckCustomKw_Patch), "CheckCustomKws", (Type[])null, (Type[])null))
					})
					.InstructionEnumeration();
			}

			private static bool CheckCustomKws(Keyword keywords, Card card)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return (int)keywords != 0 || card.AllCustomKeywords().Count() > 0;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class StatusEffect_Brief_Patch
		{
			private static void Postfix(StatusEffect __instance, ref string __result)
			{
				if (__instance is IOverrideSEBrief overrideSEBrief)
				{
					__result = overrideSEBrief.OverrideBrief(__result);
				}
			}
		}

		private static ConditionalWeakTable<Card, Dictionary<string, CardKeyword>> cwt_keywords = new ConditionalWeakTable<Card, Dictionary<string, CardKeyword>>();

		private static Dictionary<string, CardKeyword> GetKeywords(Card card)
		{
			return cwt_keywords.GetValue(card, (Card _) => new Dictionary<string, CardKeyword>());
		}

		public static IEnumerable<CardKeyword> AllCustomKeywords(this Card card)
		{
			if (cwt_keywords.TryGetValue(card, out var value))
			{
				return value.Values;
			}
			return new HashSet<CardKeyword>();
		}

		public static bool HasCustomKeyword(this Card card, string kwId)
		{
			return GetKeywords(card).ContainsKey(kwId);
		}

		public static void AddCustomKeyword(this Card card, CardKeyword keyword)
		{
			if (GetKeywords(card).TryGetValue(keyword.kwSEid, out var value))
			{
				value.Merge(keyword);
			}
			else
			{
				GetKeywords(card).Add(keyword.kwSEid, keyword);
			}
		}

		public static void AddCustomKeyword<T>(this Card card, T keyword) where T : CardKeyword
		{
			card.AddCustomKeyword((CardKeyword)keyword);
		}

		public static bool RemoveCustomKeyword(this Card card, CardKeyword keyword)
		{
			return GetKeywords(card).Remove(keyword.kwSEid);
		}

		public static bool TryGetCustomKeyword(this Card card, string kwId, out CardKeyword rezKeyword)
		{
			return GetKeywords(card).TryGetValue(kwId, out rezKeyword);
		}

		public static bool TryGetCustomKeyword<T>(this Card card, string kwId, out T rezKeyword) where T : CardKeyword
		{
			CardKeyword rezKeyword2;
			bool flag = card.TryGetCustomKeyword(kwId, out rezKeyword2);
			rezKeyword = null;
			if (flag)
			{
				rezKeyword = (T)rezKeyword2;
			}
			return flag;
		}

		public static CardKeyword GetCustomKeyword(this Card card, string kwId)
		{
			card.TryGetCustomKeyword(kwId, out var rezKeyword);
			return rezKeyword;
		}

		public static T GetCustomKeyword<T>(this Card card, string kwId) where T : CardKeyword
		{
			return card.GetCustomKeyword(kwId) as T;
		}
	}
	public interface IOnTooltipDisplay
	{
		void OnTooltipDisplay(Card card);
	}
	public interface IOverrideSEBrief
	{
		string OverrideBrief(string rawBrief);
	}
	public interface IExtendedKeywordName
	{
		string ExtendedKeywordName(Card card);
	}
	public interface IExtendedCardClone
	{
		void ExtendedCardClone(Card clonedCard, CloningMethod cloningMethod);
	}
}
namespace LBoLEntitySideloader.CustomHandlers
{
	public delegate GameEvent<T> EventProvider<T, in PT>(PT provider) where T : GameEventArgs;
	public class CHandlerManager
	{
		public Dictionary<Type, HashSet<IHandleHolder>> gameRunHandlers = new Dictionary<Type, HashSet<IHandleHolder>>();

		public Dictionary<Type, HashSet<IHandleHolder>> battleEventHandlers = new Dictionary<Type, HashSet<IHandleHolder>>();

		public static void RegisterBattleEventHandler<T>(EventProvider<T, BattleController> eventProvider, GameEventHandler<T> handler, Predicate<BattleController> filter = null, GameEventPriority priority = (GameEventPriority)10) where T : GameEventArgs
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			HandlerHolder<T, BattleController> handlerHolder = RegisterEventHandler(eventProvider, handler, priority, UniqueTracker.Instance.cHandlerManager.battleEventHandlers);
			handlerHolder.filter = filter;
		}

		public static void RegisterGameEventHandler<T>(EventProvider<T, GameRunController> eventProvider, GameEventHandler<T> handler, GameEventPriority priority = (GameEventPriority)10) where T : GameEventArgs
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			RegisterEventHandler(eventProvider, handler, priority, UniqueTracker.Instance.cHandlerManager.gameRunHandlers);
		}

		internal static HandlerHolder<T, PT> RegisterEventHandler<T, PT>(EventProvider<T, PT> eventProvider, GameEventHandler<T> handler, GameEventPriority priority, Dictionary<Type, HashSet<IHandleHolder>> handlers) where T : GameEventArgs where PT : class
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			handlers.TryAdd(typeof(T), new HashSet<IHandleHolder>());
			HandlerHolder<T, PT> handlerHolder = new HandlerHolder<T, PT>
			{
				eventProvider = eventProvider,
				handler = handler,
				priority = priority
			};
			if (!handlers[typeof(T)].Add(handlerHolder))
			{
				BepinexPlugin.log.LogWarning((object)$"Custom handler (event holder: {typeof(PT)}, args: {typeof(T)}) was already registered thus not registered again.");
			}
			return handlerHolder;
		}

		internal static void IterateHandlers(Dictionary<Type, HashSet<IHandleHolder>> handlers, Action<IHandleHolder> hhAction, Func<Type, IHandleHolder, bool> filter = null)
		{
			foreach (var (arg, hashSet2) in handlers)
			{
				foreach (IHandleHolder item in hashSet2)
				{
					if (filter == null || filter(arg, item))
					{
						hhAction(item);
					}
				}
			}
		}
	}
	public interface IHandleHolder
	{
		void RegisterHandler(object eventProvider);

		void UnregisterHandler(object eventProvider);
	}
	public class HandlerHolder<T, PT> : IHandleHolder where T : GameEventArgs where PT : class
	{
		public EventProvider<T, PT> eventProvider;

		public GameEventHandler<T> handler;

		public GameEventPriority priority;

		public Predicate<PT> filter;

		public override bool Equals(object obj)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (obj is HandlerHolder<T, PT> handlerHolder)
			{
				return (eventProvider?.Equals(handlerHolder.eventProvider) ?? (handlerHolder.eventProvider == null)) && (((object)handler)?.Equals((object?)handlerHolder.handler) ?? (handlerHolder.handler == null)) && (filter?.Equals(handlerHolder.filter) ?? (handlerHolder.filter == null)) && priority == handlerHolder.priority;
			}
			return false;
		}

		public override int GetHashCode()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return HashCode.Combine<EventProvider<T, PT>, GameEventHandler<T>, Predicate<PT>, GameEventPriority>(eventProvider, handler, filter, priority);
		}

		public GameEventPriority GetPriority()
		{
			//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_000a: Unknown result type (might be due to invalid IL or missing references)
			return priority;
		}

		public void RegisterHandler(object provider)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (provider is PT val && (filter == null || filter(val)))
			{
				GameEvent<T> val2 = eventProvider(val);
				val2.AddHandler(handler, priority);
			}
		}

		public void UnregisterHandler(object provider)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (provider is PT provider2)
			{
				GameEvent<T> val = eventProvider(provider2);
				val.RemoveHandler(handler, priority);
			}
		}
	}
	[HarmonyPatch]
	internal class GameRunController_Init_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(GameRunController), "Create", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(GameRunController), "Restore", (Type[])null, (Type[])null);
		}

		private static void Postfix(GameRunController __result)
		{
			CHandlerManager.IterateHandlers(UniqueTracker.Instance.cHandlerManager.gameRunHandlers, delegate(IHandleHolder hh)
			{
				hh.RegisterHandler(__result);
			});
		}
	}
	[HarmonyPatch(typeof(UiPanelBase), "LeaveGameRun")]
	internal class UiPanelBase_LeaveGameRun_Patch
	{
		private static void Prefix(UiPanel __instance)
		{
			GameRunController gr = ((UiPanelBase)__instance).GameRun;
			if (gr != null)
			{
				CHandlerManager.IterateHandlers(UniqueTracker.Instance.cHandlerManager.gameRunHandlers, delegate(IHandleHolder hh)
				{
					hh.UnregisterHandler(gr);
				});
			}
		}
	}
	[HarmonyPatch]
	internal class BattleController_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.DeclaredConstructor(typeof(BattleController), new Type[3]
			{
				typeof(GameRunController),
				typeof(EnemyGroup),
				typeof(IEnumerable<Card>)
			}, false);
		}

		private static void Postfix(BattleController __instance)
		{
			CHandlerManager.IterateHandlers(UniqueTracker.Instance.cHandlerManager.battleEventHandlers, delegate(IHandleHolder hh)
			{
				hh.RegisterHandler(__instance);
			});
		}
	}
	[HarmonyPatch(typeof(BattleController), "Leave")]
	internal class BattleController_Leave_Patch
	{
		private static void Postfix(BattleController __instance)
		{
			CHandlerManager.IterateHandlers(UniqueTracker.Instance.cHandlerManager.battleEventHandlers, delegate(IHandleHolder hh)
			{
				hh.UnregisterHandler(__instance);
			});
		}
	}
}
namespace LBoLEntitySideloader.BattleModifiers
{
	public delegate bool ModPrecond(Unit unit);
	public delegate Unit ModUnit(Unit unit);
	public class ModFactory
	{
		public static ModUnit LazyArg<T>(Func<T> getArg, Func<T, ModUnit> target)
		{
			return delegate(Unit unit)
			{
				T arg = getArg();
				return target(arg)(unit);
			};
		}

		public static ModUnit LazyArg<T, T1>(Func<T> getArg, Func<T1> getArg2, Func<T, T1, ModUnit> target)
		{
			return delegate(Unit unit)
			{
				T arg = getArg();
				T1 arg2 = getArg2();
				return target(arg, arg2)(unit);
			};
		}

		public static ModUnit LazyArg<T, T1, T2>(Func<T> getArg, Func<T1> getArg2, Func<T2> getArg3, Func<T, T1, T2, ModUnit> target)
		{
			return delegate(Unit unit)
			{
				T arg = getArg();
				T1 arg2 = getArg2();
				T2 arg3 = getArg3();
				return target(arg, arg2, arg3)(unit);
			};
		}

		public static ModUnit AddSE<T>(int? level = null, int? duration = null, int? count = null, int? limit = null, float occupationTime = 0f, bool startAutoDecreasing = true) where T : StatusEffect
		{
			return AddSE(typeof(T), level, duration, count, limit, occupationTime, startAutoDecreasing);
		}

		public static ModUnit AddSE(Type se, int? level = null, int? duration = null, int? count = null, int? limit = null, float occupationTime = 0f, bool startAutoDecreasing = true)
		{
			return delegate(Unit unit)
			{
				((GameEntity)unit).React((IEnumerable<BattleAction>)(object)new BattleAction[1] { (BattleAction)new ApplySEnoTriggers(se, unit, level, duration, count, limit, occupationTime, startAutoDecreasing) });
				return unit;
			};
		}

		public static ModUnit MulEffetiveHp(float multiplier)
		{
			return MultiplyHp(multiplier, multiplyBlock: true);
		}

		public static ModUnit MultiplyHp(float multiplier, bool multiplyBlock = false)
		{
			return delegate(Unit unit)
			{
				int num = ModifyBlockShield.ApplyMul(unit.MaxHp, multiplier, 1);
				unit.SetMaxHp(num, num);
				if (multiplyBlock)
				{
					((GameEntity)unit).React(Reactor.op_Implicit((BattleAction)(object)new ModifyBlockShield(unit, 0, 0, multiplier)));
				}
				IUnitView view = unit.View;
				UnitView val = (UnitView)(object)((view is UnitView) ? view : null);
				if ((Object)(object)val != (Object)null)
				{
					val._statusWidget.SetHpBar();
					if (unit is PlayerUnit)
					{
						UiManager.GetPanel<SystemBoard>().OnMaxHpChanged();
						val.OnMaxHpChanged();
					}
				}
				return unit;
			};
		}

		public static ModUnit ScaleModel(float multiplier)
		{
			return delegate(Unit unit)
			{
				//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)
				IUnitView view = unit.View;
				UnitView val = (UnitView)(object)((view is UnitView) ? view : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).transform.localScale = ((Component)val).transform.localScale * multiplier;
				}
				return unit;
			};
		}

		public static ModUnit StageCheck(Type stageType, ModUnit mod)
		{
			return (Unit unit) => PrecondFactory.IsStage(stageType)(unit) ? unit : mod(unit);
		}

		public static ModUnit DoSomeAction(ModUnit action)
		{
			return delegate(Unit unit)
			{
				((GameEntity)unit).React(Reactor.op_Implicit((BattleAction)(object)new ArbitraryBattleAction(unit, action)));
				return unit;
			};
		}
	}
	[HarmonyPatch]
	internal class ApplyEnemyMods_Patch
	{
		[HarmonyPatch(typeof(Unit), "EnterBattle")]
		[HarmonyPostfix]
		private static void EnterBattle_Postfix(Unit __instance)
		{
			__instance.HandleBattleEvent<GameEventArgs>(__instance.Battle.BattleStarted, (GameEventHandler<GameEventArgs>)delegate
			{
				UnitModTracker.Instance.Perform(__instance);
			}, (GameEventPriority)999);
		}

		[HarmonyPatch(typeof(BattleController), "Spawn", new Type[]
		{
			typeof(EnemyUnit),
			typeof(EnemyUnit),
			typeof(int),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void Spawn_Postfix(EnemyUnit __result)
		{
			UnitModTracker.Instance.Perform((Unit)(object)__result);
		}
	}
	[HarmonyPatch(typeof(GameDirector), "EnterBattle")]
	internal class GameDirectorEnterBattle_Patch
	{
		private static void Postfix(GameDirector __instance, BattleController battle)
		{
			battle.ActionViewer.Register<ApplySEnoTriggers>((BattleActionViewer<ApplySEnoTriggers>)__instance.ApplyStatusEffectViewer, (Predicate<ApplySEnoTriggers>)null);
			battle.ActionViewer.Register<ModifyBlockShield>((BattleActionViewer<ModifyBlockShield>)GameDirector.LoseBlockShieldViewer, (Predicate<ModifyBlockShield>)null);
		}
	}
	[HarmonyPatch(typeof(GameDirector), "LeaveBattle")]
	internal class GameDirectorLeaveBattle_Patch
	{
		private static void Postfix(GameDirector __instance, BattleController battle)
		{
			battle.ActionViewer.Unregister<ApplySEnoTriggers>((BattleActionViewer<ApplySEnoTriggers>)__instance.ApplyStatusEffectViewer);
			battle.ActionViewer.Unregister<ModifyBlockShield>((BattleActionViewer<ModifyBlockShield>)GameDirector.LoseBlockShieldViewer);
		}
	}
	public static class PrecondFactory
	{
		public static ModPrecond HasJadeboxes(HashSet<string> jadeBoxes)
		{
			return (Unit unit) => ((GameEntity)unit).GameRun.JadeBoxes.Select((JadeBox jb) => ((object)jb).GetType().Name).Count((string name) => jadeBoxes.Contains(name)) >= jadeBoxes.Count;
		}

		public static ModPrecond IsEnemyGroup(string groupId)
		{
			return delegate
			{
				int result;
				if (groupId != null)
				{
					GameMaster instance = Singleton<GameMaster>.Instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						GameRunController currentGameRun = instance.CurrentGameRun;
						if (currentGameRun == null)
						{
							obj = null;
						}
						else
						{
							BattleController battle = currentGameRun.Battle;
							if (battle == null)
							{
								obj = null;
							}
							else
							{
								EnemyGroup enemyGroup = battle.EnemyGroup;
								obj = ((enemyGroup != null) ? enemyGroup.Id : null);
							}
						}
					}
					result = (((string?)obj == groupId) ? 1 : 0);
				}
				else
				{
					result = 0;
				}
				return (byte)result != 0;
			};
		}

		public static ModPrecond IsStage(Type stageType)
		{
			return delegate
			{
				int result;
				if (stageType != null)
				{
					GameMaster instance = Singleton<GameMaster>.Instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						GameRunController currentGameRun = instance.CurrentGameRun;
						obj = ((currentGameRun == null) ? null : ((object)currentGameRun.CurrentStage)?.GetType());
					}
					result = (((Type?)obj == stageType) ? 1 : 0);
				}
				else
				{
					result = 0;
				}
				return (byte)result != 0;
			};
		}
	}
	public class UnitModifier
	{
		public string unitId;

		public bool modifyPlayer = false;

		public HashSet<ModPrecond> preconds = new HashSet<ModPrecond>();

		public List<ModUnit> mods = new List<ModUnit>();

		public UnitModifier(string groupId, bool modifyPlayer = false)
		{
			unitId = groupId;
			UnitModTracker.Instance.AddModifier(this);
			this.modifyPlayer = modifyPlayer;
		}

		public void ApplyMods(Unit unit)
		{
			if ((unit is PlayerUnit && !modifyPlayer) || (preconds.Count > 0 && preconds.Select((ModPrecond p) => p(unit)).Any((bool b) => !b)))
			{
				return;
			}
			foreach (ModUnit mod in mods)
			{
				try
				{
					mod(unit);
				}
				catch (Exception ex)
				{
					BepinexPlugin.log.LogError((object)ex);
				}
			}
		}
	}
	public class UnitModTracker
	{
		private static UnitModTracker _instance;

		private Dictionary<string, HashSet<UnitModifier>> modDic = new Dictionary<string, HashSet<UnitModifier>>();

		public static UnitModTracker Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new UnitModTracker();
				}
				return _instance;
			}
		}

		public void AddModifier(UnitModifier modifier)
		{
			modDic.TryAdd(modifier.unitId, new HashSet<UnitModifier>());
			modDic[modifier.unitId].Add(modifier);
		}

		public void Perform(Unit unit)
		{
			if (modDic.TryGetValue(((GameEntity)unit).Id, out var value))
			{
				CollectionExtensions.Do<UnitModifier>((IEnumerable<UnitModifier>)value, (Action<UnitModifier>)delegate(UnitModifier m)
				{
					m.ApplyMods(unit);
				});
			}
		}
	}
}
namespace LBoLEntitySideloader.BattleModifiers.Args
{
	public class ArbitraryBattleEventArgs : GameEventArgs
	{
		public Unit Target { get; set; }

		public ModUnit unitAction { get; set; }

		protected override string GetBaseDebugString()
		{
			return "ArbitraryAction: " + GameEventArgs.DebugString((GameEntity)(object)Target);
		}
	}
}
namespace LBoLEntitySideloader.BattleModifiers.Actions
{
	public class ApplySEnoTriggers : ApplyStatusEffectAction
	{
		public ApplySEnoTriggers(Type type, Unit target, int? level = null, int? duration = null, int? count = null, int? limit = null, float occupationTime = 0f, bool startAutoDecreasing = true)
			: base(type, target, level, duration, count, limit, occupationTime, startAutoDecreasing)
		{
		}

		protected override void PreEventPhase()
		{
		}

		protected override void PostEventPhase()
		{
		}
	}
	public class ArbitraryBattleAction : SimpleEventBattleAction<ArbitraryBattleEventArgs>
	{
		public ArbitraryBattleAction(Unit unit, ModUnit unitAction)
		{
			((EventBattleAction<ArbitraryBattleEventArgs>)(object)this).Args = new ArbitraryBattleEventArgs();
			((EventBattleAction<ArbitraryBattleEventArgs>)(object)this).Args.Target = unit;
			((EventBattleAction<ArbitraryBattleEventArgs>)(object)this).Args.unitAction = unitAction;
		}

		protected override void MainPhase()
		{
			try
			{
				((EventBattleAction<ArbitraryBattleEventArgs>)(object)this).Args.unitAction(((EventBattleAction<ArbitraryBattleEventArgs>)(object)this).Args.Target);
			}
			catch (Exception arg)
			{
				BepinexPlugin.log.LogError((object)$"Exception during {((object)this).GetType().Name}: {arg}");
			}
		}
	}
	public class ModifyBlockShield : LoseBlockShieldAction
	{
		private float multiplier;

		public ModifyBlockShield(Unit target, int block, int shield, float multiplier = 1f, bool forced = true)
			: base(target, block, shield, forced)
		{
			this.multiplier = multiplier;
			BlockShieldEventArgs args = ((EventBattleAction<BlockShieldEventArgs>)this).Args;
			args.Block *= -1f;
			BlockShieldEventArgs args2 = ((EventBattleAction<BlockShieldEventArgs>)this).Args;
			args2.Shield *= -1f;
		}

		public static int ApplyMul(int val, float mul, int min)
		{
			return (int)Math.Max((float)val * mul, min);
		}

		protected override void PreEventPhase()
		{
			Unit target = ((EventBattleAction<BlockShieldEventArgs>)this).Args.Target;
			BlockShieldEventArgs args = ((EventBattleAction<BlockShieldEventArgs>)this).Args;
			args.Block += (float)(target.Block - ApplyMul(target.Block, multiplier, 0));
			BlockShieldEventArgs args2 = ((EventBattleAction<BlockShieldEventArgs>)this).Args;
			args2.Shield += (float)(target.Shield - ApplyMul(target.Shield, multiplier, 0));
		}

		protected override void PostEventPhase()
		{
		}

		public override string ExportDebugDetails()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((EventBattleAction<BlockShieldEventArgs>)this).Args.Type > 0)
			{
				return string.Format("{0} --- {{B: {1}, S: {2}, mul: {3}, Type: {5}}} --> {6}", GameEventArgs.DebugString((GameEntity)(object)((EventBattleAction<BlockShieldEventArgs>)this).Args.Source), 0f - ((EventBattleAction<BlockShieldEventArgs>)this).Args.Block, 0f - ((EventBattleAction<BlockShieldEventArgs>)this).Args.Shield, ((EventBattleAction<BlockShieldEventArgs>)this).Args.Type, multiplier, GameEventArgs.DebugString((GameEntity)(object)((EventBattleAction<BlockShieldEventArgs>)this).Args.Target));
			}
			return $"{GameEventArgs.DebugString((GameEntity)(object)((EventBattleAction<BlockShieldEventArgs>)this).Args.Source)} --- {{B: {0f - ((EventBattleAction<BlockShieldEventArgs>)this).Args.Block}, S: {0f - ((EventBattleAction<BlockShieldEventArgs>)this).Args.Shield}, mul: {multiplier}}} --> {GameEventArgs.DebugString((GameEntity)(object)((EventBattleAction<BlockShieldEventArgs>)this).Args.Target)}";
		}
	}
}
namespace LBoLEntitySideloader.Attributes
{
	public static class AttributeExtensions
	{
		public static AT SingularAttribute<AT>(this Type type, object[] allAttributes = null) where AT : Attribute
		{
			if (allAttributes == null)
			{
				allAttributes = (allAttributes = type.GetCustomAttributes(inherit: false));
			}
			object obj = allAttributes.Where((object a) => a.GetType() == typeof(AT)).SingleOrDefault();
			if (obj is AT result)
			{
				return result;
			}
			return null;
		}

		public static IEnumerable<AT> MultiAttribute<AT>(this Type type, object[] allAttributes = null) where AT : Attribute
		{
			if (allAttributes == null)
			{
				allAttributes = (allAttributes = type.GetCustomAttributes(inherit: false));
			}
			IEnumerable<AT> enumerable = (from a in allAttributes
				where a.GetType() == typeof(AT)
				select (AT)a).AsEnumerable();
			if (enumerable.Count() != 0)
			{
				return enumerable;
			}
			return null;
		}
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
	public sealed class DontOverwriteAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	public sealed class EntityLogic : Attribute
	{
		private readonly Type definitionType;

		public Type DefinitionType => definitionType;

		public EntityLogic(Type definitionType)
		{
			this.definitionType = definitionType;
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	public sealed class ExternalEntityLogicAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
	public sealed class OverwriteVanilla : Attribute
	{
		private string idToOverwrite;

		private bool overideAllComponents = false;

		public string IdToOverwrite
		{
			get
			{
				return idToOverwrite;
			}
			set
			{
				idToOverwrite = value;
			}
		}

		public bool OverideAllComponents
		{
			get
			{
				return overideAllComponents;
			}
			set
			{
				overideAllComponents = value;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}