using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using HarmonyLib;
using KijinSeijaMod.BattleActions;
using KijinSeijaMod.Cards;
using KijinSeijaMod.Cards.Template;
using KijinSeijaMod.Config;
using KijinSeijaMod.Enemies;
using KijinSeijaMod.Enemies.Template;
using KijinSeijaMod.GunName;
using KijinSeijaMod.ImageLoader;
using KijinSeijaMod.Localization;
using KijinSeijaMod.Patches;
using KijinSeijaMod.StatusEffects;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Battle.Interactions;
using LBoL.Core.Cards;
using LBoL.Core.Dialogs;
using LBoL.Core.Intentions;
using LBoL.Core.Randoms;
using LBoL.Core.Stations;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Cirno;
using LBoL.EntityLib.StatusEffects.Enemy;
using LBoL.EntityLib.StatusEffects.ExtraTurn;
using LBoL.EntityLib.StatusEffects.Koishi;
using LBoL.EntityLib.StatusEffects.Neutral.Black;
using LBoL.EntityLib.StatusEffects.Neutral.TwoColor;
using LBoL.EntityLib.StatusEffects.Others;
using LBoL.EntityLib.StatusEffects.Sakuya;
using LBoL.Presentation;
using LBoL.Presentation.UI.Widgets;
using LBoL.Presentation.Units;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.UI;
using YamlDotNet.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = "")]
[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("KijinSeijaMod_windows")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("KijinSeijaMod_windows")]
[assembly: AssemblyTitle("KijinSeijaMod_windows")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace KijinSeijaMod
{
	[BepInPlugin("author.game.typeofmod.KijinSeija", "KijinSeijaMod", "0.1.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static string modUniqueID = "KijinSeijaMod";

		public static string playerName = "KijinSeija";

		public static bool useInGameModel = false;

		public static string modelName = "KijinSeija";

		public static bool modelIsFlipped = true;

		public static List<ManaColor> offColors = new List<ManaColor> { (ManaColor)6 };

		public static ConfigEntry<bool> enableAct1Boss;

		public static CustomConfigEntry<bool> enableAct1BossEntry = new CustomConfigEntry<bool>(value: false, "EnableAct1Boss", "EnableAct1Boss", "Toggle the Act 1 boss. Default: Off");

		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static BatchLocalization unitModelLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(UnitModelTemplate), false);

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

		internal static BatchLocalization exhibitLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(ExhibitTemplate), false);

		internal static IResourceSource embeddedSource = (IResourceSource)new EmbeddedSource(Assembly.GetExecutingAssembly());

		internal static DirectorySource directorySource = new DirectorySource("author.game.typeofmod.KijinSeija", "");

		public static ConfigEntry<string> KijinSeijaRecords;

		private static object KijinSeija()
		{
			throw new NotImplementedException();
		}

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Harmony val = new Harmony(modUniqueID);
			val.PatchAll();
			log = ((BaseUnityPlugin)this).Logger;
			enableAct1Boss = ((BaseUnityPlugin)this).Config.Bind<bool>(enableAct1BossEntry.Section, enableAct1BossEntry.Key, enableAct1BossEntry.Value, enableAct1BossEntry.Description);
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			CardIndexGenerator.PromiseClearIndexSet();
			EntityManager.RegisterSelf();
			KijinSeijaRecords = ((BaseUnityPlugin)this).Config.Bind<string>("Records", "Records", "", "May cause an error if edited manually.");
			Func<Sprite> func = () => ResourceLoader.LoadSprite("BossIcon.png", (IResourceSource)(object)directorySource, (Rect?)null, 1, (Vector2?)null);
			EnemyUnitTemplate.AddBossNodeIcon("KijinSeijaSagume", func, (Assembly)null);
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "author.game.typeofmod.KijinSeija";

		public const string Name = "KijinSeijaMod";

		public const string version = "0.1.2";

		public static readonly Harmony harmony = new Harmony("author.game.typeofmod.KijinSeija");
	}
	public class KijinSeijaLoadouts
	{
		public static string UltimateSkillA = "KijinSeijaUltA";

		public static string UltimateSkillB = "KijinSeijaUltB";

		public static string ExhibitA = "KijinSeijaExhibitA";

		public static string ExhibitB = "KijinSeijaExhibitB";

		public static List<string> DeckA = new List<string>
		{
			"Shoot", "Shoot", "Boundary", "Boundary", "KijinSeijaAttackR", "KijinSeijaAttackR", "KijinSeijaBlockU", "KijinSeijaBlockU", "KijinSeijaAccurateAttack", "KijinSeijaEscape",
			"Zhukeling"
		};

		public static List<string> DeckB = new List<string>
		{
			"Shoot", "Shoot", "Boundary", "Boundary", "KijinSeijaAttackW", "KijinSeijaAttackW", "KijinSeijaBlockB", "KijinSeijaBlockB", "KijinSeijaGraze", "KijinSeijaEscape",
			"Zhukeling"
		};

		public static PlayerUnitConfig playerUnitConfig;

		static KijinSeijaLoadouts()
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: 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_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 10;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 0;
			((ManaGroup)(ref val)).Blue = 0;
			((ManaGroup)(ref val)).Black = 1;
			((ManaGroup)(ref val)).Red = 1;
			((ManaGroup)(ref val)).Green = 0;
			((ManaGroup)(ref val)).Colorless = 2;
			((ManaGroup)(ref val)).Philosophy = 0;
			ManaGroup val2 = val;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, true, "", 0, 8, num, true, (int?)null, (ManaColor)7, (ManaColor)6, val2, "#ff0000ff", 24, 999, 99, UltimateSkillA, UltimateSkillB, ExhibitA, ExhibitB, (IReadOnlyList<string>)DeckA, (IReadOnlyList<string>)DeckB, 3, 2);
		}
	}
	public sealed class KijinSeijaModDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(KijinSeijaModDef))]
		public sealed class KijinSeijaMod : PlayerUnit
		{
			public class KijinSeijaTextForcer : MonoBehaviour
			{
				public string adventureId = "Debut";

				private bool _loaded = false;

				private List<(string target, string replacement)> _titleReps = new List<(string, string)>();

				private List<(string target, string replacement)> _npcReps = new List<(string, string)>();

				private void Update()
				{
					if (!SeijaRunTracker.IsSeijaRun)
					{
						return;
					}
					if (!CustomEventTextManager.IsLoaded)
					{
						CustomEventTextManager.LoadAllCustomYamls();
					}
					if (!_loaded && CustomEventTextManager.IsLoaded)
					{
						_titleReps.Clear();
						_npcReps.Clear();
						foreach (Dictionary<string, string> value5 in CustomEventTextManager.MasterTextDict.Values)
						{
							if (value5.TryGetValue("TargetTitle_" + adventureId, out var value) && value5.TryGetValue("Title_" + adventureId, out var value2))
							{
								_titleReps.Add((value.Trim(), value2.Trim()));
							}
							if (value5.TryGetValue("TargetNPC_" + adventureId, out var value3))
							{
								string value4 = null;
								if (!value5.TryGetValue("NPC_" + adventureId, out value4))
								{
									value5.TryGetValue("HostName_" + adventureId, out value4);
								}
								if (!string.IsNullOrEmpty(value4))
								{
									_npcReps.Add((value3.Trim(), value4.Trim()));
								}
							}
						}
						_loaded = true;
					}
					if (!_loaded || (_titleReps.Count == 0 && _npcReps.Count == 0))
					{
						return;
					}
					TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>();
					foreach (TextMeshProUGUI val in array)
					{
						if (string.IsNullOrWhiteSpace(((TMP_Text)val).text))
						{
							continue;
						}
						string text = Regex.Replace(((TMP_Text)val).text, "<.*?>", string.Empty).Replace("\ufeff", "").Trim();
						foreach (var titleRep in _titleReps)
						{
							if (text == titleRep.target)
							{
								((TMP_Text)val).text = ((TMP_Text)val).text.Replace(titleRep.target, titleRep.replacement);
							}
						}
						foreach (var npcRep in _npcReps)
						{
							if (text == npcRep.target)
							{
								((TMP_Text)val).text = ((TMP_Text)val).text.Replace(npcRep.target, npcRep.replacement);
							}
						}
					}
				}
			}

			[HarmonyPatch(typeof(GameRunController), "EnterMapNode")]
			public class EnterMapNode_Patch
			{
				[CompilerGenerated]
				private sealed class <LoopShopDialogue>d__1 : IEnumerator<object>, IDisposable, IEnumerator
				{
					private int <>1__state;

					private object <>2__current;

					public UnitView boss;

					public UnitView player;

					public KijinSeijaMod mod;

					public int currentLevel;

					public int nodeX;

					private bool <isFinalAct>5__1;

					private bool <isFirstEncounter>5__2;

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

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

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

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

					private bool MoveNext()
					{
						//IL_0097: Unknown result type (might be due to invalid IL or missing references)
						//IL_00a1: Expected O, but got Unknown
						//IL_015f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0169: Expected O, but got Unknown
						//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
						//IL_01ab: Expected O, but got Unknown
						//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
						//IL_01ed: Expected O, but got Unknown
						//IL_0225: Unknown result type (might be due to invalid IL or missing references)
						//IL_022f: Expected O, but got Unknown
						//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
						//IL_02c7: Expected O, but got Unknown
						//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
						//IL_0309: Expected O, but got Unknown
						//IL_0342: Unknown result type (might be due to invalid IL or missing references)
						//IL_034c: Expected O, but got Unknown
						//IL_0385: Unknown result type (might be due to invalid IL or missing references)
						//IL_038f: Expected O, but got Unknown
						//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
						//IL_03d2: Expected O, but got Unknown
						//IL_040b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0415: Expected O, but got Unknown
						//IL_011d: Unknown result type (might be due to invalid IL or missing references)
						//IL_0127: Expected O, but got Unknown
						//IL_027b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0285: Expected O, but got Unknown
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 1;
							return true;
						case 1:
							<>1__state = -1;
							<isFinalAct>5__1 = currentLevel == 4 && nodeX == 1;
							<isFirstEncounter>5__2 = currentLevel == 1 && nodeX == 1;
							if (<isFinalAct>5__1)
							{
								boss.Chat(mod.shop6, 4f, (CloudType)2, 0f);
								<>2__current = (object)new WaitForSeconds(4.5f);
								<>1__state = 2;
								return true;
							}
							if (<isFirstEncounter>5__2)
							{
								player.Chat(mod.shop1, 3f, (CloudType)2, 0f);
								<>2__current = (object)new WaitForSeconds(3.5f);
								<>1__state = 7;
								return true;
							}
							break;
						case 2:
							<>1__state = -1;
							player.Chat(mod.shop7, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 3;
							return true;
						case 3:
							<>1__state = -1;
							player.Chat(mod.shop8, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 4;
							return true;
						case 4:
							<>1__state = -1;
							boss.Chat(mod.shop9, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 5;
							return true;
						case 5:
							<>1__state = -1;
							boss.Chat(mod.shop10, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 6;
							return true;
						case 6:
							<>1__state = -1;
							break;
						case 7:
							<>1__state = -1;
							boss.Chat(mod.shop2, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 8;
							return true;
						case 8:
							<>1__state = -1;
							player.Chat(mod.shop3, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 9;
							return true;
						case 9:
							<>1__state = -1;
							boss.Chat(mod.shop4, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 10;
							return true;
						case 10:
							<>1__state = -1;
							boss.Chat(mod.shop45, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 11;
							return true;
						case 11:
							<>1__state = -1;
							player.Chat(mod.shop5, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 12;
							return true;
						case 12:
							<>1__state = -1;
							boss.Chat(mod.shop52, 4f, (CloudType)2, 0f);
							<>2__current = (object)new WaitForSeconds(4.5f);
							<>1__state = 13;
							return true;
						case 13:
							<>1__state = -1;
							break;
						}
						return false;
					}

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

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

				[Obsolete]
				private static void Prefix(GameRunController __instance, MapNode node)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0008: Invalid comparison between Unknown and I4
					//IL_0099: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
					if ((int)node.StationType != 5)
					{
						return;
					}
					UnitView val = null;
					UnitView[] array = Object.FindObjectsOfType<UnitView>();
					UnitView[] array2 = array;
					foreach (UnitView val2 in array2)
					{
						if (val2.Unit == __instance.Player)
						{
							val = val2;
							break;
						}
					}
					if ((Object)(object)val != (Object)null && __instance.Player is KijinSeijaMod mod)
					{
						GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject);
						val3.transform.position = ((Component)val).transform.position + new Vector3(6.6f, 0.6f, 0f);
						Renderer[] componentsInChildren = val3.GetComponentsInChildren<Renderer>();
						foreach (Renderer val4 in componentsInChildren)
						{
							val4.enabled = false;
						}
						UnitView component = val3.GetComponent<UnitView>();
						if ((Object)(object)component != (Object)null)
						{
							((MonoBehaviour)component).StartCoroutine(LoopShopDialogue(component, val, mod, __instance.CurrentStage.Level, node.X));
						}
						Object.Destroy((Object)(object)val3, 60f);
					}
				}

				[IteratorStateMachine(typeof(<LoopShopDialogue>d__1))]
				private static IEnumerator LoopShopDialogue(UnitView boss, UnitView player, KijinSeijaMod mod, int currentLevel, int nodeX)
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <LoopShopDialogue>d__1(0)
					{
						boss = boss,
						player = player,
						mod = mod,
						currentLevel = currentLevel,
						nodeX = nodeX
					};
				}
			}

			public bool DialogueTriggered = false;

			private float Multiplier => 0.8f;

			public string shop1 => ((GameEntity)this).LocalizeProperty("shop1", false, true);

			public string shop2 => ((GameEntity)this).LocalizeProperty("shop2", false, true);

			public string shop3 => ((GameEntity)this).LocalizeProperty("shop3", false, true);

			public string shop4 => ((GameEntity)this).LocalizeProperty("shop4", false, true);

			public string shop45 => ((GameEntity)this).LocalizeProperty("shop45", false, true);

			public string shop5 => ((GameEntity)this).LocalizeProperty("shop5", false, true);

			public string shop52 => ((GameEntity)this).LocalizeProperty("shop52", false, true);

			public string shop6 => ((GameEntity)this).LocalizeProperty("shop6", false, true);

			public string shop7 => ((GameEntity)this).LocalizeProperty("shop7", false, true);

			public string shop8 => ((GameEntity)this).LocalizeProperty("shop8", false, true);

			public string shop9 => ((GameEntity)this).LocalizeProperty("shop9", false, true);

			public string shop10 => ((GameEntity)this).LocalizeProperty("shop10", false, true);

			public string FJ1 => ((GameEntity)this).LocalizeProperty("FJ1", false, true);

			public bool Blackout { get; private set; }

			public string LocShortcut(string key, bool decorated, bool required)
			{
				return ((GameEntity)this).LocalizeProperty(key, decorated, required);
			}

			protected override void OnEnterGameRun(GameRunController gameRun)
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_00e1: 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_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Expected O, but got Unknown
				GameRunController gameRun2 = ((GameEntity)this).GameRun;
				gameRun2.ShopPriceMultiplier *= Multiplier;
				((GameEntity)this).GameRun.TrueEndingProviders.Add((GameEntity)(object)this);
				bool flag = gameRun.CurrentMap == null;
				GameObject shinObj = new GameObject("Shinmyoumaru_Debut");
				Object.DontDestroyOnLoad((Object)(object)shinObj);
				if (flag)
				{
					SpriteRenderer val = shinObj.AddComponent<SpriteRenderer>();
					val.sprite = ResourceLoader.LoadSprite("KijinSeijaShinmyoumaru.png", (IResourceSource)(object)BepinexPlugin.directorySource, (Rect?)null, 84, (Vector2?)null);
					((Renderer)val).sortingLayerName = "Default";
					((Renderer)val).sortingOrder = 50;
					shinObj.transform.position = new Vector3(5.4f, 0f, 0f);
					shinObj.transform.localScale = new Vector3(-1f, 1f, 1f);
				}
				else
				{
					Debug.Log((object)"不是全新开局");
				}
				KijinSeijaTextForcer kijinSeijaTextForcer = shinObj.AddComponent<KijinSeijaTextForcer>();
				kijinSeijaTextForcer.adventureId = "Debut";
				((Unit)this).HandleGameRunEvent<StationEventArgs>(((GameEntity)this).GameRun.StationFinished, (GameEventHandler<StationEventArgs>)delegate
				{
					if ((Object)(object)shinObj != (Object)null)
					{
						Object.Destroy((Object)(object)shinObj);
					}
				});
				GameObject val2 = new GameObject("ShinDebutHandler");
				Object.DontDestroyOnLoad((Object)(object)val2);
				ShinmyoumaruDebutHandler shinmyoumaruDebutHandler = val2.AddComponent<ShinmyoumaruDebutHandler>();
				shinmyoumaruDebutHandler.gameRun = gameRun;
				((Unit)this).HandleGameRunEvent<StationEventArgs>(((GameEntity)this).GameRun.StationEntered, (GameEventHandler<StationEventArgs>)delegate(StationEventArgs args)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000d: Invalid comparison between Unknown and I4
					if ((int)args.Station.Type == 4)
					{
						((GameEntity)this).GameRun.LoseMoney(200);
					}
					if (gameRun.CurrentStage.Level == 1)
					{
						GameMap currentMap = gameRun.CurrentMap;
						if (currentMap != null)
						{
							int num = 1;
							for (int i = 0; i < currentMap.Width; i++)
							{
								MapNode val3 = currentMap.Nodes[num, i];
								if (val3 != null)
								{
									val3.StationType = (StationType)5;
								}
							}
						}
					}
				});
			}

			protected override void OnEnterBattle(BattleController battle)
			{
				DialogueTriggered = false;
			}
		}

		public UniTask<Sprite>? LoadSpellPortraitAsync { get; private set; }

		public override IdContainer GetId()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(BepinexPlugin.modUniqueID);
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)KijinSeijaLocalization.PlayerUnitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override PlayerImages LoadPlayerImages()
		{
			return KijinSeijaImageLoader.LoadPlayerImages(BepinexPlugin.playerName);
		}

		public override PlayerUnitConfig MakeConfig()
		{
			return KijinSeijaLoadouts.playerUnitConfig;
		}
	}
}
namespace KijinSeijaMod.KijinSeijaUlt
{
	public sealed class KijinSeijaUltADef : KijinSeijaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 30;
			defaulUltConfig.PowerCost = 100;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaUltADef))]
	public sealed class KijinSeijaUltA : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__6 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			public KijinSeijaUltA <>4__this;

			private EnemyUnit <enemy>5__1;

			private PlayerUnit <player>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0104: 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_0120: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					<player>5__2 = ((UltimateSkill)<>4__this).Battle.Player;
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "逆转攻势");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Animation((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "spell", 1f, (string)null, 0f, -1);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, (Unit)(object)<enemy>5__1, DamageInfo.Reaction((float)<player>5__2.Us.MaxPowerLevel * 30f, false), <>4__this.GetGunName(1), (GunType)0);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<Actions>d__6 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

		private string LastType { get; set; }

		public KijinSeijaUltA()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
		}

		private string GetGunName(int gunIndex)
		{
			string text = LastType + gunIndex;
			if (GunConfig.FromName(text) != null)
			{
				return text;
			}
			return "SingleJiandaoSe" + gunIndex;
		}

		[IteratorStateMachine(typeof(<Actions>d__6))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__6(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
	public sealed class KijinSeijaUltBDef : KijinSeijaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 18;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaUltBDef))]
	public sealed class KijinSeijaUltB : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			public KijinSeijaUltB <>4__this;

			private int <Value18>5__1;

			private IEnumerator<EnemyUnit> <>s__2;

			private Unit <enemy>5__3;

			private int <Value19>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 3) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__2 = null;
				<enemy>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0194: 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_01a9: Expected O, but got Unknown
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<Value18>5__1 = ((Unit)((UltimateSkill)<>4__this).Battle.Player).StatusEffects.Where((StatusEffect se) => (int)se.Type == 1).Count();
						<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "天下翻覆");
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -1;
						<>2__current = (BattleAction)(object)PerformAction.Animation((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "spell", 1f, (string)null, 0f, -1);
						<>1__state = 2;
						result = true;
						break;
					case 2:
						<>1__state = -1;
						<>s__2 = ((UltimateSkill)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						while (true)
						{
							if (<>s__2.MoveNext())
							{
								<enemy>5__3 = (Unit)(object)<>s__2.Current;
								if (<enemy>5__3.IsAlive && !((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
								{
									<Value19>5__4 = 0;
									goto IL_01d0;
								}
								<enemy>5__3 = null;
								continue;
							}
							<>m__Finally1();
							<>s__2 = null;
							result = false;
							break;
						}
						break;
					case 3:
						<>1__state = -3;
						<Value19>5__4++;
						goto IL_01d0;
					case 4:
						{
							<>1__state = -3;
							result = false;
							<>m__Finally1();
							break;
						}
						IL_01d0:
						if (<Value19>5__4 < <Value18>5__1 + 1)
						{
							<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (IEnumerable<Unit>)((UltimateSkill)<>4__this).Battle.AllAliveEnemies, ((UltimateSkill)<>4__this).Damage, "Guiren1", (GunType)0);
							<>1__state = 3;
							result = true;
						}
						else
						{
							<>2__current = (BattleAction)new RemoveAllNegativeStatusEffectAction((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, 0.2f);
							<>1__state = 4;
							result = true;
						}
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__2 != null)
				{
					<>s__2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<Actions>d__5 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

		private string LastType { get; set; }

		public KijinSeijaUltB()
		{
			((UltimateSkill)this).TargetType = (TargetType)2;
		}

		[IteratorStateMachine(typeof(<Actions>d__5))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__5(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
	public class KijinSeijaUltTemplate : UltimateSkillTemplate
	{
		public override IdContainer GetId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(KijinSeijaDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)KijinSeijaLocalization.UltimateSkillsBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return KijinSeijaImageLoader.LoadUltLoader((UltimateSkillTemplate)(object)this);
		}

		public override UltimateSkillConfig MakeConfig()
		{
			throw new NotImplementedException();
		}

		public UltimateSkillConfig GetDefaulUltConfig()
		{
			return KijinSeijaDefaultConfig.DefaultUltConfig();
		}
	}
}
namespace KijinSeijaMod.StatusEffects
{
	public sealed class AccuracyModule1Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(AccuracyModule1Def))]
	public sealed class AccuracyModule1 : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageDealingEventArgs>(((StatusEffect)this).Owner.DamageDealing, (GameEventHandler<DamageDealingEventArgs>)OnDamageDealing);
		}

		private void OnDamageDealing(DamageDealingEventArgs args)
		{
			//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_0012: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			((DamageInfo)(ref damageInfo)).IsAccuracy = true;
			args.DamageInfo = damageInfo;
			((GameEventArgs)args).AddModifier((GameEntity)(object)this);
		}
	}
	public sealed class KijinSeijaEnhanceSeDef : KijinSeijaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(KijinSeijaEnhanceSeDef))]
	public sealed class KijinSeijaEnhanceSe : StatusEffect
	{
	}
	public sealed class KijinSeijaBoomSeDef : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBoomSeDef))]
	public sealed class KijinSeijaBoomSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public KijinSeijaBoomSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//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_0067: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction(((StatusEffect)<>4__this).Owner, (IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.EnemyGroup.Alives, DamageInfo.Reaction(40f, false), "ExhTNT", (GunType)0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnOwnerTurnStarted>d__1 <OnOwnerTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnStarted>d__ = this;
				}
				else
				{
					<OnOwnerTurnStarted>d__ = new <OnOwnerTurnStarted>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnStarted>d__.args = <>3__args;
				return <OnOwnerTurnStarted>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		[IteratorStateMachine(typeof(<OnOwnerTurnStarted>d__1))]
		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarted>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class KijinSeijaBorrowedBlade1Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBorrowedBlade1Def))]
	public sealed class KijinSeijaBorrowedBlade1 : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__7 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public KijinSeijaBorrowedBlade1 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnOwnerTurnStarted>d__7 <OnOwnerTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnStarted>d__ = this;
				}
				else
				{
					<OnOwnerTurnStarted>d__ = new <OnOwnerTurnStarted>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnStarted>d__.args = <>3__args;
				return <OnOwnerTurnStarted>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OnPlayerDamageReceived>d__6 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DamageEventArgs args;

			public DamageEventArgs <>3__args;

			public KijinSeijaBorrowedBlade1 <>4__this;

			private ReflectDamage <reflectDamage>5__1;

			private EnemyUnit <target>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008e: 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_00a3: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_00b4;
				}
				<>1__state = -1;
				goto IL_00c3;
				IL_00b4:
				<reflectDamage>5__1 = null;
				<target>5__2 = null;
				goto IL_00c3;
				IL_00c3:
				if (<>4__this.ReflectDamages.Count > 0)
				{
					<reflectDamage>5__1 = <>4__this.ReflectDamages.Dequeue();
					<target>5__2 = ((StatusEffect)<>4__this).Battle.RandomAliveEnemy;
					if (<reflectDamage>5__1.Target.IsAlive)
					{
						<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)<target>5__2, DamageInfo.Reaction((float)<reflectDamage>5__1.Damage, false), "ESakuyaSE1", (GunType)0);
						<>1__state = 1;
						return true;
					}
					goto IL_00b4;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerDamageReceived>d__6 <OnPlayerDamageReceived>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerDamageReceived>d__ = this;
				}
				else
				{
					<OnPlayerDamageReceived>d__ = new <OnPlayerDamageReceived>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerDamageReceived>d__.args = <>3__args;
				return <OnPlayerDamageReceived>d__;
			}

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

		private Queue<ReflectDamage> ReflectDamages { get; set; } = new Queue<ReflectDamage>();


		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageTaking, (GameEventHandler<DamageEventArgs>)OnPlayerDamageTaking);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnPlayerDamageReceived);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private void OnPlayerDamageTaking(DamageEventArgs args)
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			DamageInfo damageInfo = args.DamageInfo;
			int num = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
			if (num >= 1)
			{
				((StatusEffect)this).NotifyActivating();
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).ReduceActualDamageBy(num);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				Unit source = args.Source;
				if (source is EnemyUnit && source.IsAlive)
				{
					ReflectDamages.Enqueue(new ReflectDamage(args.Source, num));
				}
			}
		}

		[IteratorStateMachine(typeof(<OnPlayerDamageReceived>d__6))]
		private IEnumerable<BattleAction> OnPlayerDamageReceived(DamageEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerDamageReceived>d__6(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[IteratorStateMachine(typeof(<OnOwnerTurnStarted>d__7))]
		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarted>d__7(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class KijinSeijaFastAttackDef : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaFastAttackDef))]
	public sealed class KijinSeijaFastAttack : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnAllEnemyTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public KijinSeijaFastAttack <>4__this;

			private DamageAction <damageaction>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Owner == null || ((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<damageaction>5__1 = new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)((StatusEffect)<>4__this).Battle.FirstAliveEnemy, DamageInfo.Attack((float)((StatusEffect)<>4__this).Level, false), "鸦天狗触发B", (GunType)0);
					<>2__current = (BattleAction)(object)<damageaction>5__1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((StatusEffect)<>4__this).Highlight = false;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnAllEnemyTurnStarted>d__1 <OnAllEnemyTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnAllEnemyTurnStarted>d__ = this;
				}
				else
				{
					<OnAllEnemyTurnStarted>d__ = new <OnAllEnemyTurnStarted>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnAllEnemyTurnStarted>d__.args = <>3__args;
				return <OnAllEnemyTurnStarted>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(((StatusEffect)this).Battle.AllEnemyTurnStarted, (EventSequencedReactor<GameEventArgs>)OnAllEnemyTurnStarted);
			((StatusEffect)this).Highlight = true;
		}

		[IteratorStateMachine(typeof(<OnAllEnemyTurnStarted>d__1))]
		private IEnumerable<BattleAction> OnAllEnemyTurnStarted(GameEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnAllEnemyTurnStarted>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class KijinSeijaFriendS1Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaFriendS1Def))]
	public sealed class KijinSeijaFriendS1 : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((GameEntity)this).GameRun.SetEnemyHpAndMaxHp(((Unit)((StatusEffect)this).Battle.Player).Hp, ((Unit)((StatusEffect)this).Battle.Player).Hp, allAliveEnemy, false);
			}
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (GameEventHandler<UnitEventArgs>)OnOwnerTurnStarted);
		}

		protected void OnOwnerTurnStarted(UnitEventArgs args)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)new ApplyStatusEffectAction<Invincible>((Unit)((StatusEffect)this).Battle.AllAliveEnemies, (int?)16, (int?)16, (int?)0, (int?)0, 0.2f, true)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f)));
		}
	}
	public sealed class KijinSeijaFriendS2Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaFriendS2Def))]
	public sealed class KijinSeijaFriendS2 : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((GameEntity)this).GameRun.SetHpAndMaxHp(((Unit)((StatusEffect)this).Battle.Player).Hp, ((Unit)((StatusEffect)this).Battle.Player).MaxHp * 11 / 10, false);
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (GameEventHandler<UnitEventArgs>)OnOwnerTurnEnded);
		}

		protected void OnOwnerTurnEnded(UnitEventArgs args)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			((GameEntity)this).GameRun.SetHpAndMaxHp(((Unit)((StatusEffect)this).Battle.Player).Hp, ((Unit)((StatusEffect)this).Battle.Player).MaxHp * 9 / 10, false);
			((GameEntity)this).React(Reactor.op_Implicit(((StatusEffect)this).DebuffAction<Poison>((Unit)(object)((StatusEffect)this).Battle.Player, ((Unit)((StatusEffect)this).Battle.Player).Hp, 0, 0, 0, true, 0.2f)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f)));
		}
	}
	public sealed class KijinSeijaFriedS3Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaFriedS3Def))]
	public sealed class KijinSeijaFriedS3 : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnEnemyDied>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DieEventArgs args;

			public DieEventArgs <>3__args;

			public KijinSeijaFriedS3 <>4__this;

			private EnemyUnit <unit2>5__1;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<unit2>5__1 = CollectionsExtensions.MinBy<EnemyUnit, int>((IEnumerable<EnemyUnit>)((StatusEffect)<>4__this).Battle.EnemyGroup, (Func<EnemyUnit, int>)((EnemyUnit unit) => ((Unit)unit).Hp));
				<>4__this.<>n__0();
				((GameEntity)<>4__this).GameRun.GainMaxHp((int)((float)((Unit)<unit2>5__1).MaxHp / 10f), true, true);
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnEnemyDied>d__1 <OnEnemyDied>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnEnemyDied>d__ = this;
				}
				else
				{
					<OnEnemyDied>d__ = new <OnEnemyDied>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnEnemyDied>d__.args = <>3__args;
				return <OnEnemyDied>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OnturnStarted>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public KijinSeijaFriedS3 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<NextTurnLoseGame>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)0, (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnturnStarted>d__2 <OnturnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnturnStarted>d__ = this;
				}
				else
				{
					<OnturnStarted>d__ = new <OnturnStarted>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnturnStarted>d__.args = <>3__args;
				return <OnturnStarted>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<DieEventArgs>(((StatusEffect)this).Battle.EnemyDied, (EventSequencedReactor<DieEventArgs>)OnEnemyDied);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnturnStarted);
		}

		[IteratorStateMachine(typeof(<OnEnemyDied>d__1))]
		private IEnumerable<BattleAction> OnEnemyDied(DieEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnEnemyDied>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[IteratorStateMachine(typeof(<OnturnStarted>d__2))]
		private IEnumerable<BattleAction> OnturnStarted(GameEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnturnStarted>d__2(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaHeal1Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaHeal1Def))]
	public sealed class KijinSeijaHeal1 : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public KijinSeijaHeal1 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnOwnerTurnStarted>d__2 <OnOwnerTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnStarted>d__ = this;
				}
				else
				{
					<OnOwnerTurnStarted>d__ = new <OnOwnerTurnStarted>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnStarted>d__.args = <>3__args;
				return <OnOwnerTurnStarted>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DieEventArgs>(((StatusEffect)this).Owner.Dying, (GameEventHandler<DieEventArgs>)OnDying);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
		}

		private void OnDying(DieEventArgs args)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			((GameEventArgs)args).CancelBy((GameEntity)(object)this);
			((StatusEffect)this).NotifyActivating();
			if (((Unit)((StatusEffect)this).Battle.Player).MaxHp <= 30)
			{
				((GameEntity)this).GameRun.SetHpAndMaxHp(((Unit)((StatusEffect)this).Battle.Player).MaxHp, ((Unit)((StatusEffect)this).Battle.Player).MaxHp, false);
			}
			else
			{
				((GameEntity)this).GameRun.SetHpAndMaxHp(30, ((Unit)((StatusEffect)this).Battle.Player).MaxHp, false);
			}
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f)));
		}

		[IteratorStateMachine(typeof(<OnOwnerTurnStarted>d__2))]
		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarted>d__2(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class KijinSeijaInvertedWorld1Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaInvertedWorld1Def))]
	public sealed class KijinSeijaInvertedWorld1 : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnBlockShieldGained>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private BlockShieldEventArgs args;

			public BlockShieldEventArgs <>3__args;

			public KijinSeijaInvertedWorld1 <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private EnemyUnit <enemyUnit>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemyUnit>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Expected O, but got Unknown
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<>s__1 = ((StatusEffect)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						if (<>s__1.MoveNext())
						{
							<enemyUnit>5__2 = <>s__1.Current;
							if (args.Block > 0f)
							{
								<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)<enemyUnit>5__2, DamageInfo.Reaction(args.Block * 2f, false), "假面", (GunType)0);
								<>1__state = 1;
								result = true;
								break;
							}
							goto IL_00de;
						}
						<>m__Finally1();
						<>s__1 = null;
						result = false;
						break;
					case 1:
						<>1__state = -3;
						goto IL_00de;
					case 2:
						{
							<>1__state = -3;
							goto IL_0148;
						}
						IL_00de:
						if (args.Shield > 0f)
						{
							<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)<enemyUnit>5__2, DamageInfo.Reaction(args.Shield * 2f, false), "假面", (GunType)0);
							<>1__state = 2;
							result = true;
							break;
						}
						goto IL_0148;
						IL_0148:
						result = false;
						<>m__Finally1();
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnBlockShieldGained>d__1 <OnBlockShieldGained>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnBlockShieldGained>d__ = this;
				}
				else
				{
					<OnBlockShieldGained>d__ = new <OnBlockShieldGained>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnBlockShieldGained>d__.args = <>3__args;
				return <OnBlockShieldGained>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((StatusEffect)this).ReactOwnerEvent<BlockShieldEventArgs>(((Unit)allAliveEnemy).BlockShieldGained, (EventSequencedReactor<BlockShieldEventArgs>)OnBlockShieldGained);
			}
		}

		[IteratorStateMachine(typeof(<OnBlockShieldGained>d__1))]
		private IEnumerable<BattleAction> OnBlockShieldGained(BlockShieldEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnBlockShieldGained>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class KijinSeijaMaoYuSeDef : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaMaoYuSeDef))]
	public sealed class KijinSeijaMaoYuSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerStatisticalTotalDamageReceived>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatisticalDamageEventArgs totalArgs;

			public StatisticalDamageEventArgs <>3__totalArgs;

			public KijinSeijaMaoYuSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Expected O, but got Unknown
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)new CastBlockShieldAction(((StatusEffect)<>4__this).Owner, new ShieldInfo(((Unit)((StatusEffect)<>4__this).Battle.Player).MaxHp / 2, (BlockShieldType)2), false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnOwnerStatisticalTotalDamageReceived>d__1 <OnOwnerStatisticalTotalDamageReceived>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerStatisticalTotalDamageReceived>d__ = this;
				}
				else
				{
					<OnOwnerStatisticalTotalDamageReceived>d__ = new <OnOwnerStatisticalTotalDamageReceived>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerStatisticalTotalDamageReceived>d__.totalArgs = <>3__totalArgs;
				return <OnOwnerStatisticalTotalDamageReceived>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((StatusEffect)this).Owner.StatisticalTotalDamageReceived, (EventSequencedReactor<StatisticalDamageEventArgs>)OnOwnerStatisticalTotalDamageReceived);
		}

		[IteratorStateMachine(typeof(<OnOwnerStatisticalTotalDamageReceived>d__1))]
		private IEnumerable<BattleAction> OnOwnerStatisticalTotalDamageReceived(StatisticalDamageEventArgs totalArgs)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerStatisticalTotalDamageReceived>d__1(-2)
			{
				<>4__this = this,
				<>3__totalArgs = totalArgs
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaMoney1Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaMoney1Def))]
	public sealed class KijinSeijaMoney1 : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnBattleEnding>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public KijinSeijaMoney1 <>4__this;

			private int <Value1>5__1;

			private int <Value2>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Expected O, but got Unknown
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<Value1>5__1 = ((Unit)((StatusEffect)<>4__this).Battle.Player).Hp;
					<Value2>5__2 = ((Unit)((StatusEffect)<>4__this).Battle.Player).MaxHp;
					if (<Value1>5__1 < 4)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new GainMoneyAction(999, (SpecialSourceType)0);
						<>1__state = 1;
						return true;
					}
					if (<Value1>5__1 == <Value2>5__2)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new GainMoneyAction(99, (SpecialSourceType)0);
						<>1__state = 2;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnBattleEnding>d__1 <OnBattleEnding>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnBattleEnding>d__ = this;
				}
				else
				{
					<OnBattleEnding>d__ = new <OnBattleEnding>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnBattleEnding>d__.args = <>3__args;
				return <OnBattleEnding>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(((StatusEffect)this).Battle.BattleEnding, (EventSequencedReactor<GameEventArgs>)OnBattleEnding);
		}

		[IteratorStateMachine(typeof(<OnBattleEnding>d__1))]
		private IEnumerable<BattleAction> OnBattleEnding(GameEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnBattleEnding>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaTiaoZhan1Def : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaTiaoZhan1Def))]
	public sealed class KijinSeijaTiaoZhan1 : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnBattleEnded>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public KijinSeijaTiaoZhan1 <>4__this;

			private List<Exhibit> <list>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Expected O, but got Unknown
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<list>5__1 = new List<Exhibit>();
					if (<>4__this.value45 <= 2)
					{
						<>2__current = (BattleAction)new GainMoneyAction(50, (SpecialSourceType)0);
						<>1__state = 1;
						return true;
					}
					if (<>4__this.value45 > 2 && <>4__this.value45 <= 4)
					{
						<>2__current = (BattleAction)new GainMoneyAction(150, (SpecialSourceType)0);
						<>1__state = 2;
						return true;
					}
					if (<>4__this.value45 > 4 && <>4__this.value45 <= 6)
					{
						<>2__current = (BattleAction)new GainMoneyAction(400, (SpecialSourceType)0);
						<>1__state = 3;
						return true;
					}
					if (<>4__this.value45 > 6)
					{
						<>2__current = (BattleAction)new GainMoneyAction(700, (SpecialSourceType)0);
						<>1__state = 4;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					((GameEntity)<>4__this).GameRun.GainMaxHp(10, true, true);
					break;
				case 3:
					<>1__state = -1;
					((GameEntity)<>4__this).GameRun.GainMaxHp(20 + ((Unit)((StatusEffect)<>4__this).Battle.Player).MaxHp / 10, true, true);
					break;
				case 4:
					<>1__state = -1;
					((GameEntity)<>4__this).GameRun.GainMaxHp(30 + ((Unit)((StatusEffect)<>4__this).Battle.Player).MaxHp / 5, true, true);
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnBattleEnded>d__5 <OnBattleEnded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnBattleEnded>d__ = this;
				}
				else
				{
					<OnBattleEnded>d__ = new <OnBattleEnded>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnBattleEnded>d__.args = <>3__args;
				return <OnBattleEnded>d__;
			}

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

		public int value44 = 0;

		public int value45 = 0;

		protected override void OnAdded(Unit unit)
		{
			SetCount();
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (GameEventHandler<UnitEventArgs>)delegate
			{
				SetCount();
			});
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(unit.DamageReceived, (GameEventHandler<DamageEventArgs>)OnDamageReceived);
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(((StatusEffect)this).Battle.BattleEnded, (EventSequencedReactor<GameEventArgs>)OnBattleEnded);
		}

		private void SetCount()
		{
			if (value44 >= 25)
			{
				value45++;
				value44 = 0;
			}
			else
			{
				value44 = 0;
			}
			((StatusEffect)this).Count = value45;
		}

		private void OnDamageReceived(DamageEventArgs args)
		{
			//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)
			int num = value44;
			DamageInfo damageInfo = args.DamageInfo;
			value44 = num + (int)((DamageInfo)(ref damageInfo)).Damage;
		}

		[IteratorStateMachine(typeof(<OnBattleEnded>d__5))]
		private IEnumerable<BattleAction> OnBattleEnded(GameEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnBattleEnded>d__5(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class KijinSeijaTSGDef : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			defaultStatusEffectConfig.Type = (StatusEffectType)1;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaTSGDef))]
	public sealed class KijinSeijaTSG : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DieEventArgs>(((Unit)((StatusEffect)this).Battle.Player).Dying, (GameEventHandler<DieEventArgs>)OnPlayerDying);
		}

		private void OnPlayerDying(DieEventArgs args)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			((GameEventArgs)args).CancelBy((GameEntity)(object)this);
			if (((StatusEffect)this).Owner.Hp <= ((Unit)((StatusEffect)this).Battle.Player).MaxHp)
			{
				((GameEntity)this).GameRun.SetHpAndMaxHp(((StatusEffect)this).Owner.Hp, ((Unit)((StatusEffect)this).Battle.Player).MaxHp, false);
			}
			else
			{
				((GameEntity)this).GameRun.SetHpAndMaxHp(((Unit)((StatusEffect)this).Battle.Player).MaxHp, ((Unit)((StatusEffect)this).Battle.Player).MaxHp, false);
			}
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new ForceKillAction((Unit)(object)((StatusEffect)this).Battle.Player, ((StatusEffect)this).Owner)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f)));
		}
	}
	public sealed class KijinSeijaTurnGainSpiritSeDef : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaTurnGainSpiritSeDef))]
	public sealed class KijinSeijaTurnGainSpiritSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsing>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardUsingEventArgs args;

			public CardUsingEventArgs <>3__args;

			public KijinSeijaTurnGainSpiritSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>4__this.<>n__0();
				args.PlayTwice = true;
				((GameEventArgs)args).AddModifier((GameEntity)(object)<>4__this);
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnCardUsing>d__1 <OnCardUsing>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsing>d__ = this;
				}
				else
				{
					<OnCardUsing>d__ = new <OnCardUsing>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardUsing>d__.args = <>3__args;
				return <OnCardUsing>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OnOwnerTurnEnded>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public KijinSeijaTurnGainSpiritSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnOwnerTurnEnded>d__2 <OnOwnerTurnEnded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnEnded>d__ = this;
				}
				else
				{
					<OnOwnerTurnEnded>d__ = new <OnOwnerTurnEnded>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnEnded>d__.args = <>3__args;
				return <OnOwnerTurnEnded>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
		}

		[IteratorStateMachine(typeof(<OnCardUsing>d__1))]
		private IEnumerable<BattleAction> OnCardUsing(CardUsingEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnCardUsing>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[IteratorStateMachine(typeof(<OnOwnerTurnEnded>d__2))]
		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnEnded>d__2(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaYinyangyuSeDef : KijinSeijaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = KijinSeijaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Spirit" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaYinyangyuSeDef))]
	public sealed class KijinSeijaYinyangyuSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnturnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public KijinSeijaYinyangyuSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>(((StatusEffect)<>4__this).Owner, (int?)1, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Spirit>(((StatusEffect)<>4__this).Owner, (int?)1, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnturnStarted>d__1 <OnturnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnturnStarted>d__ = this;
				}
				else
				{
					<OnturnStarted>d__ = new <OnturnStarted>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnturnStarted>d__.args = <>3__args;
				return <OnturnStarted>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnturnStarted);
		}

		[IteratorStateMachine(typeof(<OnturnStarted>d__1))]
		private IEnumerable<BattleAction> OnturnStarted(GameEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnturnStarted>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public class KijinSeijaStatusEffectTemplate : StatusEffectTemplate
	{
		public override IdContainer GetId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(KijinSeijaDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)KijinSeijaLocalization.StatusEffectsBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return KijinSeijaImageLoader.LoadStatusEffectLoader((StatusEffectTemplate)(object)this);
		}

		public override StatusEffectConfig MakeConfig()
		{
			return GetDefaultStatusEffectConfig();
		}

		public static StatusEffectConfig GetDefaultStatusEffectConfig()
		{
			return KijinSeijaDefaultConfig.DefaultStatusEffectConfig();
		}
	}
}
namespace KijinSeijaMod.model
{
	public sealed class KijinSeijaModel : UnitModelTemplate
	{
		public static bool useInGameModel = BepinexPlugin.useInGameModel;

		public static string model_name = (useInGameModel ? BepinexPlugin.modelName : "KijinSeijaModel.png");

		public static string spellsprite_name = "KijinSeijaStand.png";

		public override IdContainer GetId()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(BepinexPlugin.modUniqueID);
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)KijinSeijaLocalization.UnitModelBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override ModelOption LoadModelOptions()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//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_001b: Expected O, but got Unknown
			if (useInGameModel)
			{
				return new ModelOption(ResourcesHelper.LoadSpineUnitAsync(model_name));
			}
			return new ModelOption(ResourceLoader.LoadSpriteAsync(model_name, BepinexPlugin.directorySource, 565, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://"));
		}

		public override UniTask<Sprite> LoadSpellSprite()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0048: Unknown result type (might be due to invalid IL or missing references)
			if (useInGameModel)
			{
				return ResourcesHelper.LoadSpellPortraitAsync(model_name);
			}
			return ResourceLoader.LoadSpriteAsync(spellsprite_name, BepinexPlugin.directorySource, 100, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://");
		}

		public override UnitModelConfig MakeConfig()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (useInGameModel)
			{
				UnitModelConfig val = ObjectExtensions.Copy<UnitModelConfig>(UnitModelConfig.FromName(model_name));
				val.Flip = BepinexPlugin.modelIsFlipped;
				return val;
			}
			UnitModelConfig val2 = ObjectExtensions.Copy<UnitModelConfig>(((UnitModelTemplate)this).DefaultConfig());
			val2.Flip = BepinexPlugin.modelIsFlipped;
			val2.Type = 0;
			val2.Offset = new Vector2(0f, -0.1f);
			val2.HasSpellPortrait = true;
			return val2;
		}
	}
}
namespace KijinSeijaMod.Models
{
	public sealed class KijinSeijaShinmyoumaruModel : UnitModelTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("KijinSeijaShinmyoumaru");
		}

		public override UnitModelConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			UnitModelConfig val = ObjectExtensions.Copy<UnitModelConfig>(UnitModelConfig.FromName("Reimu"));
			val.Name = "KijinSeijaShinmyoumaru";
			val.Type = 0;
			val.Flip = false;
			val.Offset = new Vector2(0f, 0.04f);
			return val;
		}

		public override ModelOption LoadModelOptions()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			return new ModelOption(UniTask.FromResult<Sprite>(ResourceLoader.LoadSprite("KijinSeijaShinmyoumaru.png", (IResourceSource)(object)BepinexPlugin.directorySource, (Rect?)null, 100, (Vector2?)null)));
		}

		public override UniTask<Sprite> LoadSpellSprite()
		{
			//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 UniTask.FromResult<Sprite>((Sprite)null);
		}

		public override LocalizationOption LoadLocalization()
		{
			return null;
		}
	}
}
namespace KijinSeijaMod.Localization
{
	public sealed class KijinSeijaLocalization
	{
		public static string Cards = "Cards";

		public static string Exhibits = "Exhibits";

		public static string PlayerUnit = "PlayerUnit";

		public static string EnemiesUnit = "EnemyUnit";

		public static string UnitModel = "UnitModel";

		public static string UltimateSkills = "UltimateSkills";

		public static string StatusEffects = "StatusEffects";

		public static BatchLocalization CardsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(CardTemplate), Cards, (Locale)0, false);

		public static BatchLocalization ExhibitsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(ExhibitTemplate), Exhibits, (Locale)0, false);

		public static BatchLocalization PlayerUnitBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(PlayerUnitTemplate), PlayerUnit, (Locale)0, false);

		public static BatchLocalization EnemiesUnitBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(EnemyUnitTemplate), EnemiesUnit, (Locale)0, false);

		public static BatchLocalization UnitModelBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(UnitModelTemplate), UnitModel, (Locale)0, false);

		public static BatchLocalization UltimateSkillsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(UltimateSkillTemplate), UltimateSkills, (Locale)0, false);

		public static BatchLocalization StatusEffectsBatchLoc = new BatchLocalization((IResourceSource)(object)BepinexPlugin.directorySource, typeof(StatusEffectTemplate), StatusEffects, (Locale)0, false);

		public static void Init()
		{
			CardsBatchLoc.DiscoverAndLoadLocFiles(Cards);
			ExhibitsBatchLoc.DiscoverAndLoadLocFiles(Exhibits);
			PlayerUnitBatchLoc.DiscoverAndLoadLocFiles(PlayerUnit);
			EnemiesUnitBatchLoc.DiscoverAndLoadLocFiles(EnemiesUnit);
			UnitModelBatchLoc.DiscoverAndLoadLocFiles(UnitModel);
			UltimateSkillsBatchLoc.DiscoverAndLoadLocFiles(UltimateSkills);
			StatusEffectsBatchLoc.DiscoverAndLoadLocFiles(StatusEffects);
		}
	}
}
namespace KijinSeijaMod.ImageLoader
{
	public sealed class KijinSeijaImageLoader
	{
		public static string file_extension = ".png";

		public static PlayerImages LoadPlayerImages(string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			PlayerImages val = new PlayerImages();
			val.AutoLoad(name, (Func<string, Sprite>)((string s) => ResourceLoader.LoadSprite(s, (IResourceSource)(object)BepinexPlugin.directorySource, 100, 1, (FilterMode)1, true, (Rect?)null, (Vector2?)null)), (Func<string, UniTask<Sprite>>)((string s) => ResourceLoader.LoadSpriteAsync(s, BepinexPlugin.directorySource, 100, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://")), (UseSame)2, ".png", "");
			return val;
		}

		public static CardImages LoadCardImages(CardTemplate cardTemplate)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad(cardTemplate, file_extension, "", !BasicTypeExtensions.IsNullOrEmpty(cardTemplate.MakeConfig().UpgradeImageId));
			return val;
		}

		public static ExhibitSprites LoadExhibitSprite(ExhibitTemplate exhibit)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			ExhibitSprites val = new ExhibitSprites();
			val.main = ResourceLoader.LoadSprite(IdContainer.op_Implicit(((EntityDefinition)exhibit).GetId()) + file_extension, BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
			return val;
		}

		public static Sprite LoadUltLoader(UltimateSkillTemplate ult)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return LoadSprite(((EntityDefinition)ult).GetId());
		}

		public static Sprite LoadStatusEffectLoader(StatusEffectTemplate status)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return LoadSprite(((EntityDefinition)status).GetId());
		}

		public static Sprite LoadSprite(IdContainer ID)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ResourceLoader.LoadSprite(IdContainer.op_Implicit(ID) + file_extension, BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
		}
	}
}
namespace KijinSeijaMod.GunName
{
	public static class GunNameID
	{
		private static IReadOnlyList<GunConfig> gunConfig = GunConfig.AllConfig();

		public static string GetGunFromId(int id)
		{
			string text = "";
			try
			{
				return (from config in gunConfig
					where config.Id == id
					select config.Name).ToList()[0];
			}
			catch
			{
				Debug.Log((object)("id: " + id + " doesn't exist. Check whether the ID is correct."));
				return "Instant";
			}
		}
	}
}
namespace KijinSeijaMod.Exhibits
{
	public sealed class KijinSeijaExhibitADef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Philosophy = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)7;
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaExhibitADef))]
	public sealed class KijinSeijaExhibitA : ShiningExhibit
	{
		public int count;

		private bool Blackout;

		protected override void OnEnterBattle()
		{
			((Exhibit)this).HandleBattleEvent<CardEventArgs>(((Exhibit)this).Battle.CardRemoved, (GameEventHandler<CardEventArgs>)OnCardWasFuckingDelected);
			count = 0;
			Blackout = true;
			if (((Exhibit)this).Owner.Us != null)
			{
				((Exhibit)this).Owner.Us.MaxPowerLevel = 2 + ((Exhibit)this).Counter;
			}
		}

		private void OnCardWasFuckingDelected(CardEventArgs args)
		{
			((GameEntity)this).GameRun.GainMaxHp(2, true, true);
			count++;
			if (count >= 4 && Blackout)
			{
				((Exhibit)this).Counter = ((Exhibit)this).Counter + 1;
				if (((Exhibit)this).Owner.Us != null)
				{
					((Exhibit)this).Owner.Us.MaxPowerLevel = 2 + ((Exhibit)this).Counter;
				}
				Blackout = false;
			}
		}
	}
	public sealed class KijinSeijaExhibitBDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_000b: 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)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Colorless = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)6;
			defaultExhibitConfig.IsPooled = false;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaExhibitBDef))]
	public sealed class KijinSeijaExhibitB : ShiningExhibit
	{
		protected override void OnEnterBattle()
		{
			((Exhibit)this).HandleBattleEvent<CardUsingEventArgs>(((Exhibit)this).Battle.CardUsed, (GameEventHandler<CardUsingEventArgs>)OnCardUsed);
		}

		private void OnCardUsed(CardUsingEventArgs args)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new HealAction((Unit)(object)((Exhibit)this).Battle.Player, (Unit)(object)((Exhibit)this).Battle.Player, 1, (HealType)0, 0.2f)));
		}
	}
	public class KijinSeijaExhibitTemplate : ExhibitTemplate
	{
		public override IdContainer GetId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(KijinSeijaDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)KijinSeijaLocalization.ExhibitsBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override ExhibitSprites LoadSprite()
		{
			return KijinSeijaImageLoader.LoadExhibitSprite((ExhibitTemplate)(object)this);
		}

		public override ExhibitConfig MakeConfig()
		{
			return GetDefaultExhibitConfig();
		}

		public ExhibitConfig GetDefaultExhibitConfig()
		{
			return KijinSeijaDefaultConfig.DefaultExhibitConfig();
		}
	}
}
namespace KijinSeijaMod.Exhibits.Common
{
	public sealed class KijinSeijaDragonBallSeDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Rarity = (Rarity)1;
			defaultExhibitConfig.Owner = null;
			defaultExhibitConfig.BaseManaColor = null;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.LosableType = (ExhibitLosableType)0;
			defaultExhibitConfig.RelativeCards = new List<string> { "KijinSeijaToken" };
			defaultExhibitConfig.IsPooled = true;
			defaultExhibitConfig.Appearance = (AppearanceType)0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaDragonBallSeDef))]
	public sealed class KijinSeijaDragonBallSe : Exhibit
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarteded>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs arg;

			public GameEventArgs <>3__arg;

			public KijinSeijaDragonBallSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((Exhibit)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					((Exhibit)<>4__this).Counter = ((Exhibit)<>4__this).Counter + 1;
					if (((Exhibit)<>4__this).Counter >= 3 && ((Exhibit)<>4__this).Counter % 2 != 0)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new AddCardsToDrawZoneAction((IEnumerable<Card>)Library.CreateCards<KijinSeijaToken>(1, false), (DrawZoneTarget)2, (AddCardsType)0);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerTurnStarteded>d__1 <OnPlayerTurnStarteded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnStarteded>d__ = this;
				}
				else
				{
					<OnPlayerTurnStarteded>d__ = new <OnPlayerTurnStarteded>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerTurnStarteded>d__.arg = <>3__arg;
				return <OnPlayerTurnStarteded>d__;
			}

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

		protected override void OnEnterBattle()
		{
			((Exhibit)this).Counter = 0;
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarteded);
			((Exhibit)this).HandleBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnEnded, (GameEventHandler<UnitEventArgs>)delegate
			{
				if (((Exhibit)this).Counter % 2 != 0 || ((Exhibit)this).Counter < 2)
				{
					((Exhibit)this).Blackout = true;
				}
				else
				{
					((Exhibit)this).Blackout = false;
				}
			});
		}

		[IteratorStateMachine(typeof(<OnPlayerTurnStarteded>d__1))]
		private IEnumerable<BattleAction> OnPlayerTurnStarteded(GameEventArgs arg)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerTurnStarteded>d__1(-2)
			{
				<>4__this = this,
				<>3__arg = arg
			};
		}

		protected override void OnLeaveBattle()
		{
			((Exhibit)this).Active = false;
			((Exhibit)this).Blackout = false;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaHolyGrailSeDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Rarity = (Rarity)1;
			defaultExhibitConfig.Owner = null;
			defaultExhibitConfig.BaseManaColor = null;
			defaultExhibitConfig.LosableType = (ExhibitLosableType)0;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.IsPooled = true;
			defaultExhibitConfig.Appearance = (AppearanceType)0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaHolyGrailSeDef))]
	public sealed class KijinSeijaHolyGrailSe : Exhibit
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public KijinSeijaHolyGrailSe <>4__this;

			private int <counter>5__1;

			private IEnumerator<EnemyUnit> <>s__2;

			private Unit <enemy>5__3;

			private List<StatusEffect>.Enumerator <>s__4;

			private StatusEffect <item>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || num == 1)
				{
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__2 = null;
				<enemy>5__3 = null;
				<>s__4 = default(List<StatusEffect>.Enumerator);
				<item>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Expected O, but got Unknown
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						<item>5__5 = null;
						goto IL_017b;
					}
					<>1__state = -1;
					if (((Exhibit)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					if (((Exhibit)<>4__this).Counter < 6)
					{
						<counter>5__1 = ((Exhibit)<>4__this).Counter + 1;
						((Exhibit)<>4__this).Counter = <counter>5__1;
						if (((Exhibit)<>4__this).Counter == 5)
						{
							((Exhibit)<>4__this).Active = true;
						}
						goto IL_01cf;
					}
					<>4__this.<>n__0();
					<>s__2 = ((Exhibit)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
					<>1__state = -3;
					goto IL_01a3;
					IL_01cf:
					return false;
					IL_017b:
					if (<>s__4.MoveNext())
					{
						<item>5__5 = <>s__4.Current;
						<>2__current = (BattleAction)new RemoveStatusEffectAction(<item>5__5, true, 0.1f);
						<>1__state = 1;
						return true;
					}
					<>m__Finally2();
					<>s__4 = default(List<StatusEffect>.Enumerator);
					<enemy>5__3 = null;
					goto IL_01a3;
					IL_01a3:
					if (<>s__2.MoveNext())
					{
						<enemy>5__3 = (Unit)(object)<>s__2.Current;
						<>s__4 = <enemy>5__3.StatusEffects.Where((StatusEffect se) => (int)se.Type == 0).ToList().GetEnumerator();
						<>1__state = -4;
						goto IL_017b;
					}
					<>m__Finally1();
					<>s__2 = null;
					((Exhibit)<>4__this).Active = false;
					goto IL_01cf;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__2 != null)
				{
					<>s__2.Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				((IDisposable)<>s__4).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerTurnStarted>d__1 <OnPlayerTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnStarted>d__ = this;
				}
				else
				{
					<OnPlayerTurnStarted>d__ = new <OnPlayerTurnStarted>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerTurnStarted>d__.args = <>3__args;
				return <OnPlayerTurnStarted>d__;
			}

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

		protected override void OnEnterBattle()
		{
			((Exhibit)this).Counter = 0;
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarted);
			((Exhibit)this).HandleBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnEnded, (GameEventHandler<UnitEventArgs>)delegate
			{
				if (((Exhibit)this).Counter == 0)
				{
					((Exhibit)this).Blackout = true;
				}
			});
		}

		[IteratorStateMachine(typeof(<OnPlayerTurnStarted>d__1))]
		private IEnumerable<BattleAction> OnPlayerTurnStarted(GameEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerTurnStarted>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		protected override void OnLeaveBattle()
		{
			((Exhibit)this).Active = false;
			((Exhibit)this).Blackout = false;
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaMadokaBowSeDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Rarity = (Rarity)1;
			defaultExhibitConfig.Owner = null;
			defaultExhibitConfig.BaseManaColor = null;
			defaultExhibitConfig.LosableType = (ExhibitLosableType)0;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Colorless = 3;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.IsPooled = true;
			defaultExhibitConfig.Appearance = (AppearanceType)0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaMadokaBowSeDef))]
	public sealed class KijinSeijaMadokaBowSe : Exhibit
	{
		protected override void OnAdded(PlayerUnit player)
		{
			GameRunController gameRun = ((GameEntity)this).GameRun;
			int removeBadCardForbidden = gameRun.RemoveBadCardForbidden + 1;
			gameRun.RemoveBadCardForbidden = removeBadCardForbidden;
		}

		protected override void OnRemoved(PlayerUnit player)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Invalid comparison between Unknown and I4
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Invalid comparison between Unknown and I8
			GameRunController gameRun = ((GameEntity)this).GameRun;
			int removeBadCardForbidden = gameRun.RemoveBadCardForbidden - 1;
			gameRun.RemoveBadCardForbidden = removeBadCardForbidden;
			if (((Exhibit)this).Battle == null || ((GameEntity)this).GameRun.RemoveBadCardForbidden > 0)
			{
				return;
			}
			foreach (Card item in ((Exhibit)this).Battle.EnumerateAllCards())
			{
				CardType cardType = item.CardType;
				if ((int)cardType == 8 && (long)(item.Config.Keywords & 0x8000) > 0L)
				{
					item.IsForbidden = true;
				}
			}
		}

		protected override void OnEnterBattle()
		{
			((Exhibit)this).HandleBattleEvent<CardUsingEventArgs>(((Exhibit)this).Battle.CardUsing, (GameEventHandler<CardUsingEventArgs>)OnCardUsing);
		}

		private void OnCardUsing(CardUsingEventArgs args)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if ((int)args.Card.CardType == 8)
			{
				((Exhibit)this).NotifyActivating();
				((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new GainManaAction(((Exhibit)this).Mana)));
			}
		}
	}
	public sealed class KijinSeijaQiannianShenqiSeDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Rarity = (Rarity)1;
			defaultExhibitConfig.Owner = null;
			defaultExhibitConfig.BaseManaColor = null;
			defaultExhibitConfig.LosableType = (ExhibitLosableType)0;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.IsPooled = true;
			defaultExhibitConfig.Appearance = (AppearanceType)0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaQiannianShenqiSeDef))]
	public sealed class KijinSeijaQiannianShenqiSe : Exhibit
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarteded>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs arg;

			public GameEventArgs <>3__arg;

			public KijinSeijaQiannianShenqiSe <>4__this;

			private int <attackCount>5__1;

			private EnemyUnit[] <enemies>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<attackCount>5__1 = 0;
					<enemies>5__2 = UnitSelector.AllEnemies.GetEnemies(((Exhibit)<>4__this).Battle);
					<attackCount>5__1 = <enemies>5__2.Count((EnemyUnit enemy) => enemy.Intentions.Any((Intention i) => true));
					if (<attackCount>5__1 > 1)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>((Unit)(object)((Exhibit)<>4__this).Battle.Player, (int?)(<attackCount>5__1 - 1), (int?)null, (int?)null, (int?)null, 0f, true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Spirit>((Unit)(object)((Exhibit)<>4__this).Battle.Player, (int?)(<attackCount>5__1 - 1), (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerTurnStarteded>d__1 <OnPlayerTurnStarteded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnStarteded>d__ = this;
				}
				else
				{
					<OnPlayerTurnStarteded>d__ = new <OnPlayerTurnStarteded>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerTurnStarteded>d__.arg = <>3__arg;
				return <OnPlayerTurnStarteded>d__;
			}

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

		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarteded);
		}

		[IteratorStateMachine(typeof(<OnPlayerTurnStarteded>d__1))]
		private IEnumerable<BattleAction> OnPlayerTurnStarteded(GameEventArgs arg)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerTurnStarteded>d__1(-2)
			{
				<>4__this = this,
				<>3__arg = arg
			};
		}
	}
	public sealed class KijinSeijaSakuraWandSeDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Rarity = (Rarity)2;
			defaultExhibitConfig.Owner = null;
			defaultExhibitConfig.BaseManaColor = null;
			defaultExhibitConfig.LosableType = (ExhibitLosableType)0;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.IsPooled = true;
			defaultExhibitConfig.Appearance = (AppearanceType)0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaSakuraWandSeDef))]
	public sealed class KijinSeijaSakuraWandSe : Exhibit
	{
		protected override void OnEnterBattle()
		{
			((Exhibit)this).HandleBattleEvent<CardUsingEventArgs>(((Exhibit)this).Battle.CardUsing, (GameEventHandler<CardUsingEventArgs>)OnCardUsing);
		}

		private void OnCardUsing(CardUsingEventArgs args)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)args.Card.CardType == 1)
			{
				args.PlayTwice = true;
			}
		}
	}
	public sealed class KijinSeijaShenDengSeDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Rarity = (Rarity)2;
			defaultExhibitConfig.Owner = null;
			defaultExhibitConfig.BaseManaColor = null;
			defaultExhibitConfig.LosableType = (ExhibitLosableType)0;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.IsPooled = true;
			defaultExhibitConfig.Appearance = (AppearanceType)0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaShenDengSeDef))]
	public sealed class KijinSeijaShenDengSe : Exhibit
	{
		[CompilerGenerated]
		private sealed class <OnTurnEnding>d__9 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public KijinSeijaShenDengSe <>4__this;

			private Type <type>5__1;

			private EnemyUnit <target>5__2;

			private int? <duration>5__3;

			private int <counter>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this.Counter % 3 == 0)
					{
						CollectionsExtensions.Shuffle<Type>((IList<Type>)<>4__this.Types, ((GameEntity)<>4__this).GameRun.EnemyBattleRng);
					}
					<>4__this.<>n__0();
					<type>5__1 = <>4__this.Types[<>4__this.Counter % 3];
					<target>5__2 = ((Exhibit)<>4__this).Battle.RandomAliveEnemy;
					<duration>5__3 = 3;
					<>2__current = (BattleAction)new ApplyStatusEffectAction(<type>5__1, (Unit)(object)<target>5__2, (int?)null, <duration>5__3, (int?)null, (int?)null, 0f, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<counter>5__4 = <>4__this.Counter + 1;
					<>4__this.Counter = <counter>5__4;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnTurnEnding>d__9 <OnTurnEnding>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnTurnEnding>d__ = this;
				}
				else
				{
					<OnTurnEnding>d__ = new <OnTurnEnding>d__9(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnTurnEnding>d__.args = <>3__args;
				return <OnTurnEnding>d__;
			}

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

		private List<Type> Types { get; set; }

		private int Counter { get; set; }

		protected override void OnEnterBattle()
		{
			Counter = 0;
			Types = new List<Type>
			{
				typeof(Weak),
				typeof(Fragil),
				typeof(Vulnerable)
			};
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnEnding, (EventSequencedReactor<UnitEventArgs>)OnTurnEnding);
		}

		[IteratorStateMachine(typeof(<OnTurnEnding>d__9))]
		private IEnumerable<BattleAction> OnTurnEnding(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnTurnEnding>d__9(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaSihunYuSeDef : KijinSeijaExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Rarity = (Rarity)1;
			defaultExhibitConfig.Owner = null;
			defaultExhibitConfig.BaseManaColor = null;
			defaultExhibitConfig.LosableType = (ExhibitLosableType)0;
			defaultExhibitConfig.HasCounter = true;
			defaultExhibitConfig.InitialCounter = 0;
			defaultExhibitConfig.IsPooled = true;
			defaultExhibitConfig.Appearance = (AppearanceType)0;
			defaultExhibitConfig.RelativeEffects = new List<string>();
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaSihunYuSeDef))]
	public sealed class KijinSeijaSihunYuSe : Exhibit
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarteded>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs arg;

			public UnitEventArgs <>3__arg;

			public KijinSeijaSihunYuSe <>4__this;

			private List<Card> <list>5__1;

			private List<Card>.Enumerator <>s__2;

			private Card <card>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<list>5__1 = null;
				<>s__2 = default(List<Card>.Enumerator);
				<card>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Expected O, but got Unknown
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((Exhibit)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<list>5__1 = ((Exhibit)<>4__this).Battle.RollCards(new CardWeightTable(RarityWeightTable.BattleCard, OwnerWeightTable.AllOnes, CardTypeWeightTable.OnlyFriend, false), 1, (Predicate<CardConfig>)delegate(CardConfig config)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						ManaGroup cost = config.Cost;
						return ((ManaGroup)(ref cost)).Amount < 5;
					}).ToList();
					if (<list>5__1.Count <= 0)
					{
						break;
					}
					<>4__this.<>n__0();
					<>s__2 = <list>5__1.GetEnumerator();
					try
					{
						while (<>s__2.MoveNext())
						{
							<card>5__3 = <>s__2.Current;
							<card>5__3.Summon();
							<card>5__3 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__2).Dispose();
					}
					<>s__2 = default(List<Card>.Enumerator);
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)<list>5__1, (AddCardsType)0, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerTurnStarteded>d__1 <OnPlayerTurnStarteded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnStarteded>d__ = this;
				}
				else
				{
					<OnPlayerTurnStarteded>d__ = new <OnPlayerTurnStarteded>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerTurnStarteded>d__.arg = <>3__arg;
				return <OnPlayerTurnStarteded>d__;
			}

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

		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarteded);
		}

		[IteratorStateMachine(typeof(<OnPlayerTurnStarteded>d__1))]
		private IEnumerable<BattleAction> OnPlayerTurnStarteded(UnitEventArgs arg)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerTurnStarteded>d__1(-2)
			{
				<>4__this = this,
				<>3__arg = arg
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
}
namespace KijinSeijaMod.Enemies
{
	public sealed class KijinSeijaEnemyGroupDef : KijinSeijaEnemyGroupTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("KijinSeijaSagume");
		}

		public override EnemyGroupConfig MakeConfig()
		{
			EnemyGroupConfig defaultEnemyGroupConfig = GetDefaultEnemyGroupConfig();
			defaultEnemyGroupConfig.Name = "KijinSeijaSagume";
			defaultEnemyGroupConfig.FormationName = "Single";
			defaultEnemyGroupConfig.Enemies = new List<string> { "KijinSeijaSagume" };
			defaultEnemyGroupConfig.EnemyType = (EnemyType)3;
			defaultEnemyGroupConfig.RollBossExhibit = false;
			return defaultEnemyGroupConfig;
		}
	}
	public sealed class KijinSeijaEnemyUnitDef : KijinSeijaEnemyUnitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("KijinSeijaSagume");
		}

		public override EnemyUnitConfig MakeConfig()
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			EnemyUnitConfig defaultEnemyUnitConfig = GetDefaultEnemyUnitConfig();
			defaultEnemyUnitConfig.IsPreludeOpponent = false;
			defaultEnemyUnitConfig.ModleName = "KijinSeijaSagume";
			defaultEnemyUnitConfig.BaseManaColor = new List<ManaColor>
			{
				(ManaColor)4,
				(ManaColor)3
			};
			defaultEnemyUnitConfig.Type = (EnemyType)3;
			defaultEnemyUnitConfig.MaxHp = 1688;
			defaultEnemyUnitConfig.MaxHpHard = 1789;
			defaultEnemyUnitConfig.MaxHpLunatic = 1917;
			defaultEnemyUnitConfig.Damage1 = 8;
			defaultEnemyUnitConfig.Damage1Hard = 11;
			defaultEnemyUnitConfig.Damage1Lunatic = 14;
			defaultEnemyUnitConfig.Damage2 = 45;
			defaultEnemyUnitConfig.Damage2Hard = 70;
			defaultEnemyUnitConfig.Damage2Lunatic = 100;
			defaultEnemyUnitConfig.Defend = 100;
			defaultEnemyUnitConfig.DefendHard = 200;
			defaultEnemyUnitConfig.DefendLunatic = 350;
			defaultEnemyUnitConfig.Count1 = 10;
			defaultEnemyUnitConfig.Count1Hard = 12;
			defaultEnemyUnitConfig.Count1Lunatic = 15;
			defaultEnemyUnitConfig.Count2 = 1;
			defaultEnemyUnitConfig.Count2Hard = 2;
			defaultEnemyUnitConfig.Count2Lunatic = 3;
			defaultEnemyUnitConfig.PowerLoot = new MinMax(500, 500);
			defaultEnemyUnitConfig.BluePointLoot = new MinMax(1000, 1000);
			defaultEnemyUnitConfig.Gun1 = new List<string> { "Simple1" };
			defaultEnemyUnitConfig.Gun2 = new List<string> { "Simple1" };
			defaultEnemyUnitConfig.Gun3 = new List<string> { "Simple1" };
			defaultEnemyUnitConfig.Gun4 = new List<string> { "Simple1" };
			return defaultEnemyUnitConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaEnemyUnitDef))]
	public sealed class KijinSeijaSagume : EnemyUnit
	{
		private enum MoveType
		{
			move1,
			move2,
			move3,
			move4
		}

		[CompilerGenerated]
		private sealed class <BasicDefendAction>d__57 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaSagume <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new CastBlockShieldAction((Unit)(object)<>4__this, ((EnemyUnit)<>4__this).Defend, 0, (BlockShieldType)1, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<BasicDefendAction>d__57 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <BasicDefendAction>d__57(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <BuffAndClear>d__54 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaSagume <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Animation((Unit)(object)<>4__this, "spell", 1f, (string)null, 0f, -1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Invincible>((Unit)(object)<>4__this, (int?)null, (int?)((EnemyUnit)<>4__this).Count2, (int?)null, (int?)null, 0f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<YuyukoDeath>((Unit)(object)((Unit)<>4__this).Battle.Player, (int?)((EnemyUnit)<>4__this).Count2, (int?)null, (int?)null, (int?)null, 0.2f, true);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Vulnerable>((Unit)(object)((Unit)<>4__this).Battle.Player, (int?)null, (int?)((EnemyUnit)<>4__this).Count2, (int?)null, (int?)null, 0f, false);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>((Unit)(object)((Unit)<>4__this).Battle.Player, (int?)((EnemyUnit)<>4__this).Count1, (int?)null, (int?)null, (int?)null, 0f, false);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<BuffAndClear>d__54 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <BuffAndClear>d__54(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <GetTurnMoves>d__56 : IEnumerable<IEnemyMove>, IEnumerable, IEnumerator<IEnemyMove>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private IEnemyMove <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaSagume <>4__this;

			private MoveType <>s__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Expected O, but got Unknown
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Expected O, but got Unknown
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0201: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					MoveType next = <>4__this.Next;
					<>s__1 = next;
					switch (<>s__1)
					{
					case MoveType.move1:
						<>2__current = ((EnemyUnit)<>4__this).AttackMove(<>4__this.move1, "ERinShoot1", ((EnemyUnit)<>4__this).Damage1, ((EnemyUnit)<>4__this).Count1, false, "Instant", true);
						<>1__state = 1;
						return true;
					case MoveType.move2:
						<>2__current = ((EnemyUnit)<>4__this).AttackMove(<>4__this.move2, "CSweet020", ((EnemyUnit)<>4__this).Damage2, 2, true, "Instant", true);
						<>1__state = 2;
						return true;
					case MoveType.move3:
						<>2__current = (IEnemyMove)new SimpleEnemyMove(Intention.SpellCard(<>4__this.move3, (int?)null, (int?)null, false), <>4__this.BuffAndClear());
						<>1__state = 4;
						return true;
					case MoveType.move4:
						<>2__current = (IEnemyMove)new SimpleEnemyMove(Intention.SpellCard(<>4__this.move4, (int?)null, (int?)null, false), <>4__this.SetMaxHp());
						<>1__state = 6;
						return true;
					default:
						throw new ArgumentOutOfRangeException();
					}
				}
				case 1:
					<>1__state = -1;
					return false;
				case 2:
					<>1__state = -1;
					<>2__current = (IEnemyMove)new SimpleEnemyMove(Intention.Defend(), <>4__this.BasicDefendAction());
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				case 4:
					<>1__state = -1;
					<>2__current = ((EnemyUnit)<>4__this).ClearMove(0f);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					break;
				case 6:
					<>1__state = -1;
					<>2__current = ((EnemyUnit)<>4__this).ClearMove(0f);
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<IEnemyMove> IEnumerable<IEnemyMove>.GetEnumerator()
			{
				<GetTurnMoves>d__56 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetTurnMoves>d__56(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <OnBattleStarted>d__51 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs arg;

			public GameEventArgs <>3__arg;

			public KijinSeijaSagume <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_039d: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a3: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)((Unit)<>4__this).Battle.Player, <>4__this.Sagume1, 3f, 0f, 3.2f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, <>4__this.Sagume2, 7f, 0f, 7.2f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)((Unit)<>4__this).Battle.Player, <>4__this.Sagume3, 5f, 0f, 5.2f, true);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, <>4__this.Sagume4, 5f, 0f, 5.2f, true);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, <>4__this.Sagume5, 5f, 0f, 5.2f, true);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, <>4__this.Sagume55, 5f, 0f, 5.2f, true);
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)((Unit)<>4__this).Battle.Player, <>4__this.Sagume6, 5f, 0f, 5.2f, true);
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, <>4__this.Sagume7, 5f, 0f, 5.2f, true);
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, <>4__this.Sagume8, 5f, 0f, 5.2f, true);
					<>1__state = 9;
					return true;
				case 9:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<ScarletDestiny>((Unit)(object)<>4__this, (int?)null, (int?)null, (int?)null, (int?)(21 - 3 * ((EnemyUnit)<>4__this).Count2), 0f, true);
					<>1__state = 10;
					return true;
				case 10:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<FlatPeach>((Unit)(object)<>4__this, (int?)(1 + 2 * ((EnemyUnit)<>4__this).Count2), (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 11;
					return true;
				case 11:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Curiosity>((Unit)(object)<>4__this, (int?)(((int)((EnemyUnit)<>4__this).Difficulty != 3) ? 1 : 2), (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 12;
					return true;
				case 12:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<JunkoPurify>((Unit)(object)<>4__this, (int?)((EnemyUnit)<>4__this).Count2, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 13;
					return true;
				case 13:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LongLight>((Unit)(object)<>4__this, (int?)((EnemyUnit)<>4__this).Count2, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 14;
					return true;
				case 14:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<WindGirl>((Unit)(object)<>4__this, (int?)((EnemyUnit)<>4__this).Count2, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 15;
					return true;
				case 15:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnBattleStarted>d__51 <OnBattleStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnBattleStarted>d__ = this;
				}
				else
				{
					<OnBattleStarted>d__ = new <OnBattleStarted>d__51(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnBattleStarted>d__.arg = <>3__arg;
				return <OnBattleStarted>d__;
			}

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

		[CompilerGenerated]
		private sealed class <SetMaxHp>d__55 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaSagume <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Animation((Unit)(object)<>4__this, "skill1", 0.8f, (string)null, 0f, -1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((Unit)<>4__this).MaxHp >= 1453)
					{
						<>2__current = (BattleAction)new HealAction((Unit)(object)<>4__this, (Unit)(object)<>4__this, ((Unit)<>4__this).MaxHp - ((Unit)<>4__this).Hp * 2, (HealType)0, 0.2f);
						<>1__state = 2;
						return true;
					}
					((GameEntity)<>4__this).GameRun.SetEnemyHpAndMaxHp(1969, 1970, (EnemyUnit)(object)<>4__this, false);
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<SetMaxHp>d__55 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <SetMaxHp>d__55(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		private bool _nextDevil;

		private MoveType Last { get; set; }

		public RandomGen SeijaRng { get; set; }

		private MoveType Next { get; set; }

		public string move1 => ((EnemyUnit)this).GetSpellCardName((int?)0, 1);

		public string move2 => ((EnemyUnit)this).GetSpellCardName((int?)2, 3);

		public string move3 => ((EnemyUnit)this).GetSpellCardName((int?)4, 5);

		public string move4 => ((EnemyUnit)this).GetSpellCardName((int?)6, 7);

		public string Sagume1 => ((GameEntity)this).LocalizeProperty("Sagume1", false, true);

		public string Sagume2 => ((GameEntity)this).LocalizeProperty("Sagume2", false, true);

		public string Sagume3 => ((GameEntity)this).LocalizeProperty("Sagume3", false, true);

		public string Sagume4 => ((GameEntity)this).LocalizeProperty("Sagume4", false, true);

		public string Sagume5 => ((GameEntity)this).LocalizeProperty("Sagume5", false, true);

		public string Sagume55 => ((GameEntity)this).LocalizeProperty("Sagume55", false, true);

		public string Sagume6 => ((GameEntity)this).LocalizeProperty("Sagume6", false, true);

		public string Sagume7 => ((GameEntity)this).LocalizeProperty("Sagume7", false, true);

		public string Sagume8 => ((GameEntity)this).LocalizeProperty("Sagume8", false, true);

		public string Sagume9 => ((GameEntity)this).LocalizeProperty("Sagume9", false, true);

		public string Sagume10 => ((GameEntity)this).LocalizeProperty("Sagume10", false, true);

		public string Sagume11 => ((GameEntity)this).LocalizeProperty("Sagume11", false, true);

		public string Sagume12 => ((GameEntity)this).LocalizeProperty("Sagume12", false, true);

		public string Sagume13 => ((GameEntity)this).LocalizeProperty("Sagume13", false, true);

		protected override void OnEnterBattle(BattleController battle)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Last = MoveType.move2;
			Next = MoveType.move1;
			SeijaRng = new RandomGen(((GameEntity)this).GameRun.FinalBossSeed);
			((Unit)this).ReactBattleEvent<GameEventArgs>(((Unit)this).Battle.BattleStarted, (Func<GameEventArgs, IEnumerable<BattleAction>>)OnBattleStarted);
			((Unit)this).HandleBattleEvent<DamageEventArgs>(((Unit)this).DamageReceived, (GameEventHandler<DamageEventArgs>)OnDamageReceived);
			((Unit)this).HandleBattleEvent<DieEventArgs>(((Unit)this).Dying, (GameEventHandler<DieEventArgs>)OnDying);
		}

		[IteratorStateMachine(typeof(<OnBattleStarted>d__51))]
		private IEnumerable<BattleAction> OnBattleStarted(GameEventArgs arg)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnBattleStarted>d__51(-2)
			{
				<>4__this = this,
				<>3__arg = arg
			};
		}

		private void OnDying(DieEventArgs args)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			((GameEventArgs)args).CancelBy((GameEntity)(object)this);
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new RemoveAllNegativeStatusEffectAction((Unit)(object)this, 0.2f)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)new ApplyStatusEffectAction<Invincible>((Unit)(object)this, (int?)999, (int?)0, (int?)0, (int?)0, 0f, true)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)PerformAction.Chat((Unit)(object)((Unit)this).Battle.Player, Sagume9, 5f, 0f, 5.2f, true)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)PerformAction.Chat((Unit)(object)this, Sagume10, 5f, 0f, 5.2f, true)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)PerformAction.Chat((Unit)(object)((Unit)this).Battle.Player, Sagume11, 5f, 0f, 5.2f, true)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)PerformAction.Chat((Unit)(object)this, Sagume12, 5f, 0f, 5.2f, true)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)PerformAction.Chat((Unit)(object)this, Sagume13, 5f, 0f, 5.2f, true)));
			((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new EscapeAction((Unit)(object)this)));
		}

		private void OnDamageReceived(DamageEventArgs args)
		{
			if (((Unit)this).Hp <= 300)
			{
				if (((Unit)this).IsInTurn)
				{
					_nextDevil = true;
					return;
				}
				Next = MoveType.move4;
				((EnemyUnit)this).UpdateTurnMoves();
			}
		}

		[IteratorStateMachine(typeof(<BuffAndClear>d__54))]
		private IEnumerable<BattleAction> BuffAndClear()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BuffAndClear>d__54(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SetMaxHp>d__55))]
		private IEnumerable<BattleAction> SetMaxHp()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetMaxHp>d__55(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<GetTurnMoves>d__56))]
		protected override IEnumerable<IEnemyMove> GetTurnMoves()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetTurnMoves>d__56(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<BasicDefendAction>d__57))]
		private IEnumerable<BattleAction> BasicDefendAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BasicDefendAction>d__57(-2)
			{
				<>4__this = this
			};
		}

		protected override void UpdateMoveCounters()
		{
			if (_nextDevil)
			{
				Next = MoveType.move4;
				_nextDevil = false;
				return;
			}
			MoveType next = Next;
			if (1 == 0)
			{
			}
			MoveType next2 = next switch
			{
				MoveType.move1 => MoveType.move2, 
				MoveType.move2 => MoveType.move3, 
				MoveType.move3 => MoveType.move1, 
				MoveType.move4 => MoveType.move1, 
				_ => MoveType.move1, 
			};
			if (1 == 0)
			{
			}
			Next = next2;
		}
	}
	public sealed class KijinSeijaSagumeModel : UnitModelTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("KijinSeijaSagume");
		}

		public override LocalizationOption LoadLocalization()
		{
			return null;
		}

		public override ModelOption LoadModelOptions()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			return new ModelOption(UniTask.FromResult<Sprite>(ResourceLoader.LoadSprite("KijinSeijaSagume.png", (IResourceSource)(object)BepinexPlugin.directorySource, (Rect?)null, 200, (Vector2?)null)));
		}

		public override UnitModelConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			UnitModelConfig val = ObjectExtensions.Copy<UnitModelConfig>(UnitModelConfig.FromName("Sakuya"));
			val.Name = "KijinSeijaSagume";
			val.Flip = true;
			val.Type = 0;
			val.Offset = new Vector2(0f, 0.04f);
			val.SpellColor = (IReadOnlyList<Color32>)(object)new Color32[4]
			{
				new Color32((byte)104, (byte)15, (byte)5, byte.MaxValue),
				new Color32(byte.MaxValue, (byte)46, (byte)72, byte.MaxValue),
				new Color32((byte)74, (byte)0, (byte)1, (byte)150),
				new Color32(byte.MaxValue, (byte)46, (byte)72, byte.MaxValue)
			};
			return val;
		}

		public override UniTask<Sprite> LoadSpellSprite()
		{
			//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 UniTask.FromResult<Sprite>((Sprite)null);
		}
	}
}
namespace KijinSeijaMod.Enemies.Template
{
	public abstract class KijinSeijaEnemyGroupTemplate : EnemyGroupTemplate
	{
		public override IdContainer GetId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(KijinSeijaDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override EnemyGroupConfig MakeConfig()
		{
			return KijinSeijaDefaultConfig.DefaultEnemyGroupConfig();
		}

		public EnemyGroupConfig GetDefaultEnemyGroupConfig()
		{
			return KijinSeijaDefaultConfig.DefaultEnemyGroupConfig();
		}
	}
	public class KijinSeijaEnemyUnitTemplate : EnemyUnitTemplate
	{
		public override IdContainer GetId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(KijinSeijaDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override EnemyUnitConfig MakeConfig()
		{
			return KijinSeijaDefaultConfig.DefaultEnemyUnitConfig();
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)KijinSeijaLocalization.EnemiesUnitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

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

		public EnemyUnitConfig GetDefaultEnemyUnitConfig()
		{
			return KijinSeijaDefaultConfig.DefaultEnemyUnitConfig();
		}
	}
}
namespace KijinSeijaMod.Config
{
	public struct CustomConfigEntry<T>
	{
		public T Value { get; set; }

		public string Section { get; set; }

		public string Key { get; set; }

		public string Description { get; set; }

		public CustomConfigEntry(T value, string section, string key, string description)
		{
			Value = value;
			Section = section;
			Key = key;
			Description = description;
		}
	}
	public sealed class KijinSeijaDefaultConfig
	{
		private static readonly string OwnerName = BepinexPlugin.modUniqueID;

		public static string DefaultID(EntityDefinition entity)
		{
			string name = ((object)entity).GetType().Name;
			return name.Remove(name.Length - 3);
		}

		public static CardConfig DefaultCardConfig()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: 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>(), OwnerName, "", "", "", false, (string)null, (IReadOnlyList<string>)new List<string>());
		}

		public static ExhibitConfig DefaultExhibitConfig()
		{
			//IL_0032: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			return new ExhibitConfig(0, "", 10, false, false, false, false, (AppearanceType)3, OwnerName, (ExhibitLosableType)1, (Rarity)3, (int?)null, (int?)null, (int?)null, (ManaGroup?)default(ManaGroup), (ManaColor?)null, (ManaColor?)(ManaColor)1, 1, false, (int?)null, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}

		public static StatusEffectConfig DefaultStatusEffectConfig()
		{
			//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, true, (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 static UltimateSkillConfig DefaultUltConfig()
		{
			//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 static EnemyUnitConfig DefaultEnemyUnitConfig()
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			return new EnemyUnitConfig("", false, false, (IReadOnlyList<ManaColor>)new List<ManaColor> { (ManaColor)6 }, 10, "", "#ffff", (EnemyType)3, false, (float?)null, (int?)null, 250, (int?)10, (int?)10, (int?)10, (int?)10, (int?)1, (int?)15, (int?)1, (int?)2, (int?)250, (int?)10, (int?)10, (int?)10, (int?)10, (int?)1, (int?)15, (int?)1, (int?)2, (int?)250, (int?)10, (int?)10, (int?)10, (int?)10, (int?)1, (int?)15, (int?)1, (int?)2, new MinMax(100, 100), new MinMax(100, 100), (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) }, (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) }, (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) }, (IReadOnlyList<string>)new List<string> { GunNameID.GetGunFromId(800) });
		}

		public static EnemyGroupConfig DefaultEnemyGroupConfig()
		{
			//IL_002d: 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: Expected O, but got Unknown
			return new EnemyGroupConfig("", false, (IReadOnlyList<string>)new List<string>(), "", "Single", (IReadOnlyList<string>)new List<string>(), (EnemyType)3, false, 1f, true, new Vector2(-4f, 0.5f), "", "", (string)null);
		}
	}
}
namespace KijinSeijaMod.Cards
{
	public sealed class KijinSeijaDynamicCostDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 10;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 10;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 2;
			defaultCardConfig.UpgradedValue1 = 3;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Keywords = (Keyword)65536;
			defaultCardConfig.UpgradedKeywords = (Keyword)65536;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Mana = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedMana = val;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaDynamicCostDef))]
	public sealed class KijinSeijaDynamicCost : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaDynamicCost <>4__this;

			private IEnumerator<Card> <enumerator>5__1;

			private int <Value20>5__2;

			private List<Card> <list>5__3;

			private Card <card3>5__4;

			private IEnumerator<Card> <>s__5;

			private Card <card2>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<enumerator>5__1 = null;
				<list>5__3 = null;
				<card3>5__4 = null;
				<>s__5 = null;
				<card2>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Expected O, but got Unknown
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_016d;
					}
					<>1__state = -1;
					<Value20>5__2 = 0;
					goto IL_019d;
					IL_019d:
					if (<Value20>5__2 < ((Card)<>4__this).Value1)
					{
						<list>5__3 = ((GameEntity)<>4__this).GameRun.BaseDeck.Where((Card card) => card.CanUpgradeAndPositive).ToList();
						if (<list>5__3.Count > 0)
						{
							<card3>5__4 = CollectionsExtensions.Sample<Card>((IEnumerable<Card>)<list>5__3, ((GameEntity)<>4__this).GameRun.GameRunEventRng);
							((GameEntity)<>4__this).GameRun.UpgradeDeckCard(<card3>5__4, false);
							<>s__5 = ((Card)<>4__this).Battle.EnumerateAllCards().GetEnumerator();
							<>1__state = -3;
							while (<>s__5.MoveNext())
							{
								<card2>5__6 = <>s__5.Current;
								if (<card2>5__6.InstanceId == <card3>5__4.InstanceId)
								{
									if (<card2>5__6.CanUpgrade)
									{
										<>2__current = (BattleAction)new UpgradeCardAction(<card2>5__6);
										<>1__state = 1;
										return true;
									}
									break;
								}
								<card2>5__6 = null;
							}
							goto IL_016d;
						}
						goto IL_0183;
					}
					<enumerator>5__1 = null;
					return false;
					IL_016d:
					<>m__Finally1();
					<>s__5 = null;
					<card3>5__4 = null;
					goto IL_0183;
					IL_0183:
					<list>5__3 = null;
					<Value20>5__2++;
					goto IL_019d;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__4 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaDynamicCost <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__3 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		protected override ManaGroup AdditionalCost
		{
			get
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: 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_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				if (((Card)this).Battle != null && ((Card)this).Battle.ExileZone.Count < 10)
				{
					return ((Card)this).Mana * -((Card)this).Battle.ExileZone.Count;
				}
				if (((Card)this).Battle != null && ((Card)this).Battle.ExileZone.Count >= 10)
				{
					return ((Card)this).Mana * -10;
				}
				return ((Card)this).Mana * 0;
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__3))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__3(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__4))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__4(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaMultipleKeywordsDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.RelativeEffects = new List<string> { "KijinSeijaTSG" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "KijinSeijaTSG" };
			defaultCardConfig.Keywords = (Keyword)524288;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaMultipleKeywordsDef))]
	public sealed class KijinSeijaMultipleKeywords : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaMultipleKeywords <>4__this;

			private EnemyUnit <selectedEnemy>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<selectedEnemy>5__1 = selector.SelectedEnemy;
					<>2__current = ((Card)<>4__this).DebuffAction<KijinSeijaTSG>((Unit)(object)<selectedEnemy>5__1, 1, 0, 0, 0, true, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaMultipleKeywords <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaUnplayableDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			defaultCardConfig.Cost = default(ManaGroup);
			defaultCardConfig.UpgradedCost = default(ManaGroup);
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)8;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 4;
			defaultCardConfig.UpgradedValue1 = 2;
			defaultCardConfig.Keywords = (Keyword)2129920;
			defaultCardConfig.UpgradedKeywords = (Keyword)2129920;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaUnplayableDef))]
	public sealed class KijinSeijaUnplayable : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public KijinSeijaUnplayable <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Invalid comparison between Unknown and I4
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((int)((Card)<>4__this).Zone == 2)
					{
						<>2__current = (BattleAction)(object)ConvertManaAction.Purify(((Card)<>4__this).Battle.BattleMana, ((Card)<>4__this).Value1);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerTurnStarted>d__1 <OnPlayerTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnStarted>d__ = this;
				}
				else
				{
					<OnPlayerTurnStarted>d__ = new <OnPlayerTurnStarted>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerTurnStarted>d__.args = <>3__args;
				return <OnPlayerTurnStarted>d__;
			}

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

		protected override void OnEnterBattle(BattleController battle)
		{
			((Card)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Card)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarted);
			((Card)this).HandleBattleEvent<ManaEventArgs>(((Card)this).Battle.ManaLosing, (GameEventHandler<ManaEventArgs>)OnManaLosing, (GameEventPriority)0);
		}

		[IteratorStateMachine(typeof(<OnPlayerTurnStarted>d__1))]
		private IEnumerable<BattleAction> OnPlayerTurnStarted(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerTurnStarted>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		private void OnManaLosing(ManaEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)((Card)this).Zone == 2)
			{
				((Card)this).NotifyActivating();
				((GameEventArgs)args).CancelBy((GameEntity)(object)this);
			}
		}
	}
	public sealed class KijinSeijaAccurateAttackDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Damage = 24;
			defaultCardConfig.UpgradedDamage = 32;
			defaultCardConfig.Keywords = (Keyword)256;
			defaultCardConfig.UpgradedKeywords = (Keyword)256;
			defaultCardConfig.ToolPlayableTimes = 7;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaAccurateAttackDef))]
	public sealed class KijinSeijaAccurateAttack : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaAccurateAttack <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).AttackAction(selector, "EAyaShoot1");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaAccurateAttack <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaAccurateAttack2Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Value1 = 92;
			defaultCardConfig.UpgradedValue1 = 118;
			defaultCardConfig.Value2 = 26;
			defaultCardConfig.UpgradedValue2 = 32;
			defaultCardConfig.Keywords = (Keyword)0;
			defaultCardConfig.UpgradedKeywords = (Keyword)256;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaAccurateAttack2Def))]
	public sealed class KijinSeijaAccurateAttack2 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaAccurateAttack2 <>4__this;

			private EnemyUnit <enemy>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Expected O, but got Unknown
				//IL_00a6: 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_00bb: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__1();
					<enemy>5__1 = selector.GetEnemy(((Card)<>4__this).Battle);
					if (((Unit)<enemy>5__1).Hp > ((Unit)((Card)<>4__this).Battle.Player).Hp * 2)
					{
						<>2__current = (BattleAction)new DamageAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)<enemy>5__1, DamageInfo.Reaction((float)((Card)<>4__this).Value1, false), "EAyaShoot2", (GunType)0);
						<>1__state = 1;
						return true;
					}
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)<enemy>5__1, DamageInfo.Reaction((float)((Card)<>4__this).Value2, false), "鸦天狗攻击", (GunType)0);
					<>1__state = 2;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__4 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaAccurateAttack2 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override bool Triggered
		{
			get
			{
				IEnumerable<EnemyUnit> allAliveEnemies = ((Card)this).Battle.AllAliveEnemies;
				foreach (EnemyUnit item in allAliveEnemies)
				{
					if (((Unit)item).Hp > ((Unit)((Card)this).Battle.Player).Hp * 2)
					{
						return true;
					}
				}
				return false;
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__4))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__4(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaAngryHeTongDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 3;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Value1 = 32;
			defaultCardConfig.Value2 = 2;
			defaultCardConfig.UpgradedValue2 = 1;
			defaultCardConfig.Keywords = (Keyword)0;
			defaultCardConfig.UpgradedKeywords = (Keyword)256;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaAngryHeTongDef))]
	public sealed class KijinSeijaAngryHeTong : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaAngryHeTong <>4__this;

			private EnemyUnit <enemy>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__1();
					<enemy>5__1 = selector.GetEnemy(((Card)<>4__this).Battle);
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)<enemy>5__1, DamageInfo.Reaction((float)((Card)<>4__this).AdditionalDamage, false), "锤子", (GunType)0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__4 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaAngryHeTong <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		protected override int AdditionalDamage => ((Card)this).Value1 - ((Card)this).Value2 * (4 - ((Card)this).DeckCounter.Value);

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__4))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__4(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaAttackRDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.IsPooled = false;
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Damage = 16;
			defaultCardConfig.UpgradedDamage = 25;
			defaultCardConfig.GunName = "MaoyuC";
			defaultCardConfig.Keywords = (Keyword)1;
			defaultCardConfig.UpgradedKeywords = (Keyword)1;
			defaultCardConfig.Illustrator = "@TheIllustrator";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaAttackRDef))]
	public sealed class KijinSeijaAttackR : KijinSeijaCard
	{
	}
	public sealed class KijinSeijaAttackWDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.IsPooled = false;
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Damage = 16;
			defaultCardConfig.UpgradedDamage = 25;
			defaultCardConfig.GunName = "MaoyuR";
			defaultCardConfig.Keywords = (Keyword)1;
			defaultCardConfig.UpgradedKeywords = (Keyword)1;
			defaultCardConfig.Illustrator = "Wholesome_illustrator";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaAttackWDef))]
	public sealed class KijinSeijaAttackW : KijinSeijaCard
	{
	}
	public sealed class KijinSeijaBasicAbilityDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 1;
			((ManaGroup)(ref cost)).Any = 1;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 3;
			defaultCardConfig.UpgradedValue1 = 4;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBasicAbilityDef))]
	public sealed class KijinSeijaBasicAbility : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaBasicAbility <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LimitedDamage>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)null, (int?)null, (int?)null, (int?)(((Unit)((Card)<>4__this).Battle.Player).MaxHp / ((Card)<>4__this).Value1), 1f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaBasicAbility <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaBasicAbility2Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 2;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 1;
			defaultCardConfig.UpgradedValue1 = 2;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Keywords = (Keyword)65536;
			defaultCardConfig.UpgradedKeywords = (Keyword)65536;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBasicAbility2Def))]
	public sealed class KijinSeijaBasicAbility2 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaBasicAbility2 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<GuangxueMicai>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)null, (int?)((Card)<>4__this).Value1, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaBasicAbility2 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaBlockAndBarrierDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 2;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)2;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Block = 10;
			defaultCardConfig.UpgradedBlock = 12;
			defaultCardConfig.Shield = 18;
			defaultCardConfig.UpgradedShield = 24;
			defaultCardConfig.ToolPlayableTimes = 6;
			defaultCardConfig.RelativeKeyword = (Keyword)1536;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)1536;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBlockAndBarrierDef))]
	public sealed class KijinSeijaBlockAndBarrier : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaBlockAndBarrier <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 3u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Expected O, but got Unknown
				//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						while (true)
						{
							if (<>s__1.MoveNext())
							{
								<enemy>5__2 = (Unit)(object)<>s__1.Current;
								if (<enemy>5__2.IsAlive && !((Card)<>4__this).Battle.BattleShouldEnd)
								{
									BlockInfo block;
									if (((Unit)((Card)<>4__this).Battle.Player).Hp < ((Unit)((Card)<>4__this).Battle.LowestHpEnemy).Hp)
									{
										<>2__current = ((Card)<>4__this).DefenseAction(true);
										<>1__state = 1;
										result = true;
									}
									else if (((Unit)((Card)<>4__this).Battle.Player).Hp > ((Unit)((Card)<>4__this).Battle.HighestHpEnemy).Hp)
									{
										KijinSeijaBlockAndBarrier kijinSeijaBlockAndBarrier = <>4__this;
										block = ((Card)<>4__this).Block;
										<>2__current = ((Card)kijinSeijaBlockAndBarrier).DefenseAction(((BlockInfo)(ref block)).Block, 0, (BlockShieldType)1, true);
										<>1__state = 2;
										result = true;
									}
									else
									{
										KijinSeijaBlockAndBarrier kijinSeijaBlockAndBarrier2 = <>4__this;
										block = ((Card)<>4__this).Block;
										<>2__current = ((Card)kijinSeijaBlockAndBarrier2).DefenseAction(((BlockInfo)(ref block)).Block, 0, (BlockShieldType)1, true);
										<>1__state = 4;
										result = true;
									}
									break;
								}
								<enemy>5__2 = null;
								continue;
							}
							<>m__Finally1();
							<>s__1 = null;
							result = false;
							break;
						}
						goto end_IL_0000;
					case 1:
						<>1__state = -3;
						result = false;
						break;
					case 2:
						<>1__state = -3;
						<>2__current = (BattleAction)new HealAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)((Card)<>4__this).Battle.Player, 3, (HealType)0, 0.2f);
						<>1__state = 3;
						result = true;
						goto end_IL_0000;
					case 3:
						<>1__state = -3;
						result = false;
						break;
					case 4:
						<>1__state = -3;
						result = false;
						break;
					}
					<>m__Finally1();
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaBlockAndBarrier <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaBlockBDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.IsPooled = false;
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)2;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Block = 14;
			defaultCardConfig.UpgradedBlock = 24;
			defaultCardConfig.Keywords = (Keyword)1;
			defaultCardConfig.UpgradedKeywords = (Keyword)1;
			defaultCardConfig.RelativeKeyword = (Keyword)512;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)512;
			defaultCardConfig.Illustrator = "Cool_illustrator";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBlockBDef))]
	public sealed class KijinSeijaBlockB : KijinSeijaCard
	{
	}
	public sealed class KijinSeijaBlockUDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.IsPooled = false;
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)2;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Block = 14;
			defaultCardConfig.UpgradedBlock = 24;
			defaultCardConfig.Keywords = (Keyword)1;
			defaultCardConfig.UpgradedKeywords = (Keyword)1;
			defaultCardConfig.RelativeKeyword = (Keyword)512;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)512;
			defaultCardConfig.Illustrator = "Credit_the_artist";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBlockUDef))]
	public sealed class KijinSeijaBlockU : KijinSeijaCard
	{
	}
	public sealed class KijinSeijaBonusOnUpgradeDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 3;
			((ManaGroup)(ref cost)).Colorless = 1;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Damage = 1;
			defaultCardConfig.UpgradedDamage = 3;
			defaultCardConfig.Value1 = 40;
			defaultCardConfig.UpgradedValue1 = 60;
			defaultCardConfig.Value2 = 1;
			defaultCardConfig.UpgradedValue2 = 2;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Keywords = (Keyword)2097152;
			defaultCardConfig.UpgradedKeywords = (Keyword)2097408;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBonusOnUpgradeDef))]
	public sealed class KijinSeijaBonusOnUpgrade : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass8_0
		{
			public EnemyUnit target;

			internal bool <Actions>b__0(EnemyUnit enemy)
			{
				return enemy != target;
			}
		}

		[CompilerGenerated]
		private sealed class <Actions>d__8 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaBonusOnUpgrade <>4__this;

			private <>c__DisplayClass8_0 <>8__1;

			private List<Unit> <targets>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass8_0();
					<>8__1.target = selector.GetEnemy(((Card)<>4__this).Battle);
					<>2__current = ((Card)<>4__this).AttackAction(selector, "阴阳结印");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<targets>5__2 = ((Card)<>4__this).Battle.EnemyGroup.Alives.Where((EnemyUnit enemy) => enemy != <>8__1.target).Cast<Unit>().ToList();
					if (!<>4__this.Highlight)
					{
						<>2__current = (BattleAction)new HealAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)((Card)<>4__this).Battle.Player, ((Card)<>4__this).Value1, (HealType)0, 0.2f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					((GameEntity)<>4__this).GameRun.GainMaxHp(((Card)<>4__this).Value2, true, true);
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__8 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__8(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaBonusOnUpgrade <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <OnEnemyDied>d__7 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DieEventArgs args;

			public DieEventArgs <>3__args;

			public KijinSeijaBonusOnUpgrade <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.DieSource == <>4__this && !args.Unit.HasStatusEffect<Servant>())
					{
						<>4__this.Highlight = false;
						<>2__current = (BattleAction)(object)PerformAction.Sfx("C5", 0f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnEnemyDied>d__7 <OnEnemyDied>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnEnemyDied>d__ = this;
				}
				else
				{
					<OnEnemyDied>d__ = new <OnEnemyDied>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnEnemyDied>d__.args = <>3__args;
				return <OnEnemyDied>d__;
			}

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

		public bool Highlight { get; private set; }

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		protected override void OnEnterBattle(BattleController battle)
		{
			((Card)this).ReactBattleEvent<DieEventArgs>(((Card)this).Battle.EnemyDied, (EventSequencedReactor<DieEventArgs>)OnEnemyDied);
			Highlight = true;
		}

		[IteratorStateMachine(typeof(<OnEnemyDied>d__7))]
		private IEnumerable<BattleAction> OnEnemyDied(DieEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnEnemyDied>d__7(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__8))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__8(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaBoomDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 5;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBoomDef))]
	public sealed class KijinSeijaBoom : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaBoom <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<KijinSeijaBoomSe>(1, 1, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaBoom <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaBorrowedBladeDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 3;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "KijinSeijaBorrowedBlade1" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "KijinSeijaBorrowedBlade1" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaBorrowedBladeDef))]
	public sealed class KijinSeijaBorrowedBlade : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaBorrowedBlade <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__1();
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<KijinSeijaBorrowedBlade1>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)1, (int?)0, (int?)0, (int?)0, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaBorrowedBlade <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaCard5Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 5;
			defaultCardConfig.UpgradedValue1 = 7;
			defaultCardConfig.Value2 = 2;
			defaultCardConfig.UpgradedValue2 = 3;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Keywords = (Keyword)8388608;
			defaultCardConfig.UpgradedKeywords = (Keyword)9437184;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "KijinSeijaCard7" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "KijinSeijaCard7" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaCard5Def))]
	public sealed class KijinSeijaCard5 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaCard5 <>4__this;

			private IReadOnlyList<Card> <readOnlyList>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Expected O, but got Unknown
				//IL_0043: 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_0076: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (precondition != null)
					{
						<readOnlyList>5__1 = ((SelectCardInteraction)precondition).SelectedCards;
						if (<readOnlyList>5__1.Count > 0)
						{
							<>2__current = (BattleAction)new ExileManyCardAction((IEnumerable<Card>)<readOnlyList>5__1);
							<>1__state = 1;
							return true;
						}
						goto IL_0087;
					}
					goto IL_008f;
				case 1:
					<>1__state = -1;
					goto IL_0087;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_008f:
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<KijinSeijaCard7>(((Card)<>4__this).Value2, false), (AddCardsType)0, false);
					<>1__state = 2;
					return true;
					IL_0087:
					<readOnlyList>5__1 = null;
					goto IL_008f;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaCard5 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		public override Interaction Precondition()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			List<Card> list = (from card in ((Card)this).Battle.HandZone.Concat(((Card)this).Battle.DrawZoneToShow).Concat(((Card)this).Battle.DiscardZone)
				where card != this
				select card).ToList();
			if (!CollectionsExtensions.Empty<Card>((IReadOnlyCollection<Card>)list))
			{
				return (Interaction)new SelectCardInteraction(0, ((Card)this).Value1, (IEnumerable<Card>)list, (SelectedCardHandling)0);
			}
			return null;
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaCard7Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Keywords = (Keyword)8388608;
			defaultCardConfig.UpgradedKeywords = (Keyword)10485760;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaCard7Def))]
	public sealed class KijinSeijaCard7 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaCard7 <>4__this;

			private SelectCardInteraction <selectCardInteraction>5__1;

			private Card <card>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<selectCardInteraction>5__1 = (SelectCardInteraction)precondition;
					<card>5__2 = ((<selectCardInteraction>5__1 != null) ? <selectCardInteraction>5__1.SelectedCards[0] : null);
					if (<card>5__2 != null)
					{
						<>2__current = (BattleAction)new MoveCardAction(<card>5__2, (CardZone)2);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaCard7 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		public override Interaction Precondition()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			if (((Card)this).Battle.ExileZone.Count <= 0)
			{
				return null;
			}
			return (Interaction)new SelectCardInteraction(0, 1, (IEnumerable<Card>)((Card)this).Battle.ExileZone, (SelectedCardHandling)0);
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaChangeImageDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 2;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Damage = 1;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaChangeImageDef))]
	public sealed class KijinSeijaChangeImage : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaChangeImage <>4__this;

			private EnemyUnit <enemy>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((Card)<>4__this).Battle);
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)<enemy>5__1, DamageInfo.Reaction((float)((Unit)<enemy>5__1).MaxHp / 3f, false), "锤子", (GunType)0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaChangeImage <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <OnPlayerDamageDealt>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DamageEventArgs args;

			public DamageEventArgs <>3__args;

			public KijinSeijaChangeImage <>4__this;

			private DamageInfo <damageInfo>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Invalid comparison between Unknown and I4
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Expected O, but got Unknown
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((int)((GameEventArgs)args).Cause != 1 || ((GameEventArgs)args).ActionSource != <>4__this)
					{
						break;
					}
					<damageInfo>5__1 = args.DamageInfo;
					if (((DamageInfo)(ref <damageInfo>5__1)).Damage > 0f)
					{
						<>2__current = (BattleAction)new GainMoneyAction((int)((DamageInfo)(ref <damageInfo>5__1)).Damage, (SpecialSourceType)0);
						<>1__state = 1;
						return true;
					}
					goto IL_00ae;
				case 1:
					<>1__state = -1;
					goto IL_00ae;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00ae:
					if (((Card)<>4__this).IsUpgraded)
					{
						<>2__current = (BattleAction)new GainPowerAction((int)((DamageInfo)(ref <damageInfo>5__1)).Damage);
						<>1__state = 2;
						return true;
					}
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerDamageDealt>d__4 <OnPlayerDamageDealt>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerDamageDealt>d__ = this;
				}
				else
				{
					<OnPlayerDamageDealt>d__ = new <OnPlayerDamageDealt>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerDamageDealt>d__.args = <>3__args;
				return <OnPlayerDamageDealt>d__;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		protected override void OnEnterBattle(BattleController battle)
		{
			((Card)this).ReactBattleEvent<DamageEventArgs>(((Unit)((Card)this).Battle.Player).DamageDealt, (EventSequencedReactor<DamageEventArgs>)OnPlayerDamageDealt);
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[IteratorStateMachine(typeof(<OnPlayerDamageDealt>d__4))]
		private IEnumerable<BattleAction> OnPlayerDamageDealt(DamageEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerDamageDealt>d__4(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaCustomAbilityDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 4;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 4;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaCustomAbilityDef))]
	public sealed class KijinSeijaCustomAbility : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaCustomAbility <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<KijinSeijaTurnGainSpiritSe>(1, 1, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaCustomAbility <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaDebuffDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 2;
			defaultCardConfig.UpgradedValue1 = 1;
			defaultCardConfig.Value2 = 60;
			defaultCardConfig.UpgradedValue2 = 90;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.RelativeEffects = new List<string> { "Vulnerable", "SpiritNegative" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Vulnerable", "SpiritNegative" };
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaDebuffDef))]
	public sealed class KijinSeijaDebuff : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaDebuff <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainPowerAction(((Card)<>4__this).Value2);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).DebuffAction<Vulnerable>((Unit)(object)((Card)<>4__this).Battle.Player, 0, ((Card)<>4__this).Value1, 0, 0, true, 0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).DebuffAction<SpiritNegative>((Unit)(object)((Card)<>4__this).Battle.Player, 3, 0, 0, 0, true, 0.2f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaDebuff <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaDrawDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 4;
			defaultCardConfig.UpgradedValue1 = 6;
			defaultCardConfig.ToolPlayableTimes = 6;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaDrawDef))]
	public sealed class KijinSeijaDraw : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaDraw <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new DrawManyCardAction(((Card)<>4__this).Value1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaDraw <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaDraw2Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 3;
			defaultCardConfig.UpgradedValue1 = 5;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Mana = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedMana = val;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaDraw2Def))]
	public sealed class KijinSeijaDraw2 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaDraw2 <>4__this;

			private List<Card> <list>5__1;

			private int <targetDrawCount>5__2;

			private List<Card> <cardsToDraw>5__3;

			private int <remainingNeeded>5__4;

			private List<Card>.Enumerator <>s__5;

			private Card <card>5__6;

			private List<Card>.Enumerator <>s__7;

			private Card <drawCard>5__8;

			private IEnumerable<Card> <cardsFromDiscard>5__9;

			private List<Card>.Enumerator <>s__10;

			private Card <discardCard>5__11;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				case -5:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally3();
					}
					break;
				}
				<list>5__1 = null;
				<cardsToDraw>5__3 = null;
				<>s__5 = default(List<Card>.Enumerator);
				<card>5__6 = null;
				<>s__7 = default(List<Card>.Enumerator);
				<drawCard>5__8 = null;
				<cardsFromDiscard>5__9 = null;
				<>s__10 = default(List<Card>.Enumerator);
				<discardCard>5__11 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_029d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Expected O, but got Unknown
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Expected O, but got Unknown
				//IL_0274: Unknown result type (might be due to invalid IL or missing references)
				//IL_027e: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<list>5__1 = new List<Card>();
						if (precondition != null)
						{
							<list>5__1.AddRange(((SelectHandInteraction)precondition).SelectedCards);
						}
						<>s__5 = <list>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_00d3;
					case 1:
						<>1__state = -3;
						<card>5__6 = null;
						goto IL_00d3;
					case 2:
						<>1__state = -4;
						<drawCard>5__8.SetTurnCost(((Card)<>4__this).Mana);
						<drawCard>5__8 = null;
						goto IL_01a4;
					case 3:
						{
							<>1__state = -5;
							<discardCard>5__11.SetTurnCost(((Card)<>4__this).Mana);
							<discardCard>5__11 = null;
							goto IL_02b0;
						}
						IL_02b0:
						if (<>s__10.MoveNext())
						{
							<discardCard>5__11 = <>s__10.Current;
							<>2__current = (BattleAction)new MoveCardAction(<discardCard>5__11, (CardZone)2);
							<>1__state = 3;
							return true;
						}
						<>m__Finally3();
						<>s__10 = default(List<Card>.Enumerator);
						<cardsFromDiscard>5__9 = null;
						break;
						IL_01a4:
						if (<>s__7.MoveNext())
						{
							<drawCard>5__8 = <>s__7.Current;
							<>2__current = (BattleAction)new MoveCardAction(<drawCard>5__8, (CardZone)2);
							<>1__state = 2;
							return true;
						}
						<>m__Finally2();
						<>s__7 = default(List<Card>.Enumerator);
						<remainingNeeded>5__4 = <targetDrawCount>5__2 - <cardsToDraw>5__3.Count;
						if (<remainingNeeded>5__4 <= 0 || ((Card)<>4__this).Battle.DiscardZone.Count <= 0)
						{
							break;
						}
						<cardsFromDiscard>5__9 = CollectionsExtensions.SampleManyOrAll<Card>((IEnumerable<Card>)((Card)<>4__this).Battle.DiscardZone, <remainingNeeded>5__4, ((GameEntity)<>4__this).GameRun.BattleCardRng);
						<>s__10 = <cardsFromDiscard>5__9.ToList().GetEnumerator();
						<>1__state = -5;
						goto IL_02b0;
						IL_00d3:
						if (<>s__5.MoveNext())
						{
							<card>5__6 = <>s__5.Current;
							<>2__current = (BattleAction)new MoveCardToDrawZoneAction(<card>5__6, (DrawZoneTarget)0);
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__5 = default(List<Card>.Enumerator);
						<targetDrawCount>5__2 = ((Card)<>4__this).Value1;
						<cardsToDraw>5__3 = ((Card)<>4__this).Battle.DrawZone.Reverse().Take(<targetDrawCount>5__2).ToList();
						<>s__7 = <cardsToDraw>5__3.GetEnumerator();
						<>1__state = -4;
						goto IL_01a4;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>s__7).Dispose();
			}

			private void <>m__Finally3()
			{
				<>1__state = -1;
				((IDisposable)<>s__10).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaDraw2 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		public override Interaction Precondition()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			List<Card> list = ((Card)this).Battle.HandZone.Where((Card card) => card != this).ToList();
			if (!CollectionsExtensions.Empty<Card>((IReadOnlyCollection<Card>)list))
			{
				return (Interaction)new SelectHandInteraction(0, list.Count, (IEnumerable<Card>)list);
			}
			return null;
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaDroneBlockDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.RelativeKeyword = (Keyword)65536;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)65536;
			defaultCardConfig.Value1 = 16;
			defaultCardConfig.UpgradedValue1 = 24;
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "DroneBlock" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "DroneBlock" };
			defaultCardConfig.Keywords = (Keyword)524288;
			defaultCardConfig.UpgradedKeywords = (Keyword)524288;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaDroneBlockDef))]
	public sealed class KijinSeijaDroneBlock : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaDroneBlock <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<DroneBlock>(((Card)<>4__this).Value1, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaDroneBlock <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaEscapeDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.IsPooled = false;
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.MoneyCost = 200;
			defaultCardConfig.Keywords = (Keyword)9961472;
			defaultCardConfig.UpgradedKeywords = (Keyword)11534336;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaEscapeDef))]
	public sealed class KijinSeijaEscape : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__8 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaEscape <>4__this;

			private List<EnemyUnit> <list>5__1;

			private EnemyUnit <u>5__2;

			private EnemyUnit <u>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0268: Unknown result type (might be due to invalid IL or missing references)
				//IL_0272: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<list>5__1 = ((IEnumerable<EnemyUnit>)((Card)<>4__this).Battle.EnemyGroup).Where((EnemyUnit u) => ((Unit)u).IsAlive).ToList();
					if (<list>5__1.Count > 1)
					{
						<u>5__2 = <list>5__1.First();
						<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<u>5__2, <>4__this.TalkEscape3, 3f, 0f, 0f, true);
						<>1__state = 1;
						return true;
					}
					if (<list>5__1.Count == 0)
					{
						Debug.LogWarning((object)"Payment is used while no Enemy");
						break;
					}
					<u>5__3 = <list>5__1.First();
					if (<u>5__3 is KijinSeijaSagume)
					{
						<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<u>5__3, <>4__this.TalkEscape2, 3f, 0f, 0f, true);
						<>1__state = 3;
						return true;
					}
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)((Card)<>4__this).Battle.Player, <>4__this.TalkEscape, 3f, 0f, 0f, true);
					<>1__state = 5;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>((Unit)(object)<u>5__2, (int?)10, (int?)null, (int?)null, (int?)null, 1f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<u>5__2 = null;
					break;
				case 3:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>((Unit)(object)<u>5__3, (int?)99, (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					goto IL_0283;
				case 5:
					<>1__state = -1;
					<>2__current = (BattleAction)new EscapeAction((Unit)(object)<u>5__3);
					<>1__state = 6;
					return true;
				case 6:
					{
						<>1__state = -1;
						goto IL_0283;
					}
					IL_0283:
					<u>5__3 = null;
					<u>5__3 = null;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__8 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__8(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaEscape <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public string TalkEscape => ((GameEntity)this).LocalizeProperty("TalkEscape", false, true);

		public string TalkEscape2 => ((GameEntity)this).LocalizeProperty("TalkEscape2", false, true);

		public string TalkEscape3 => ((GameEntity)this).LocalizeProperty("TalkEscape3", false, true);

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__8))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__8(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaExtraTurnDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 1;
			defaultCardConfig.UpgradedValue1 = 2;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Mana = val;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.RelativeEffects = new List<string> { "TimeIsLimited" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "TimeIsLimited" };
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaExtraTurnDef))]
	public sealed class KijinSeijaExtraTurn : LimitedStopTimeCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaExtraTurn <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<ExtraTurn>(((Card)<>4__this).Value1, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((LimitedStopTimeCard)<>4__this).Limited)
					{
						<>2__current = ((Card)<>4__this).DebuffAction<TimeIsLimited>((Unit)(object)((Card)<>4__this).Battle.Player, 1, 0, 0, 0, true, 0.2f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaExtraTurn <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaFoxDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.RelativeKeyword = (Keyword)589824;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)589824;
			defaultCardConfig.Value1 = 3;
			defaultCardConfig.UpgradedValue1 = 5;
			defaultCardConfig.Value2 = 1;
			defaultCardConfig.UpgradedValue2 = 2;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "FoxCharm", "Immune" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "FoxCharm", "Immune" };
			defaultCardConfig.Keywords = (Keyword)589824;
			defaultCardConfig.UpgradedKeywords = (Keyword)589824;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaFoxDef))]
	public sealed class KijinSeijaFox : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaFox <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<FoxCharm>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)((Card)<>4__this).Value1, (int?)((Card)<>4__this).Value1, (int?)((Card)<>4__this).Value1, (int?)((Card)<>4__this).Value1, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Immune>(0, ((Card)<>4__this).Value2, 0, 0, 0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaFox <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaGainManaDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 1;
			((ManaGroup)(ref val)).Red = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 12;
			defaultCardConfig.Mana = val;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaGainManaDef))]
	public sealed class KijinSeijaGainMana : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaGainMana <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainManaAction(((Card)<>4__this).Mana);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).DebuffAction<Weak>((Unit)(object)((Card)<>4__this).Battle.Player, 0, 2, 0, 0, true, 0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).DebuffAction<Vulnerable>((Unit)(object)((Card)<>4__this).Battle.Player, 0, 2, 0, 0, true, 0.2f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaGainMana <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaGainMana2Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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_0073: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 4;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Red = 2;
			((ManaGroup)(ref val)).Black = 2;
			((ManaGroup)(ref val)).Blue = 2;
			((ManaGroup)(ref val)).Green = 2;
			((ManaGroup)(ref val)).White = 2;
			((ManaGroup)(ref val)).Philosophy = 1;
			defaultCardConfig.Mana = val;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaGainMana2Def))]
	public sealed class KijinSeijaGainMana2 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaGainMana2 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainManaAction(((Card)<>4__this).Mana);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaGainMana2 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaGrazeDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 2;
			defaultCardConfig.UpgradedValue1 = 3;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.ToolPlayableTimes = 9;
			defaultCardConfig.RelativeEffects = new List<string> { "Graze" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Graze" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaGrazeDef))]
	public sealed class KijinSeijaGraze : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaGraze <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Graze>(((Card)<>4__this).Value1, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaGraze <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaGraze2Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 1;
			defaultCardConfig.UpgradedValue1 = 1;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.RelativeEffects = new List<string> { "Invincible" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Invincible" };
			defaultCardConfig.Keywords = (Keyword)2097152;
			defaultCardConfig.UpgradedKeywords = (Keyword)2097152;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaGraze2Def))]
	public sealed class KijinSeijaGraze2 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaGraze2 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Invincible>(((Card)<>4__this).Value1, ((Card)<>4__this).Value1, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaGraze2 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaHealDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 3;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Keywords = (Keyword)0;
			defaultCardConfig.UpgradedKeywords = (Keyword)2097152;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaHealDef))]
	public sealed class KijinSeijaHeal : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaHeal <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<KijinSeijaHeal1>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)1, (int?)1, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaHeal <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaInvertedWorldDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "KijinSeijaInvertedWorld1" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "KijinSeijaInvertedWorld1" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaInvertedWorldDef))]
	public sealed class KijinSeijaInvertedWorld : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaInvertedWorld <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__1();
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<KijinSeijaInvertedWorld1>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)1, (int?)0, (int?)0, (int?)0, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaInvertedWorld <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaJiaYongDianQiDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.RelativeEffects = new List<string> { "Appliance" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Appliance" };
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaJiaYongDianQiDef))]
	public sealed class KijinSeijaJiaYongDianQi : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaJiaYongDianQi <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Appliance>(0, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaJiaYongDianQi <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaKillDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Value1 = 4;
			defaultCardConfig.UpgradedValue1 = 7;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaKillDef))]
	public sealed class KijinSeijaKill : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__6 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaKill <>4__this;

			private EnemyUnit <selectedEnemy>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<selectedEnemy>5__1 = selector.SelectedEnemy;
					if (((Unit)<selectedEnemy>5__1).MaxHp >= ((Unit)((Card)<>4__this).Battle.Player).MaxHp * ((Card)<>4__this).Value1)
					{
						<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<selectedEnemy>5__1, <>4__this.FailToKill, 3f, 0f, 0f, true);
						<>1__state = 1;
						return true;
					}
					if (((Unit)<selectedEnemy>5__1).MaxHp - ((Unit)<selectedEnemy>5__1).Hp >= ((Unit)((Card)<>4__this).Battle.Player).Hp)
					{
						<>2__current = (BattleAction)new ForceKillAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)<selectedEnemy>5__1);
						<>1__state = 2;
						return true;
					}
					<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<selectedEnemy>5__1, <>4__this.FailToKill, 3f, 0f, 0f, true);
					<>1__state = 3;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__6 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaKill <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public string FailToKill => ((GameEntity)this).LocalizeProperty("FailToKill", false, true);

		public override bool Triggered
		{
			get
			{
				IEnumerable<EnemyUnit> allAliveEnemies = ((Card)this).Battle.AllAliveEnemies;
				foreach (EnemyUnit item in allAliveEnemies)
				{
					if (((Unit)item).MaxHp - ((Unit)item).Hp >= ((Unit)((Card)this).Battle.Player).Hp && ((Unit)item).MaxHp <= ((Unit)((Card)this).Battle.Player).MaxHp * ((Card)this).Value1)
					{
						return true;
					}
				}
				return false;
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__6))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__6(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaLoseHpDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 1;
			((ManaGroup)(ref val)).Red = 1;
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 3;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Keywords = (Keyword)0;
			defaultCardConfig.UpgradedKeywords = (Keyword)2097152;
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaLoseHpDef))]
	public sealed class KijinSeijaLoseHp : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaLoseHp <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if (((Unit)((Card)<>4__this).Battle.Player).MaxHp == ((Unit)((Card)<>4__this).Battle.Player).Hp)
				{
					Singleton<GameMaster>.Instance.CurrentGameRun.SetHpAndMaxHp(1, ((Unit)((Card)<>4__this).Battle.Player).MaxHp, false);
				}
				else
				{
					Singleton<GameMaster>.Instance.CurrentGameRun.SetHpAndMaxHp(((Unit)((Card)<>4__this).Battle.Player).MaxHp - ((Unit)((Card)<>4__this).Battle.Player).Hp, ((Unit)((Card)<>4__this).Battle.Player).MaxHp, false);
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaLoseHp <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaLoseHp2Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 3;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Keywords = (Keyword)0;
			defaultCardConfig.UpgradedKeywords = (Keyword)2097152;
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaLoseHp2Def))]
	public sealed class KijinSeijaLoseHp2 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaLoseHp2 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<TimeAuraSe>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)((Unit)((Card)<>4__this).Battle.Player).Hp, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Singleton<GameMaster>.Instance.CurrentGameRun.SetHpAndMaxHp(1, ((Unit)((Card)<>4__this).Battle.Player).MaxHp, false);
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaLoseHp2 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaLoseHp3Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 5;
			defaultCardConfig.UpgradedValue1 = 10;
			defaultCardConfig.Keywords = (Keyword)65536;
			defaultCardConfig.UpgradedKeywords = (Keyword)65536;
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaLoseHp3Def))]
	public sealed class KijinSeijaLoseHp3 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaLoseHp3 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				Singleton<GameMaster>.Instance.CurrentGameRun.SetHpAndMaxHp(((Unit)((Card)<>4__this).Battle.Player).MaxHp - ((Unit)((Card)<>4__this).Battle.Player).MaxHp / ((Card)<>4__this).Value1, ((Unit)((Card)<>4__this).Battle.Player).MaxHp - ((Unit)((Card)<>4__this).Battle.Player).MaxHp / ((Card)<>4__this).Value1, false);
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaLoseHp3 <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaLosePowerDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 5;
			defaultCardConfig.Mana = val;
			defaultCardConfig.Value1 = 3;
			defaultCardConfig.UpgradedValue1 = 5;
			defaultCardConfig.ToolPlayableTimes = 5;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaLosePowerDef))]
	public sealed class KijinSeijaLosePower : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaLosePower <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				//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_0064: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new LosePowerAction(50);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainManaAction(((Card)<>4__this).Mana);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)new DrawManyCardAction(((Card)<>4__this).Value1);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaLosePower <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaLoveGirlDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 1;
			defaultCardConfig.UpgradedValue1 = 2;
			defaultCardConfig.ToolPlayableTimes = 5;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "LoveGirlDamageReduce" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "LoveGirlDamageReduce" };
			defaultCardConfig.Keywords = (Keyword)524288;
			defaultCardConfig.UpgradedKeywords = (Keyword)524288;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaLoveGirlDef))]
	public sealed class KijinSeijaLoveGirl : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaLoveGirl <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LoveGirlDamageReduce>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)((Card)<>4__this).Value1, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaLoveGirl <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaMaoYuDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaMaoYuDef))]
	public sealed class KijinSeijaMaoYu : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaMaoYu <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<KijinSeijaMaoYuSe>(0, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaMaoYu <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaMoneyDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaMoneyDef))]
	public sealed class KijinSeijaMoney : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaMoney <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<KijinSeijaMoney1>(1, 1, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaMoney <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaPoisonDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)2;
			defaultCardConfig.RelativeKeyword = (Keyword)65536;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)65536;
			defaultCardConfig.Value1 = 8;
			defaultCardConfig.UpgradedValue1 = 12;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Poison" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Poison" };
			defaultCardConfig.Keywords = (Keyword)524288;
			defaultCardConfig.UpgradedKeywords = (Keyword)524288;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaPoisonDef))]
	public sealed class KijinSeijaPoison : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaPoison <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00e4;
					}
					<>1__state = -1;
					<>4__this.<>n__1();
					<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
					<>1__state = -3;
					goto IL_00ec;
					IL_00e4:
					<enemy>5__2 = null;
					goto IL_00ec;
					IL_00ec:
					if (<>s__1.MoveNext())
					{
						<enemy>5__2 = (Unit)(object)<>s__1.Current;
						if (<enemy>5__2.IsAlive && !((Card)<>4__this).Battle.BattleShouldEnd)
						{
							<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Poison>(<enemy>5__2, (int?)((Card)<>4__this).Value1, (int?)0, (int?)0, (int?)0, 0f, true);
							<>1__state = 1;
							return true;
						}
						goto IL_00e4;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaPoison <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaRabbitDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "EnemyTuanzi" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "EnemyTuanzi" };
			defaultCardConfig.Keywords = (Keyword)8388608;
			defaultCardConfig.UpgradedKeywords = (Keyword)8388608;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaRabbitDef))]
	public sealed class KijinSeijaRabbit : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaRabbit <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<EnemyTuanzi>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)2, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<AccuracyModule1>(0, 0, 0, 0, 0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaRabbit <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaShenLingGoldDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)5;
			defaultCardConfig.RelativeKeyword = (Keyword)65536;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)65536;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Amulet" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Amulet" };
			defaultCardConfig.Keywords = (Keyword)65536;
			defaultCardConfig.UpgradedKeywords = (Keyword)65536;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaShenLingGoldDef))]
	public sealed class KijinSeijaShenLingGold : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaShenLingGold <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>4__this.<>n__1();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Amulet>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)1, (int?)null, (int?)null, (int?)null, 0f, true);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						goto IL_014e;
					case 2:
						{
							<>1__state = -3;
							goto IL_0146;
						}
						IL_014e:
						if (<>s__1.MoveNext())
						{
							<enemy>5__2 = (Unit)(object)<>s__1.Current;
							if (<enemy>5__2.IsAlive && !((Card)<>4__this).Battle.BattleShouldEnd)
							{
								<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<ShenlingGold>(<enemy>5__2, (int?)30, (int?)null, (int?)null, (int?)null, 1f, true);
								<>1__state = 2;
								return true;
							}
							goto IL_0146;
						}
						<>m__Finally1();
						<>s__1 = null;
						return false;
						IL_0146:
						<enemy>5__2 = null;
						goto IL_014e;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaShenLingGold <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaShenLingHPDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)5;
			defaultCardConfig.RelativeKeyword = (Keyword)65536;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)65536;
			defaultCardConfig.Value1 = 2;
			defaultCardConfig.UpgradedValue1 = 3;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Amulet" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Amulet" };
			defaultCardConfig.Keywords = (Keyword)65536;
			defaultCardConfig.UpgradedKeywords = (Keyword)65536;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaShenLingHPDef))]
	public sealed class KijinSeijaShenLingHP : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaShenLingHP <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>4__this.<>n__1();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Amulet>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)1, (int?)null, (int?)null, (int?)null, 0f, true);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						goto IL_0157;
					case 2:
						{
							<>1__state = -3;
							goto IL_014f;
						}
						IL_0157:
						if (<>s__1.MoveNext())
						{
							<enemy>5__2 = (Unit)(object)<>s__1.Current;
							if (<enemy>5__2.IsAlive && !((Card)<>4__this).Battle.BattleShouldEnd)
							{
								<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<ShenlingHp>(<enemy>5__2, (int?)((Card)<>4__this).Value1, (int?)null, (int?)null, (int?)null, 1f, true);
								<>1__state = 2;
								return true;
							}
							goto IL_014f;
						}
						<>m__Finally1();
						<>s__1 = null;
						return false;
						IL_014f:
						<enemy>5__2 = null;
						goto IL_0157;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaShenLingHP <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaSunflowerDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 3;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Damage = 7;
			defaultCardConfig.UpgradedDamage = 9;
			defaultCardConfig.Block = 9;
			defaultCardConfig.UpgradedBlock = 9;
			defaultCardConfig.ToolPlayableTimes = 9;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaSunflowerDef))]
	public sealed class KijinSeijaSunflower : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaSunflower <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a5: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__1();
					<>2__current = ((Card)<>4__this).AttackAction(selector, "WhiteFairy1");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).AttackAction(selector, "Instant");
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					KijinSeijaSunflower kijinSeijaSunflower = <>4__this;
					BlockInfo block = ((Card)<>4__this).Block;
					<>2__current = ((Card)kijinSeijaSunflower).DefenseAction(((BlockInfo)(ref block)).Block, 0, (BlockShieldType)1, true);
					<>1__state = 3;
					return true;
				}
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaSunflower <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaTiaoZhanDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 1;
			defaultCardConfig.UpgradedValue1 = 1;
			defaultCardConfig.ToolPlayableTimes = 1;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaTiaoZhanDef))]
	public sealed class KijinSeijaTiaoZhan : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaTiaoZhan <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<MoodPassion>(0, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Vulnerable>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)0, (int?)99, (int?)0, (int?)0, 0f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<KijinSeijaTiaoZhan1>(((Card)<>4__this).Value1, 0, 0, 0, 0.2f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaTiaoZhan <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaTokenDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.IsPooled = false;
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)2;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Philosophy = 1;
			defaultCardConfig.Mana = val;
			defaultCardConfig.Keywords = (Keyword)589824;
			defaultCardConfig.UpgradedKeywords = (Keyword)589824;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaTokenDef))]
	public sealed class KijinSeijaToken : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaToken <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

			private List<Card> <KijinSeijaTokens>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 2) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<KijinSeijaTokens>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Expected O, but got Unknown
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Expected O, but got Unknown
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0159: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (BattleAction)new GainManaAction(((Card)<>4__this).Mana);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						goto IL_01ab;
					case 2:
						<>1__state = -3;
						<>2__current = (BattleAction)new ExileManyCardAction((IEnumerable<Card>)<KijinSeijaTokens>5__3);
						<>1__state = 3;
						return true;
					case 3:
						{
							<>1__state = -3;
							goto IL_019b;
						}
						IL_01ab:
						if (<>s__1.MoveNext())
						{
							<enemy>5__2 = (Unit)(object)<>s__1.Current;
							if (<>4__this.KijinSeijaTokenCount >= 7)
							{
								<KijinSeijaTokens>5__3 = (from card in ((Card)<>4__this).Battle.EnumerateAllCardsButExile()
									where card is KijinSeijaToken
									select card).ToList();
								if (<>4__this == <KijinSeijaTokens>5__3.First())
								{
									<>2__current = (BattleAction)new DamageAction((Unit)(object)((Card)<>4__this).Battle.Player, (IEnumerable<Unit>)((Card)<>4__this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)<enemy>5__2.MaxHp * 10f, false), "实现愿望", (GunType)0);
									<>1__state = 2;
									return true;
								}
								goto IL_019b;
							}
							goto IL_01a3;
						}
						<>m__Finally1();
						<>s__1 = null;
						return false;
						IL_01a3:
						<enemy>5__2 = null;
						goto IL_01ab;
						IL_019b:
						<KijinSeijaTokens>5__3 = null;
						goto IL_01a3;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		public int KijinSeijaTokenCount
		{
			get
			{
				if (((Card)this).Battle != null)
				{
					return ((Card)this).Battle.EnumerateAllCardsButExile().Count((Card card) => card is KijinSeijaToken);
				}
				return 0;
			}
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}
	}
	public sealed class KijinSeijaUPDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Any = 0;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Keywords = (Keyword)524288;
			defaultCardConfig.UpgradedKeywords = (Keyword)524288;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaUPDef))]
	public sealed class KijinSeijaUP : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__6 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaUP <>4__this;

			private int <Value12>5__1;

			private List<Card> <list>5__2;

			private IEnumerator<Card> <enumerator>5__3;

			private Card <card3>5__4;

			private IEnumerator<Card> <>s__5;

			private Card <card2>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<list>5__2 = null;
				<enumerator>5__3 = null;
				<card3>5__4 = null;
				<>s__5 = null;
				<card2>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<Value12>5__1 = 0;
						goto IL_01f1;
					case 1:
						<>1__state = -3;
						goto IL_019b;
					case 2:
						{
							<>1__state = -3;
							goto IL_01b3;
						}
						IL_01f1:
						if (<Value12>5__1 < ((Card)<>4__this).UpgradeCounter)
						{
							<list>5__2 = ((GameEntity)<>4__this).GameRun.BaseDeck.Where((Card card) => card.CanUpgradeAndPositive).ToList();
							if (<list>5__2.Count > 0)
							{
								<card3>5__4 = CollectionsExtensions.Sample<Card>((IEnumerable<Card>)<list>5__2, ((GameEntity)<>4__this).GameRun.GameRunEventRng);
								((GameEntity)<>4__this).GameRun.UpgradeDeckCard(<card3>5__4, false);
								<>s__5 = ((Card)<>4__this).Battle.EnumerateAllCards().GetEnumerator();
								<>1__state = -3;
								goto IL_01a3;
							}
							goto IL_01c9;
						}
						return false;
						IL_01a3:
						if (<>s__5.MoveNext())
						{
							<card2>5__6 = <>s__5.Current;
							if (<card2>5__6 is KijinSeijaUP)
							{
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
							if (<card2>5__6.InstanceId != <card3>5__4.InstanceId)
							{
								goto IL_019b;
							}
							if (<card2>5__6.CanUpgrade)
							{
								<>2__current = (BattleAction)new UpgradeCardAction(<card2>5__6);
								<>1__state = 2;
								return true;
							}
						}
						goto IL_01b3;
						IL_019b:
						<card2>5__6 = null;
						goto IL_01a3;
						IL_01b3:
						<>m__Finally1();
						<>s__5 = null;
						<card3>5__4 = null;
						goto IL_01c9;
						IL_01c9:
						<enumerator>5__3 = null;
						<list>5__2 = null;
						<enumerator>5__3 = null;
						<Value12>5__1++;
						goto IL_01f1;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__6 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterFollowPlayAction>d__8 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaUP <>4__this;

			private Card <deckCardByInstanceId>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<deckCardByInstanceId>5__1 = ((GameEntity)<>4__this).GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
					if (<deckCardByInstanceId>5__1 != null)
					{
						((GameEntity)<>4__this).GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
					}
					<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterFollowPlayAction>d__8 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterFollowPlayAction>d__8(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__7 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaUP <>4__this;

			private Card <deckCardByInstanceId>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<deckCardByInstanceId>5__1 = ((GameEntity)<>4__this).GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
					if (<deckCardByInstanceId>5__1 != null)
					{
						((GameEntity)<>4__this).GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
					}
					<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__7 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override bool CanUpgrade => ((Card)this).UpgradeCounter < 99;

		public override bool IsUpgraded => ((Card)this).UpgradeCounter > 0;

		public override void Initialize()
		{
			((Card)this).Initialize();
			((Card)this).UpgradeCounter = 0;
		}

		public override void Upgrade()
		{
			int? upgradeCounter = ((Card)this).UpgradeCounter + 1;
			((Card)this).UpgradeCounter = upgradeCounter;
			((Card)this).ProcessKeywordUpgrade();
			((Card)this).CostChangeInUpgrading();
			((GameEntity)this).NotifyChanged();
		}

		[IteratorStateMachine(typeof(<Actions>d__6))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__6(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__7))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__7(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<AfterFollowPlayAction>d__8))]
		public override IEnumerable<BattleAction> AfterFollowPlayAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterFollowPlayAction>d__8(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class KijinSeijaVampireDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 3;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Vampire" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Vampire" };
			defaultCardConfig.Keywords = (Keyword)524288;
			defaultCardConfig.UpgradedKeywords = (Keyword)524288;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaVampireDef))]
	public sealed class KijinSeijaVampire : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaVampire <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Vampire>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)null, (int?)null, (int?)null, (int?)null, 1f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Graze>(1, 0, 0, 0, 0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

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

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaVampire <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaWaterDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)2;
			defaultCardConfig.Value1 = 12;
			defaultCardConfig.UpgradedValue1 = 15;
			defaultCardConfig.ToolPlayableTimes = 5;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Drowning" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Drowning" };
			defaultCardConfig.Keywords = (Keyword)524288;
			defaultCardConfig.UpgradedKeywords = (Keyword)524288;
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaWaterDef))]
	public sealed class KijinSeijaWater : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaWater <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

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

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00d6;
					}
					<>1__state = -1;
					<>4__this.<>n__1();
					<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
					<>1__state = -3;
					goto IL_00de;
					IL_00d6:
					<enemy>5__2 = null;
					goto IL_00de;
					IL_00de:
					if (<>s__1.MoveNext())
					{
						<enemy>5__2 = (Unit)(object)<>s__1.Current;
						if (<enemy>5__2.IsAlive && !((Card)<>4__this).Battle.BattleShouldEnd)
						{
							<>2__current = ((Card)<>4__this).DebuffAction<Drowning>(<enemy>5__2, ((Card)<>4__this).Value1, 0, 0, 0, true, 0.2f);
							<>1__state = 1;
							return true;
						}
						goto IL_00d6;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaWater <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaWeakDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)0;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)2;
			defaultCardConfig.RelativeKeyword = (Keyword)65536;
			defaultCardConfig.UpgradedRelativeKeyword = (Keyword)65536;
			defaultCardConfig.Value1 = 2;
			defaultCardConfig.UpgradedValue1 = 3;
			defaultCardConfig.ToolPlayableTimes = 6;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Vulnerable" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Vulnerable" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaWeakDef))]
	public sealed class KijinSeijaWeak : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaWeak <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00e4;
					}
					<>1__state = -1;
					<>4__this.<>n__1();
					<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
					<>1__state = -3;
					goto IL_00ec;
					IL_00e4:
					<enemy>5__2 = null;
					goto IL_00ec;
					IL_00ec:
					if (<>s__1.MoveNext())
					{
						<enemy>5__2 = (Unit)(object)<>s__1.Current;
						if (<enemy>5__2.IsAlive && !((Card)<>4__this).Battle.BattleShouldEnd)
						{
							<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Vulnerable>(<enemy>5__2, (int?)0, (int?)((Card)<>4__this).Value1, (int?)0, (int?)0, 0f, true);
							<>1__state = 1;
							return true;
						}
						goto IL_00e4;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaWeak <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__1()
		{
			((Card)this).NotifyActivating();
		}
	}
	public sealed class KijinSeijaWGCZDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 1;
			defaultCardConfig.UpgradedValue1 = 2;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaWGCZDef))]
	public sealed class KijinSeijaWGCZ : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaWGCZ <>4__this;

			private SelectCardInteraction <selectCardInteraction>5__1;

			private Card <card>5__2;

			private IReadOnlyList<Card> <cards>5__3;

			private int <num>5__4;

			private IEnumerator<Card> <>s__5;

			private Card <card2>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<selectCardInteraction>5__1 = null;
				<card>5__2 = null;
				<cards>5__3 = null;
				<>s__5 = null;
				<card2>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (precondition == null)
						{
							break;
						}
						<selectCardInteraction>5__1 = (SelectCardInteraction)precondition;
						<card>5__2 = ((<selectCardInteraction>5__1 != null) ? <selectCardInteraction>5__1.SelectedCards[0] : null);
						if (<card>5__2 != null)
						{
							<>s__5 = <selectCardInteraction>5__1.SelectedCards.GetEnumerator();
							<>1__state = -3;
							goto IL_011d;
						}
						goto IL_01aa;
					case 1:
						<>1__state = -3;
						<>2__current = (BattleAction)new RemoveCardAction(<card>5__2);
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -3;
						<card2>5__6 = null;
						goto IL_011d;
					case 3:
						{
							<>1__state = -1;
							<cards>5__3 = null;
							goto IL_01aa;
						}
						IL_011d:
						if (<>s__5.MoveNext())
						{
							<card2>5__6 = <>s__5.Current;
							<>2__current = (BattleAction)new PlayCardAction(<card>5__2);
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__5 = null;
						<cards>5__3 = <selectCardInteraction>5__1.SelectedCards;
						<num>5__4 = <cards>5__3.Sum(delegate(Card card)
						{
							//IL_0006: Unknown result type (might be due to invalid IL or missing references)
							//IL_000b: Unknown result type (might be due to invalid IL or missing references)
							ManaGroup cost = card.Config.Cost;
							return ((ManaGroup)(ref cost)).Amount;
						});
						<>2__current = ((Card)<>4__this).SacrificeAction(<num>5__4);
						<>1__state = 3;
						return true;
						IL_01aa:
						<selectCardInteraction>5__1 = null;
						<card>5__2 = null;
						break;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaWGCZ <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		public override Interaction Precondition()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			List<Card> list = ((Card)this).Battle.ExileZone.Where((Card card) => card != this).ToList();
			if (!CollectionsExtensions.Empty<Card>((IReadOnlyCollection<Card>)list))
			{
				return (Interaction)new SelectCardInteraction(1, ((Card)this).Value1, (IEnumerable<Card>)list, (SelectedCardHandling)0);
			}
			return null;
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaYaoShiDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 4;
			defaultCardConfig.UpgradedValue1 = 6;
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "RockHardAura" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "RockHardAura" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaYaoShiDef))]
	public sealed class KijinSeijaYaoShi : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaYaoShi <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<RockHardAura>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)((Card)<>4__this).Value1, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaYaoShi <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaYaTianGouDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 10;
			defaultCardConfig.UpgradedValue1 = 15;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "KijinSeijaFastAttack" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "KijinSeijaFastAttack" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaYaTianGouDef))]
	public sealed class KijinSeijaYaTianGou : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaYaTianGou <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<KijinSeijaFastAttack>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)((Card)<>4__this).Value1, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Graze>(2, 0, 0, 0, 0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaYaTianGou <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaYinyangyuDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)4;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 7;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Spirit", "Firepower" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaYinyangyuDef))]
	public sealed class KijinSeijaYinyangyu : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaYinyangyu <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<KijinSeijaYinyangyuSe>(1, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaYinyangyu <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaHybridDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor>
			{
				(ManaColor)1,
				(ManaColor)2
			};
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Hybrid = 1;
			((ManaGroup)(ref val)).HybridColor = 0;
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Mana = val;
			defaultCardConfig.ToolPlayableTimes = 6;
			defaultCardConfig.Keywords = (Keyword)65536;
			defaultCardConfig.UpgradedKeywords = (Keyword)65536;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaHybridDef))]
	public sealed class KijinSeijaHybrid : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaHybrid <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainTurnManaAction(((Card)<>4__this).Mana);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Lunatic>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)null, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaHybrid <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaXCostDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.IsXCost = true;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.ToolPlayableTimes = 2;
			defaultCardConfig.RelativeEffects = new List<string> { "Graze", "Firepower", "Spirit", "TimeAuraSe", "MoodEpiphany", "Burst", "FrostArmor" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Graze", "Firepower", "Spirit", "TimeAuraSe", "MoodEpiphany", "Burst", "FrostArmor" };
			defaultCardConfig.Value2 = 3;
			defaultCardConfig.UpgradedValue2 = 4;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Mana = val;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaXCostDef))]
	public sealed class KijinSeijaXCost : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__6 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaXCost <>4__this;

			private int <times1>5__1;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<times1>5__1 = ((Card)<>4__this).SynergyAmount(consumingMana, (ManaColor)6, 1);
					<>2__current = ((Card)<>4__this).BuffAction<Graze>(<times1>5__1, 0, 0, 0, 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Firepower>(<times1>5__1 * ((Card)<>4__this).Value2, 0, 0, 0, 0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Spirit>(<times1>5__1 * ((Card)<>4__this).Value2, 0, 0, 0, 0.2f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<TimeAuraSe>(<times1>5__1 * ((Card)<>4__this).Value2, 0, 0, 0, 0.2f);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<FrostArmor>(<times1>5__1 * ((Card)<>4__this).Value2, 0, 0, 0, 0.2f);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					if (<times1>5__1 >= 4)
					{
						<>2__current = ((Card)<>4__this).BuffAction<MoodEpiphany>(0, 0, 0, 0, 0.2f);
						<>1__state = 6;
						return true;
					}
					break;
				case 6:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).BuffAction<Burst>(1, 0, 0, 0, 0.2f);
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__6 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaXCost <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		private ManaGroup _colorlessMana;

		public ManaGroup ColorlessMana => _colorlessMana;

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		public override ManaGroup GetXCostFromPooled(ManaGroup pooledMana)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup result = default(ManaGroup);
			((ManaGroup)(ref result)).Colorless = ((ManaGroup)(ref pooledMana)).Colorless;
			((ManaGroup)(ref result)).Philosophy = ((ManaGroup)(ref pooledMana)).Philosophy;
			return result;
		}

		[IteratorStateMachine(typeof(<Actions>d__6))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__6(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		public KijinSeijaXCost()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup colorlessMana = default(ManaGroup);
			((ManaGroup)(ref colorlessMana)).Colorless = 1;
			_colorlessMana = colorlessMana;
			base..ctor();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaAoeAttackDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: 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_0064: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)4 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Red = 1;
			((ManaGroup)(ref val)).Colorless = 1;
			((ManaGroup)(ref val)).Black = 1;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 4;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)2;
			defaultCardConfig.Damage = 2;
			defaultCardConfig.UpgradedDamage = 10;
			defaultCardConfig.ToolPlayableTimes = 9;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaAoeAttackDef))]
	public sealed class KijinSeijaAoeAttack : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaAoeAttack <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Card)<>4__this).AttackAction(selector, "银月之精");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((Card)<>4__this).Battle.Player, (IEnumerable<Unit>)((Card)<>4__this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)((Card)<>4__this).AdditionalDamage, false), "Instant", (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__4 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaAoeAttack <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		protected override int AdditionalDamage => (int)Math.Pow(2.0, 10 - ((Card)this).DeckCounter.Value);

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__4))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__4(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaMultiAttackDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.GunName = GunNameID.GetGunFromId(400);
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)4 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)1;
			defaultCardConfig.TargetType = (TargetType)1;
			defaultCardConfig.Damage = 1;
			defaultCardConfig.UpgradedDamage = 2;
			defaultCardConfig.ToolPlayableTimes = 8;
			defaultCardConfig.Value1 = 10;
			defaultCardConfig.UpgradedValue1 = 8;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaMultiAttackDef))]
	public sealed class KijinSeijaMultiAttack : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__7 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaMultiAttack <>4__this;

			private List<GunPair>.Enumerator <>s__1;

			private GunPair <gunPair>5__2;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = default(List<GunPair>.Enumerator);
				<gunPair>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						((Card)<>4__this).CardGuns = new Guns(<>4__this.GetGunName(2), ((Card)<>4__this).Value1 - 1, false);
						<>2__current = ((Card)<>4__this).AttackAction(selector, <>4__this.GetGunName(2));
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>s__1 = ((Card)<>4__this).CardGuns.GunPairs.GetEnumerator();
						<>1__state = -3;
						break;
					case 2:
						<>1__state = -3;
						<gunPair>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<gunPair>5__2 = <>s__1.Current;
						<>2__current = ((Card)<>4__this).AttackAction(selector, <gunPair>5__2);
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__1 = default(List<GunPair>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__1).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__7 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaMultiAttack <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__5 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		private string LastType { get; set; }

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__5))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__5(-2)
			{
				<>4__this = this
			};
		}

		private string GetGunName(int gunIndex)
		{
			string text = LastType + gunIndex;
			if (GunConfig.FromName(text) != null)
			{
				return text;
			}
			return "SingleJiandaoSe" + gunIndex;
		}

		[IteratorStateMachine(typeof(<Actions>d__7))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__7(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaConditionalDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 4;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 30;
			defaultCardConfig.UpgradedValue1 = 45;
			defaultCardConfig.Value2 = 24;
			defaultCardConfig.UpgradedValue2 = 32;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeEffects = new List<string> { "Reflect", "Grace" };
			defaultCardConfig.UpgradedRelativeEffects = new List<string> { "Reflect", "Grace" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaConditionalDef))]
	public sealed class KijinSeijaConditional : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaConditional <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Grace>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)((Card)<>4__this).Value1, (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((Card)<>4__this).PlayInTriggered)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Reflect>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)((Card)<>4__this).Value2, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__4 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaConditional <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override bool Triggered
		{
			get
			{
				IEnumerable<EnemyUnit> allAliveEnemies = ((Card)this).Battle.AllAliveEnemies;
				foreach (EnemyUnit item in allAliveEnemies)
				{
					if (item.Intentions.Any(delegate(Intention i)
					{
						if (!(i is AttackIntention))
						{
							SpellCardIntention val = (SpellCardIntention)(object)((i is SpellCardIntention) ? i : null);
							if (val == null || !val.Damage.HasValue)
							{
								return false;
							}
						}
						return true;
					}))
					{
						return true;
					}
				}
				return false;
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__4))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__4(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaCardGenerationDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0038: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Colorless = 2;
			defaultCardConfig.Cost = val;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 2;
			defaultCardConfig.UpgradedCost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.ToolPlayableTimes = 3;
			defaultCardConfig.Keywords = (Keyword)65536;
			defaultCardConfig.UpgradedKeywords = (Keyword)65536;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.RelativeCards = new List<string> { "KijinSeijaUnplayable" };
			defaultCardConfig.UpgradedRelativeCards = new List<string> { "KijinSeijaUnplayable" };
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaCardGenerationDef))]
	public sealed class KijinSeijaCardGeneration : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaCardGeneration <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<KijinSeijaUnplayable>(1, false), (AddCardsType)0, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaCardGeneration <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
	public sealed class KijinSeijaDiscoverDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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_0092: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 1;
			((ManaGroup)(ref val)).Colorless = 1;
			defaultCardConfig.Cost = val;
			defaultCardConfig.Rarity = (Rarity)1;
			defaultCardConfig.Type = (CardType)3;
			defaultCardConfig.TargetType = (TargetType)4;
			defaultCardConfig.Value1 = 4;
			defaultCardConfig.UpgradedValue1 = 7;
			defaultCardConfig.ToolPlayableTimes = 4;
			defaultCardConfig.Value2 = 1;
			val = default(ManaGroup);
			((ManaGroup)(ref val)).Any = 0;
			defaultCardConfig.Mana = val;
			defaultCardConfig.Keywords = (Keyword)196608;
			defaultCardConfig.UpgradedKeywords = (Keyword)327680;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaDiscoverDef))]
	public sealed class KijinSeijaDiscover : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaDiscover <>4__this;

			private Card[] <array>5__1;

			private MiniSelectCardInteraction <interaction>5__2;

			private Card <selectedCard>5__3;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<array>5__1 = null;
				<interaction>5__2 = null;
				<selectedCard>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Expected O, but got Unknown
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Expected O, but got Unknown
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Expected O, but got Unknown
				//IL_00d8: 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_0117: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<array>5__1 = ((Card)<>4__this).Battle.RollCardsWithoutManaLimit(new CardWeightTable(RarityWeightTable.BattleCard, OwnerWeightTable.Valid, CardTypeWeightTable.CanBeLoot, false), ((Card)<>4__this).Value1, (Predicate<CardConfig>)((CardConfig config) => config.Id != ((GameEntity)<>4__this).Id && ((Enum)config.Keywords).HasFlag((Enum)(object)(Keyword)256)));
					<interaction>5__2 = new MiniSelectCardInteraction((IEnumerable<Card>)<array>5__1, false, false, false)
					{
						Source = (GameEntity)(object)<>4__this
					};
					<>2__current = (BattleAction)new InteractionAction((Interaction)(object)<interaction>5__2, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<selectedCard>5__3 = <interaction>5__2.SelectedCard;
					<selectedCard>5__3.SetTurnCost(((Card)<>4__this).Mana);
					<selectedCard>5__3.IsEthereal = true;
					<selectedCard>5__3.IsExile = true;
					<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { <selectedCard>5__3 });
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__2 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <AfterUseAction>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaDiscover <>4__this;

			private Card <deckCardByInstanceId>5__1;

			private int? <num>5__2;

			private int? <num2>5__3;

			private int <num3>5__4;

			private IEnumerator<BattleAction> <>s__5;

			private BattleAction <ba>5__6;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AfterUseAction>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<deckCardByInstanceId>5__1 = null;
				<>s__5 = null;
				<ba>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<deckCardByInstanceId>5__1 = ((Card)<>4__this).Battle.GameRun.GetDeckCardByInstanceId(((Card)<>4__this).InstanceId);
						<num>5__2 = ((Card)<>4__this).DeckCounter - 1;
						((Card)<>4__this).DeckCounter = <num>5__2;
						<num2>5__3 = <num>5__2;
						<num3>5__4 = 0;
						if ((<num2>5__3.GetValueOrDefault() == <num3>5__4) & <num2>5__3.HasValue)
						{
							if (<deckCardByInstanceId>5__1 != null)
							{
								((Card)<>4__this).Battle.GameRun.RemoveDeckCard(<deckCardByInstanceId>5__1, false);
							}
							<>2__current = (BattleAction)new RemoveCardAction((Card)(object)<>4__this);
							<>1__state = 1;
							return true;
						}
						if (<deckCardByInstanceId>5__1 != null)
						{
							<deckCardByInstanceId>5__1.DeckCounter = ((Card)<>4__this).DeckCounter;
						}
						<>s__5 = <>4__this.<>n__0().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -1;
						return false;
					case 2:
						<>1__state = -3;
						<ba>5__6 = null;
						break;
					}
					if (<>s__5.MoveNext())
					{
						<ba>5__6 = <>s__5.Current;
						<>2__current = <ba>5__6;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__5 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<AfterUseAction>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <AfterUseAction>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override void Initialize()
		{
			//IL_004a: 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_009b: Invalid comparison between Unknown and I4
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			((Card)this).Initialize();
			((Card)this).Config = CardConfig.FromId(((GameEntity)this).Id);
			if (((Card)this).Config == null)
			{
				throw new InvalidDataException("Cannot find card config for <" + ((GameEntity)this).Id + ">");
			}
			((Card)this).Keywords = ((Card)this).Config.Keywords;
			if (!((Card)this).Config.IsXCost)
			{
				((Card)this).BaseCost = ((Card)this).ConfigCost;
				((Card)this).TurnCostDelta = ManaGroup.Empty;
			}
			((Card)this).DeckCounter = ((Card)this).ToolPlayableTimes;
			if ((int)((Card)this).CardType == 5)
			{
				((Card)this).Loyalty = ((Card)this).ConfigLoyalty;
			}
			if (((Card)this).PlentifulMana.HasValue)
			{
				((Card)this).IsPlentiful = true;
			}
		}

		[IteratorStateMachine(typeof(<AfterUseAction>d__1))]
		public override IEnumerable<BattleAction> AfterUseAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AfterUseAction>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__0()
		{
			return ((Card)this).AfterUseAction();
		}
	}
}
namespace KijinSeijaMod.Cards.Template
{
	public class KijinSeijaCard : Card
	{
		protected virtual int BaseValue3 { get; set; } = 0;


		protected virtual int BaseUpgradedValue3 { get; set; } = 0;


		public int Value3
		{
			get
			{
				if (((Card)this).IsUpgraded)
				{
					return BaseUpgradedValue3;
				}
				return BaseValue3;
			}
		}
	}
	public static class CardIndexGenerator
	{
		private static readonly List<ManaColor> offColors = BepinexPlugin.offColors;

		private static int? initial_offset = null;

		private static HashSet<int> uniqueIds = new HashSet<int>();

		public const int milx1 = 10000000;

		public static HashSet<int> UniqueIds
		{
			get
			{
				if (uniqueIds == null)
				{
					uniqueIds = new HashSet<int>();
				}
				return uniqueIds;
			}
		}

		public static int Initial_offset
		{
			get
			{
				if (!initial_offset.HasValue)
				{
					int num = 0;
					if (UniqueTracker.Instance.configIndexes.TryGetValue(typeof(CardConfig), out var value))
					{
						num = value.Where((int i) => i >= 10000000).DefaultIfEmpty().Max() / 10000000;
					}
					num++;
					initial_offset = num * 10000000;
				}
				return initial_offset.Value;
			}
		}

		internal static void PromiseClearIndexSet()
		{
			EntityManager.AddPostLoadAction((Action)delegate
			{
				uniqueIds = null;
			}, (Assembly)null);
		}

		public static int GetUniqueIndex(CardConfig config)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected I4, but got Unknown
			//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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			int num = Initial_offset;
			num += (config.Colors.Any((ManaColor x) => offColors.Any((ManaColor y) => y == x)) ? 1000000 : 0);
			num += ((!((Enum)config.Keywords).HasFlag((Enum)(object)(Keyword)1)) ? ((config.Rarity + 1) * 100000) : 0);
			int num2 = ((config.Colors.Count > 1) ? 9 : ((int)config.Colors[0]));
			num += num2 * 10000;
			int num3;
			if (!config.IsXCost && !((Enum)config.Keywords).HasFlag((Enum)(object)(Keyword)32768))
			{
				ManaGroup cost = config.Cost;
				if (((ManaGroup)(ref cost)).Total <= 9)
				{
					cost = config.Cost;
					num3 = ((ManaGroup)(ref cost)).Total;
					goto IL_00df;
				}
			}
			num3 = 9;
			goto IL_00df;
			IL_00df:
			int num4 = num3;
			num += num4 * 1000;
			num += config.Type * 100;
			if (UniqueTracker.Instance.configIndexes.TryGetValue(typeof(CardConfig), out var value))
			{
				for (; value.Contains(num); num++)
				{
				}
			}
			return num;
		}
	}
	public abstract class KijinSeijaCardTemplate : CardTemplate
	{
		public override IdContainer GetId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(KijinSeijaDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override CardImages LoadCardImages()
		{
			return KijinSeijaImageLoader.LoadCardImages((CardTemplate)(object)this);
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)KijinSeijaLocalization.CardsBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public CardConfig GetDefaultCardConfig()
		{
			return KijinSeijaDefaultConfig.DefaultCardConfig();
		}
	}
}
namespace KijinSeijaMod.Cards.B
{
	public sealed class KijinSeija99OSDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)4 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 1;
			((ManaGroup)(ref cost)).White = 1;
			((ManaGroup)(ref cost)).Red = 1;
			((ManaGroup)(ref cost)).Black = 1;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)5;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 3;
			defaultCardConfig.UpgradedValue1 = 2;
			defaultCardConfig.Loyalty = 1;
			defaultCardConfig.UpgradedLoyalty = 4;
			defaultCardConfig.PassiveCost = 1;
			defaultCardConfig.UpgradedPassiveCost = 1;
			defaultCardConfig.UltimateCost = -9;
			defaultCardConfig.UpgradedUltimateCost = -9;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeija99OSDef))]
	public sealed class KijinSeija99OS : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeija99OS <>4__this;

			private List<Card> <list2>5__1;

			private int <Value12>5__2;

			private List<Card> <list1>5__3;

			private IEnumerator<Card> <enumerator>5__4;

			private Card <card3>5__5;

			private IEnumerator<Card> <>s__6;

			private Card <card2>5__7;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<list2>5__1 = null;
				<list1>5__3 = null;
				<enumerator>5__4 = null;
				<card3>5__5 = null;
				<>s__6 = null;
				<card2>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).UltimateCost;
						((Card)<>4__this).UltimateUsed = true;
						<Value12>5__2 = 0;
						goto IL_01ea;
					case 1:
						<>1__state = -3;
						goto IL_01ac;
					case 2:
						{
							<>1__state = -1;
							<list2>5__1 = null;
							return false;
						}
						IL_01ea:
						if (<Value12>5__2 < 12)
						{
							<list1>5__3 = ((GameEntity)<>4__this).GameRun.BaseDeck.Where((Card card) => card.CanUpgradeAndPositive).ToList();
							if (<list1>5__3.Count > 0)
							{
								<card3>5__5 = CollectionsExtensions.Sample<Card>((IEnumerable<Card>)<list1>5__3, ((GameEntity)<>4__this).GameRun.GameRunEventRng);
								((GameEntity)<>4__this).GameRun.UpgradeDeckCard(<card3>5__5, false);
								<>s__6 = ((Card)<>4__this).Battle.EnumerateAllCards().GetEnumerator();
								<>1__state = -3;
								while (<>s__6.MoveNext())
								{
									<card2>5__7 = <>s__6.Current;
									if (<card2>5__7.InstanceId == <card3>5__5.InstanceId)
									{
										if (<card2>5__7.CanUpgrade)
										{
											<>2__current = (BattleAction)new UpgradeCardAction(<card2>5__7);
											<>1__state = 1;
											return true;
										}
										break;
									}
									<card2>5__7 = null;
								}
								goto IL_01ac;
							}
							goto IL_01c2;
						}
						<list2>5__1 = ((GameEntity)<>4__this).GameRun.BaseDeck.Where((Card card) => (int)card.CardType == 5).ToList();
						if (<list2>5__1.Count > 0)
						{
							((GameEntity)<>4__this).GameRun.RemoveDeckCards(((GameEntity)<>4__this).GameRun.BaseDeckWithoutUnremovable.Where((Card c) => (int)c.CardType == 5), true);
						}
						<>2__current = (BattleAction)(object)((Card)<>4__this).SkillAnime;
						<>1__state = 2;
						return true;
						IL_01ac:
						<>m__Finally1();
						<>s__6 = null;
						<card3>5__5 = null;
						goto IL_01c2;
						IL_01c2:
						<enumerator>5__4 = null;
						<list1>5__3 = null;
						<enumerator>5__4 = null;
						<Value12>5__2++;
						goto IL_01ea;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__6 != null)
				{
					<>s__6.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetPassiveActions>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeija99OS <>4__this;

			private int <num>5__1;

			private Unit <player>5__2;

			private int <i>5__3;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetPassiveActions>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<player>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((Card)<>4__this).Summoned || ((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).PassiveCost;
					<player>5__2 = (Unit)(object)((Card)<>4__this).Battle.Player;
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<TempSpirit>(<player>5__2, (int?)(((Card)<>4__this).Battle.DiscardZone.Count / 5), (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<num>5__1 = <i>5__3;
					<i>5__3 = <num>5__1 + 1;
					break;
				}
				if (<i>5__3 < ((Card)<>4__this).Battle.FriendPassiveTimes)
				{
					if (((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<TempFirepower>(<player>5__2, (int?)(((Card)<>4__this).Battle.DrawZone.Count / 5), (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<GetPassiveActions>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetPassiveActions>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <SummonActions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeija99OS <>4__this;

			private IEnumerator<BattleAction> <>s__1;

			private BattleAction <battleAction>5__2;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SummonActions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<battleAction>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>s__1 = <>4__this.<>n__1(selector, consumingMana, precondition).GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<battleAction>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<battleAction>5__2 = <>s__1.Current;
						<>2__current = <battleAction>5__2;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<SummonActions>d__2 <SummonActions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SummonActions>d__ = this;
				}
				else
				{
					<SummonActions>d__ = new <SummonActions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<SummonActions>d__.selector = <>3__selector;
				<SummonActions>d__.consumingMana = <>3__consumingMana;
				<SummonActions>d__.precondition = <>3__precondition;
				return <SummonActions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override IEnumerable<BattleAction> OnTurnStartedInHand()
		{
			return ((Card)this).GetPassiveActions();
		}

		[IteratorStateMachine(typeof(<GetPassiveActions>d__1))]
		public override IEnumerable<BattleAction> GetPassiveActions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetPassiveActions>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SummonActions>d__2))]
		protected override IEnumerable<BattleAction> SummonActions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SummonActions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Card)this).NotifyActivating();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__1(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ((Card)this).SummonActions(selector, consumingMana, precondition);
		}
	}
	public sealed class KijinSeija99SDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)3 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 1;
			((ManaGroup)(ref cost)).White = 1;
			((ManaGroup)(ref cost)).Red = 1;
			((ManaGroup)(ref cost)).Black = 1;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)5;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 3;
			defaultCardConfig.UpgradedValue1 = 2;
			defaultCardConfig.Loyalty = 1;
			defaultCardConfig.UpgradedLoyalty = 4;
			defaultCardConfig.PassiveCost = 1;
			defaultCardConfig.UpgradedPassiveCost = 1;
			defaultCardConfig.UltimateCost = -9;
			defaultCardConfig.UpgradedUltimateCost = -9;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeija99SDef))]
	public sealed class KijinSeija99S : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeija99S <>4__this;

			private SelectCardInteraction <selectCardInteraction>5__1;

			private Card <card1>5__2;

			private List<Card> <list2>5__3;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<selectCardInteraction>5__1 = null;
				<card1>5__2 = null;
				<list2>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).UltimateCost;
					((Card)<>4__this).UltimateUsed = true;
					<selectCardInteraction>5__1 = (SelectCardInteraction)precondition;
					<card1>5__2 = ((<selectCardInteraction>5__1 != null) ? <selectCardInteraction>5__1.SelectedCards.FirstOrDefault() : null);
					if (<card1>5__2 != null)
					{
						((GameEntity)<>4__this).GameRun.RemoveDeckCard(<card1>5__2, true);
					}
					<list2>5__3 = ((GameEntity)<>4__this).GameRun.BaseDeck.Where((Card card) => (int)card.CardType == 5).ToList();
					if (<list2>5__3.Count > 0)
					{
						((GameEntity)<>4__this).GameRun.RemoveDeckCards(((GameEntity)<>4__this).GameRun.BaseDeckWithoutUnremovable.Where((Card c) => (int)c.CardType == 5), true);
					}
					<>2__current = (BattleAction)(object)((Card)<>4__this).SkillAnime;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__4 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetPassiveActions>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeija99S <>4__this;

			private int <num>5__1;

			private Unit <player>5__2;

			private int <i>5__3;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetPassiveActions>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<player>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((Card)<>4__this).Summoned || ((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).PassiveCost;
					<player>5__2 = (Unit)(object)((Card)<>4__this).Battle.Player;
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					goto IL_0163;
				case 2:
					{
						<>1__state = -1;
						goto IL_0163;
					}
					IL_0163:
					<num>5__1 = <i>5__3;
					<i>5__3 = <num>5__1 + 1;
					break;
				}
				if (<i>5__3 < ((Card)<>4__this).Battle.FriendPassiveTimes)
				{
					if (((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					if (<player>5__2.Hp > <player>5__2.MaxHp / 2)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>(<player>5__2, (int?)1, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Spirit>(<player>5__2, (int?)1, (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 2;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<GetPassiveActions>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetPassiveActions>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <SummonActions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeija99S <>4__this;

			private IEnumerator<BattleAction> <>s__1;

			private BattleAction <battleAction>5__2;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SummonActions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<battleAction>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>s__1 = <>4__this.<>n__1(selector, consumingMana, precondition).GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<battleAction>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<battleAction>5__2 = <>s__1.Current;
						<>2__current = <battleAction>5__2;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<SummonActions>d__2 <SummonActions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SummonActions>d__ = this;
				}
				else
				{
					<SummonActions>d__ = new <SummonActions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<SummonActions>d__.selector = <>3__selector;
				<SummonActions>d__.consumingMana = <>3__consumingMana;
				<SummonActions>d__.precondition = <>3__precondition;
				return <SummonActions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override IEnumerable<BattleAction> OnTurnStartedInHand()
		{
			return ((Card)this).GetPassiveActions();
		}

		[IteratorStateMachine(typeof(<GetPassiveActions>d__1))]
		public override IEnumerable<BattleAction> GetPassiveActions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetPassiveActions>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SummonActions>d__2))]
		protected override IEnumerable<BattleAction> SummonActions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SummonActions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		public override Interaction Precondition()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (((Card)this).UltimateUsed)
			{
				List<Card> list = ((GameEntity)this).GameRun.BaseDeckWithoutUnremovable.ToList();
				Card deckCardByInstanceId = ((GameEntity)this).GameRun.GetDeckCardByInstanceId(((Card)this).InstanceId);
				if (deckCardByInstanceId != null)
				{
					list.Remove(deckCardByInstanceId);
				}
				if (list.Count <= 0)
				{
					return null;
				}
				return (Interaction)new SelectCardInteraction(0, 10, (IEnumerable<Card>)list, (SelectedCardHandling)0);
			}
			return null;
		}

		[IteratorStateMachine(typeof(<Actions>d__4))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__4(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Card)this).NotifyActivating();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__1(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ((Card)this).SummonActions(selector, consumingMana, precondition);
		}
	}
	public sealed class KijinSeijaTeammateDef : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)4 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 2;
			((ManaGroup)(ref cost)).Red = 1;
			((ManaGroup)(ref cost)).Black = 1;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)5;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Loyalty = 4;
			defaultCardConfig.UpgradedLoyalty = 7;
			defaultCardConfig.PassiveCost = 1;
			defaultCardConfig.UpgradedPassiveCost = 1;
			defaultCardConfig.ActiveCost = -9;
			defaultCardConfig.UpgradedActiveCost = -9;
			defaultCardConfig.UltimateCost = -9;
			defaultCardConfig.UpgradedUltimateCost = -9;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaTeammateDef))]
	public sealed class KijinSeijaTeammate : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaTeammate <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <enemy>5__2;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 3u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0090: 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_00a0: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>s__1 = ((Card)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<>2__current = (BattleAction)(object)((Card)<>4__this).SkillAnime;
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -3;
						goto IL_01e4;
					case 3:
						<>1__state = -3;
						<>2__current = (BattleAction)(object)((Card)<>4__this).SkillAnime;
						<>1__state = 4;
						return true;
					case 4:
						{
							<>1__state = -3;
							goto IL_01e4;
						}
						IL_01e4:
						<enemy>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<enemy>5__2 = (Unit)(object)<>s__1.Current;
						if (precondition == null || (int)((MiniSelectCardInteraction)precondition).SelectedCard.FriendToken == 1)
						{
							((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).ActiveCost;
							<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<KijinSeijaFriendS1>(<enemy>5__2, (int?)1, (int?)1, (int?)0, (int?)0, 0f, true);
							<>1__state = 1;
							return true;
						}
						((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).UltimateCost;
						((Card)<>4__this).UltimateUsed = true;
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<KijinSeijaFriendS2>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)1, (int?)1, (int?)0, (int?)0, 0f, true);
						<>1__state = 3;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetPassiveActions>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaTeammate <>4__this;

			private int <num>5__1;

			private Unit <player>5__2;

			private int <i>5__3;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetPassiveActions>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<player>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((Card)<>4__this).Summoned || ((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).PassiveCost;
					<player>5__2 = (Unit)(object)((Card)<>4__this).Battle.Player;
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<num>5__1 = <i>5__3;
					<i>5__3 = <num>5__1 + 1;
					break;
				}
				if (<i>5__3 < ((Card)<>4__this).Battle.FriendPassiveTimes)
				{
					if (((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Grace>(<player>5__2, (int?)(<player>5__2.MaxHp / 5), (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<GetPassiveActions>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetPassiveActions>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <SummonActions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaTeammate <>4__this;

			private IEnumerator<BattleAction> <>s__1;

			private BattleAction <battleAction>5__2;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SummonActions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<battleAction>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>s__1 = <>4__this.<>n__1(selector, consumingMana, precondition).GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<battleAction>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<battleAction>5__2 = <>s__1.Current;
						<>2__current = <battleAction>5__2;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<SummonActions>d__2 <SummonActions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SummonActions>d__ = this;
				}
				else
				{
					<SummonActions>d__ = new <SummonActions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<SummonActions>d__.selector = <>3__selector;
				<SummonActions>d__.consumingMana = <>3__consumingMana;
				<SummonActions>d__.precondition = <>3__precondition;
				return <SummonActions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override IEnumerable<BattleAction> OnTurnStartedInHand()
		{
			return ((Card)this).GetPassiveActions();
		}

		[IteratorStateMachine(typeof(<GetPassiveActions>d__1))]
		public override IEnumerable<BattleAction> GetPassiveActions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetPassiveActions>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SummonActions>d__2))]
		protected override IEnumerable<BattleAction> SummonActions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SummonActions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Card)this).NotifyActivating();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__1(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ((Card)this).SummonActions(selector, consumingMana, precondition);
		}
	}
	public sealed class KijinSeijaTeammate2Def : KijinSeijaCardTemplate
	{
		public override CardConfig MakeConfig()
		{
			//IL_001f: 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)
			CardConfig defaultCardConfig = GetDefaultCardConfig();
			defaultCardConfig.Colors = new List<ManaColor> { (ManaColor)2 };
			ManaGroup cost = default(ManaGroup);
			((ManaGroup)(ref cost)).Colorless = 2;
			((ManaGroup)(ref cost)).Blue = 1;
			defaultCardConfig.Cost = cost;
			defaultCardConfig.Rarity = (Rarity)2;
			defaultCardConfig.Type = (CardType)5;
			defaultCardConfig.TargetType = (TargetType)0;
			defaultCardConfig.Value1 = 3;
			defaultCardConfig.UpgradedValue1 = 2;
			defaultCardConfig.Value2 = 7;
			defaultCardConfig.UpgradedValue2 = 5;
			defaultCardConfig.Loyalty = 4;
			defaultCardConfig.UpgradedLoyalty = 4;
			defaultCardConfig.PassiveCost = 1;
			defaultCardConfig.UpgradedPassiveCost = 2;
			defaultCardConfig.UltimateCost = -8;
			defaultCardConfig.UpgradedUltimateCost = -8;
			defaultCardConfig.Illustrator = "";
			defaultCardConfig.Index = CardIndexGenerator.GetUniqueIndex(defaultCardConfig);
			return defaultCardConfig;
		}
	}
	[EntityLogic(typeof(KijinSeijaTeammate2Def))]
	public sealed class KijinSeijaTeammate2 : KijinSeijaCard
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaTeammate2 <>4__this;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Actions>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).UltimateCost;
					((Card)<>4__this).UltimateUsed = true;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<KijinSeijaFriedS3>((Unit)(object)((Card)<>4__this).Battle.Player, (int?)1, (int?)0, (int?)0, (int?)0, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)((Card)<>4__this).SkillAnime;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<Actions>d__3 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				<Actions>d__.consumingMana = <>3__consumingMana;
				<Actions>d__.precondition = <>3__precondition;
				return <Actions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetPassiveActions>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public KijinSeijaTeammate2 <>4__this;

			private int <num>5__1;

			private Unit <player>5__2;

			private int <i>5__3;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetPassiveActions>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<player>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((Card)<>4__this).Summoned || ((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					((Card)<>4__this).Loyalty = ((Card)<>4__this).Loyalty + ((Card)<>4__this).PassiveCost;
					<player>5__2 = (Unit)(object)((Card)<>4__this).Battle.Player;
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>(<player>5__2, (int?)((Card)<>4__this).Value1, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Poison>(<player>5__2, (int?)((Card)<>4__this).Value2, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<num>5__1 = <i>5__3;
					<i>5__3 = <num>5__1 + 1;
					break;
				}
				if (<i>5__3 < ((Card)<>4__this).Battle.FriendPassiveTimes)
				{
					if (((Card)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>2__current = (BattleAction)new HealAction((Unit)(object)((Card)<>4__this).Battle.Player, (Unit)(object)((Card)<>4__this).Battle.Player, 3, (HealType)0, 0.2f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<GetPassiveActions>d__1 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetPassiveActions>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <SummonActions>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			private ManaGroup consumingMana;

			public ManaGroup <>3__consumingMana;

			private Interaction precondition;

			public Interaction <>3__precondition;

			public KijinSeijaTeammate2 <>4__this;

			private IEnumerator<BattleAction> <>s__1;

			private BattleAction <battleAction>5__2;

			BattleAction IEnumerator<BattleAction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SummonActions>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<battleAction>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>s__1 = <>4__this.<>n__1(selector, consumingMana, precondition).GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<battleAction>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<battleAction>5__2 = <>s__1.Current;
						<>2__current = <battleAction>5__2;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__1 != null)
				{
					<>s__1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				<SummonActions>d__2 <SummonActions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SummonActions>d__ = this;
				}
				else
				{
					<SummonActions>d__ = new <SummonActions>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<SummonActions>d__.selector = <>3__selector;
				<SummonActions>d__.consumingMana = <>3__consumingMana;
				<SummonActions>d__.precondition = <>3__precondition;
				return <SummonActions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<BattleAction>)this).GetEnumerator();
			}
		}

		public override IEnumerable<BattleAction> OnTurnStartedInHand()
		{
			return ((Card)this).GetPassiveActions();
		}

		[IteratorStateMachine(typeof(<GetPassiveActions>d__1))]
		public override IEnumerable<BattleAction> GetPassiveActions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetPassiveActions>d__1(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SummonActions>d__2))]
		protected override IEnumerable<BattleAction> SummonActions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SummonActions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector,
				<>3__consumingMana = consumingMana,
				<>3__precondition = precondition
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Card)this).NotifyActivating();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<BattleAction> <>n__1(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ((Card)this).SummonActions(selector, consumingMana, precondition);
		}
	}
}
namespace KijinSeijaMod.BattleActions
{
	public class BuffAttackEventArgs : GameEventArgs
	{
		public Card Card { get; internal set; }

		public int Amount { get; internal set; }

		protected override string GetBaseDebugString()
		{
			return "BuffAttack: " + Amount;
		}
	}
}
namespace KijinSeijaMod.Patches
{
	public static class CustomEventTextManager
	{
		public static Dictionary<string, Dictionary<string, string>> MasterTextDict = new Dictionary<string, Dictionary<string, string>>();

		public static bool IsLoaded = false;

		public static void LoadAllCustomYamls()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (IsLoaded)
			{
				return;
			}
			IsLoaded = true;
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			string path = Path.Combine(directoryName, "DirResources");
			if (!Directory.Exists(path))
			{
				return;
			}
			string[] files = Directory.GetFiles(path, "KijinSeija_*.yaml", SearchOption.AllDirectories);
			IDeserializer val = new DeserializerBuilder().IgnoreUnmatchedProperties().Build();
			string[] array = files;
			foreach (string text in array)
			{
				try
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
					string[] array2 = fileNameWithoutExtension.Split(new char[1] { '_' });
					string text2 = ((array2.Length > 1) ? array2[1] : "Unknown");
					string name = new DirectoryInfo(Path.GetDirectoryName(text)).Name;
					string text3 = "ZhHans";
					switch (name)
					{
					case "en":
						text3 = "En";
						break;
					case "ja":
						text3 = "Ja";
						break;
					case "ko":
						text3 = "Ko";
						break;
					case "zh-Hans":
						text3 = "ZhHans";
						break;
					default:
						if (array2.Length > 2)
						{
							text3 = array2[2];
						}
						break;
					}
					if (!MasterTextDict.ContainsKey(text3))
					{
						MasterTextDict[text3] = new Dictionary<string, string>();
					}
					string text4 = File.ReadAllText(text);
					Dictionary<string, string> dictionary = val.Deserialize<Dictionary<string, string>>(text4);
					if (dictionary == null)
					{
						continue;
					}
					Debug.Log((object)$"[KijinSeija_XRay_Load] 成功加载文件: {fileNameWithoutExtension}, 识别文件夹为: {name}, 划入语言包: {text3}, 共读取到词条: {dictionary.Count} 个");
					foreach (KeyValuePair<string, string> item in dictionary)
					{
						string text5 = item.Key.Replace("\ufeff", "").Trim();
						switch (text5)
						{
						default:
							if (!(text5 == "NPC"))
							{
								MasterTextDict[text3][text5] = item.Value;
								break;
							}
							goto case "Title";
						case "Title":
						case "HostName":
						case "TargetTitle":
						case "TargetNPC":
							MasterTextDict[text3][text5 + "_" + text2] = item.Value;
							break;
						}
					}
				}
				catch (Exception ex)
				{
					Debug.LogError((object)("[KijinSeija_XRay_Error] 文件读取失败: " + text + " 报错: " + ex.Message));
				}
			}
		}

		public static string DetectLanguageFromVanillaDict(IDictionary<string, string> dict)
		{
			if (dict == null || dict.Count == 0)
			{
				return "ZhHans";
			}
			int num = 0;
			int num2 = 0;
			foreach (string value in dict.Values)
			{
				if (!string.IsNullOrWhiteSpace(value))
				{
					if (Regex.IsMatch(value, "[\\uac00-\\ud7a3]"))
					{
						return "Ko";
					}
					if (Regex.IsMatch(value, "[\\u3040-\\u30ff]"))
					{
						return "Ja";
					}
					if (Regex.IsMatch(value, "[\\u4e00-\\u9fa5]"))
					{
						num++;
					}
					else
					{
						num2++;
					}
				}
			}
			string text = ((num > 0 && num >= num2 / 5) ? "ZhHans" : "En");
			Debug.Log((object)$"[KijinSeija_XRay_Detect] 语言嗅探 -> 中文条目数:{num}, 外文条目数:{num2} ===> 最终裁定当前游戏语言为: {text}");
			return text;
		}
	}
	[HarmonyPatch(typeof(DialogRunner), "LocalizeLine")]
	public class OverrideDialogLinePatch
	{
		private static readonly FieldInfo stringTableField = AccessTools.Field(typeof(DialogRunner), "_stringTable");

		private static bool _hasDiagnosed = false;

		private static void Prefix(DialogRunner __instance, string lineId)
		{
			if (!SeijaRunTracker.IsSeijaRun)
			{
				return;
			}
			CustomEventTextManager.LoadAllCustomYamls();
			string text = lineId.Replace("\ufeff", "").Replace("\r", "").Replace("\n", "")
				.Trim();
			IDictionary<string, string> dictionary = (IDictionary<string, string>)stringTableField.GetValue(__instance);
			if (dictionary != null)
			{
				string text2 = CustomEventTextManager.DetectLanguageFromVanillaDict(dictionary);
				if (!_hasDiagnosed)
				{
					Debug.Log((object)$"[KijinSeija_XRay_Patch] 拦截到对话请求！系统需要语言: {text2}。 我们的字典里有这个语言包吗？ => {CustomEventTextManager.MasterTextDict.ContainsKey(text2)}");
					_hasDiagnosed = true;
				}
				if (CustomEventTextManager.MasterTextDict.ContainsKey(text2))
				{
					if (CustomEventTextManager.MasterTextDict[text2].TryGetValue(text, out var value))
					{
						dictionary[lineId] = value;
					}
					else
					{
						Debug.LogWarning((object)("[KijinSeija_XRay_Miss] 漏网之鱼：游戏请求翻译 Key [" + text + "]，但在我们的 " + text2 + " 字典里找不到！"));
					}
				}
			}
			TextReplaceMonitor.EnsureRunning();
		}
	}
	public class TextReplaceMonitor : MonoBehaviour
	{
		public static void EnsureRunning()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (SeijaRunTracker.IsSeijaRun)
			{
				TextReplaceMonitor textReplaceMonitor = Object.FindObjectOfType<TextReplaceMonitor>();
				if ((Object)(object)textReplaceMonitor == (Object)null)
				{
					GameObject val = new GameObject("KijinSeija_TextMonitor_Immortal");
					Object.DontDestroyOnLoad((Object)(object)val);
					textReplaceMonitor = val.AddComponent<TextReplaceMonitor>();
				}
			}
		}

		[Obsolete]
		private void Update()
		{
			if (!SeijaRunTracker.IsSeijaRun || !CustomEventTextManager.IsLoaded)
			{
				return;
			}
			GameRunController currentRun = SeijaRunTracker.CurrentRun;
			if (currentRun == null)
			{
				return;
			}
			Station currentStation = currentRun.CurrentStation;
			AdventureStation val = (AdventureStation)(object)((currentStation is AdventureStation) ? currentStation : null);
			if (val == null)
			{
				return;
			}
			string id = val.Adventure.Id;
			string text = null;
			string value = null;
			string text2 = null;
			string value2 = null;
			foreach (Dictionary<string, string> value5 in CustomEventTextManager.MasterTextDict.Values)
			{
				if (value5.TryGetValue("TargetTitle_" + id, out var value3))
				{
					text = value3;
					value5.TryGetValue("Title_" + id, out value);
				}
				if (value5.TryGetValue("TargetNPC_" + id, out var value4))
				{
					text2 = value4;
					if (!value5.TryGetValue("NPC_" + id, out value2))
					{
						value5.TryGetValue("HostName_" + id, out value2);
					}
				}
			}
			string text3 = text?.Trim();
			string text4 = text2?.Trim();
			string text5 = value?.Trim();
			string text6 = value2?.Trim();
			TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val2 in array)
			{
				if (!string.IsNullOrWhiteSpace(((TMP_Text)val2).text))
				{
					string text7 = Regex.Replace(((TMP_Text)val2).text, "<.*?>", string.Empty).Replace("\ufeff", "").Trim();
					if (!string.IsNullOrEmpty(text3) && !string.IsNullOrEmpty(text5) && text7 == text3)
					{
						((TMP_Text)val2).text = ((TMP_Text)val2).text.Replace(text3, text5);
					}
					if (!string.IsNullOrEmpty(text4) && !string.IsNullOrEmpty(text6) && text7 == text4)
					{
						((TMP_Text)val2).text = ((TMP_Text)val2).text.Replace(text4, text6);
					}
				}
			}
		}
	}
	[HarmonyPatch]
	internal class CustomGameEventManager
	{
		public static GameEvent<BuffAttackEventArgs> PreCustomEvent { get; set; }

		public static GameEvent<BuffAttackEventArgs> PostCustomEvent { get; set; }

		[HarmonyPatch(typeof(GameRunController), "EnterBattle")]
		private static bool Prefix(GameRunController __instance)
		{
			PreCustomEvent = new GameEvent<BuffAttackEventArgs>();
			PostCustomEvent = new GameEvent<BuffAttackEventArgs>();
			return true;
		}
	}
	[HarmonyPatch(typeof(Stage), "CreateStation")]
	public class ReplaceFinalBossPatch
	{
		private static void Postfix(Stage __instance, MapNode node, ref Station __result)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if (__instance.Level != 4 || !(((GameEntity)((GameEntity)__instance).GameRun.Player).Id == BepinexPlugin.modUniqueID) || (int)node.StationType != 10)
			{
				return;
			}
			Station obj = __result;
			BattleStation val = (BattleStation)(object)((obj is BattleStation) ? obj : null);
			if (val != null)
			{
				EnemyGroupEntry val2 = Library.TryGetEnemyGroupEntry("KijinSeijaSagume");
				if (val2 != null)
				{
					val.EnemyGroupEntry = val2;
				}
			}
		}
	}
	public static class SeijaRunTracker
	{
		public static bool IsSeijaRun;

		public static GameRunController CurrentRun;
	}
	[HarmonyPatch(typeof(GameRunController), "Create")]
	public class TrackerCreatePatch
	{
		private static void Postfix(GameRunController __result)
		{
			object obj;
			if (__result == null)
			{
				obj = null;
			}
			else
			{
				PlayerUnit player = __result.Player;
				obj = ((player != null) ? ((GameEntity)player).Id : null);
			}
			SeijaRunTracker.IsSeijaRun = (string?)obj == BepinexPlugin.modUniqueID;
			SeijaRunTracker.CurrentRun = __result;
		}
	}
	[HarmonyPatch(typeof(GameRunController), "Restore")]
	public class TrackerRestorePatch
	{
		private static void Postfix(GameRunController __result)
		{
			object obj;
			if (__result == null)
			{
				obj = null;
			}
			else
			{
				PlayerUnit player = __result.Player;
				obj = ((player != null) ? ((GameEntity)player).Id : null);
			}
			SeijaRunTracker.IsSeijaRun = (string?)obj == BepinexPlugin.modUniqueID;
			SeijaRunTracker.CurrentRun = __result;
		}
	}
	[HarmonyPatch(typeof(UnitModelConfig), "FromName")]
	public class EraseEirinPatch
	{
		private static void Prefix(ref string Name)
		{
			if (Name == "Eirin" && SeijaRunTracker.IsSeijaRun)
			{
				Name = "ThisModelNameDoesNotExist_Null";
			}
		}
	}
	public class ShinmyoumaruDebutHandler : MonoBehaviour
	{
		public GameRunController gameRun;

		private GameObject canvasObj;

		private void Update()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			if (gameRun == null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Station currentStation = gameRun.CurrentStation;
			AdventureStation val = (AdventureStation)(object)((currentStation is AdventureStation) ? currentStation : null);
			bool flag = val != null && val.Adventure.Id == "Debut";
			if (flag && (Object)(object)canvasObj == (Object)null)
			{
				canvasObj = new GameObject("Shinmyoumaru_TopCanvas");
				Object.DontDestroyOnLoad((Object)(object)canvasObj);
				Canvas val2 = canvasObj.AddComponent<Canvas>();
				val2.renderMode = (RenderMode)0;
				val2.sortingOrder = 32767;
				CanvasScaler val3 = canvasObj.AddComponent<CanvasScaler>();
				val3.uiScaleMode = (ScaleMode)1;
				val3.referenceResolution = new Vector2(1920f, 1080f);
				GameObject val4 = new GameObject("Shinmyoumaru_Image");
				val4.transform.SetParent(canvasObj.transform, false);
				Image val5 = val4.AddComponent<Image>();
				val5.sprite = ResourceLoader.LoadSprite("KijinSeijaShinmyoumaru.png", (IResourceSource)(object)BepinexPlugin.directorySource, (Rect?)null, 84, (Vector2?)null);
				((Graphic)val5).SetNativeSize();
				RectTransform component = val4.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0.6f, 0.5f);
				component.anchorMax = new Vector2(0.6f, 0.5f);
				component.pivot = new Vector2(0.5f, 0.5f);
				component.anchoredPosition = Vector2.zero;
				((Transform)component).localScale = new Vector3(-1f, 1f, 1f);
			}
			else if (!flag && (Object)(object)canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)canvasObj);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else if (gameRun.CurrentStage != null && gameRun.CurrentStage.Level > 1)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	internal static class IsExternalInit
	{
	}
}