using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AddWatermark;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using HarmonyLib;
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.Randoms;
using LBoL.Core.Stations;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards;
using LBoL.EntityLib.Cards.Character.Cirno;
using LBoL.EntityLib.Cards.Character.Reimu;
using LBoL.EntityLib.Cards.Enemy;
using LBoL.EntityLib.Cards.Neutral.NoColor;
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.Presentation;
using LBoL.Presentation.UI;
using LBoL.Presentation.UI.Widgets;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.CustomHandlers;
using LBoLEntitySideloader.CustomKeywords;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using TMPro;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using UnityEngine.UI;
using YuukaMod.Assets;
using YuukaMod.BattleActions;
using YuukaMod.Cards;
using YuukaMod.Cards.Template;
using YuukaMod.Config;
using YuukaMod.Enemies;
using YuukaMod.Enemies.Template;
using YuukaMod.GunName;
using YuukaMod.ImageLoader;
using YuukaMod.Keywords;
using YuukaMod.Localization;
using YuukaMod.Logic;
using YuukaMod.Patches;
using YuukaMod.Source.Keywords;
using YuukaMod.StatusEffects;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("LBoL.Base")]
[assembly: IgnoresAccessChecksTo("LBoL.ConfigData")]
[assembly: IgnoresAccessChecksTo("LBoL.Core")]
[assembly: IgnoresAccessChecksTo("LBoL.EntityLib")]
[assembly: IgnoresAccessChecksTo("LBoL.Presentation")]
[assembly: IgnoresAccessChecksTo("Untitled.ConfigDataBuilder.Base")]
[assembly: AssemblyCompany("YuukaMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+fa294bc9c145afadde855780a1d227a7030b1393")]
[assembly: AssemblyProduct("YuukaMod")]
[assembly: AssemblyTitle("YuukaMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace YuukaMod
{
	[BepInPlugin("Vengyre.LBoL.Character.Yuuka", "YuukaMod", "0.6.5")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static string modUniqueID = "YuukaMod";

		public static string playerName = "Yuuka";

		public static bool useInGameModel = false;

		public static string modelName = "Youmu";

		public static bool modelIsFlipped = true;

		public static List<ManaColor> offColors = new List<ManaColor>
		{
			(ManaColor)1,
			(ManaColor)2,
			(ManaColor)3,
			(ManaColor)6
		};

		public static ConfigEntry<bool> enableAct1Boss;

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

		public static ConfigEntry<int> gardenJadeboxReplacementChance;

		public static CustomConfigEntry<int> gardenJadeboxReplacementChanceEntry = new CustomConfigEntry<int>(100, "Jadeboxes", "GardenOfDreamsReplacementChance", "Chance (0-100) that the 'Garden of All Dreams' Jadebox replaces non-tool Uncommon and Rare card rewards. Default: 100 (always).");

		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

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

		internal static DirectorySource directorySource = new DirectorySource("Vengyre.LBoL.Character.Yuuka", "");

		internal static BatchLocalization jadeboxLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(JadeBoxTemplate), "Jadeboxes", (Locale)0, false);

		private void Awake()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			log = ((BaseUnityPlugin)this).Logger;
			enableAct1Boss = ((BaseUnityPlugin)this).Config.Bind<bool>(enableAct1BossEntry.Section, enableAct1BossEntry.Key, enableAct1BossEntry.Value, enableAct1BossEntry.Description);
			gardenJadeboxReplacementChance = ((BaseUnityPlugin)this).Config.Bind<int>(gardenJadeboxReplacementChanceEntry.Section, gardenJadeboxReplacementChanceEntry.Key, gardenJadeboxReplacementChanceEntry.Value, new ConfigDescription(gardenJadeboxReplacementChanceEntry.Description, (AcceptableValueBase)null, Array.Empty<object>()));
			ModAssetManager.LoadAssets();
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			CardIndexGenerator.PromiseClearIndexSet();
			EntityManager.RegisterSelf();
			harmony.PatchAll();
			if (Chainloader.PluginInfos.ContainsKey("neo.lbol.tools.watermark"))
			{
				WatermarkWrapper.ActivateWatermark();
			}
			Func<Sprite> func = () => ResourceLoader.LoadSprite("BossIcon.png", (IResourceSource)(object)directorySource, (Rect?)null, 1, (Vector2?)null);
			if (enableAct1Boss.Value)
			{
				EnemyUnitTemplate.AddBossNodeIcon(modUniqueID, func, (Assembly)null);
				log.LogInfo((object)"Yuuka boss enabled!");
			}
			YuukaCharacterArrangedHandle.RegisterHandlers();
			YuukaSecondCardTracker.RegisterHandlers();
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "Vengyre.LBoL.Character.Yuuka";

		public const string Name = "YuukaMod";

		public const string version = "0.6.5";

		public static readonly Harmony harmony = new Harmony("Vengyre.LBoL.Character.Yuuka");
	}
	public static class YuukaGardenArchitectConfig
	{
		public static int Option1FlowerToBonus = 3;

		public static int Option1GrowBonus = 2;

		public static int Option2FlowerBonus = 10;

		public static int Option3BloomToBonus = 3;

		public static int Option3FirepowerBonus = 1;
	}
	public static class YuukaSeasonsConfig
	{
		public static int BloomValue = 4;

		public static int GrowValue = 1;

		public static int SummerFlowerValue = 9;

		public static int FervorValue = 25;

		public static int BarrierValue = 5;
	}
	public class YuukaLoadouts
	{
		public static string UltimateSkillA = "YuukaUltA";

		public static string UltimateSkillB = "YuukaUltB";

		public static string ExhibitA = "YuukaExhibitA";

		public static string ExhibitB = "YuukaExhibitB";

		public static List<string> DeckA = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YuukaCharacterBaseAttackG", "YuukaCharacterBaseAttackG", "YuukaCharacterBaseBlockR", "YuukaCharacterBaseBlockR", "YuukaCharacterBloomingField", "YuukaCharacterRosepetalRuin" };

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YuukaCharacterBaseAttackR", "YuukaCharacterBaseAttackR", "YuukaCharacterBaseBlockG", "YuukaCharacterBaseBlockG", "YuukaCharacterSunbeamBurst", "YuukaCharacterRadiantGlare" };

		public static PlayerUnitConfig playerUnitConfig;

		static YuukaLoadouts()
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 0;
			((ManaGroup)(ref val)).Blue = 0;
			((ManaGroup)(ref val)).Black = 0;
			((ManaGroup)(ref val)).Red = 2;
			((ManaGroup)(ref val)).Green = 2;
			((ManaGroup)(ref val)).Colorless = 0;
			((ManaGroup)(ref val)).Philosophy = 0;
			ManaGroup val2 = val;
			string ultimateSkillA = UltimateSkillA;
			string ultimateSkillB = UltimateSkillB;
			string exhibitA = ExhibitA;
			string exhibitB = ExhibitB;
			IReadOnlyList<string> deckA = DeckA;
			IReadOnlyList<string> deckB = DeckB;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, true, "", 0, 8, num, true, (int?)null, (ManaColor)5, (ManaColor)4, val2, "#378a04", 78, 50, 0, ultimateSkillA, ultimateSkillB, exhibitA, exhibitB, deckA, deckB, 2, 3);
		}
	}
	public sealed class YuukaModDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(YuukaModDef))]
		public sealed class YuukaMod : PlayerUnit
		{
			protected override void OnEnterGameRun(GameRunController gameRun)
			{
				CardConfig.FromId("PatchouliGreenAttack").IsPooled = false;
			}
		}

		[HarmonyPatch(typeof(UiManager), "LeaveGameRun")]
		private class UiManager_LeaveGameRun_Patch
		{
			private static void Postfix(UiManager __instance)
			{
				CardConfig.FromId("PatchouliGreenAttack").IsPooled = true;
			}
		}

		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)YuukaLocalization.PlayerUnitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

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

		public override PlayerUnitConfig MakeConfig()
		{
			return YuukaLoadouts.playerUnitConfig;
		}

		public override EikiSummonInfo AssociateEikiSummon()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new EikiSummonInfo(typeof(global::YuukaMod.Enemies.YuukaMod), (string)null);
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace YuukaMod.YuukaUlt
{
	public class YuukaUltTemplate : 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(YuukaDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public UltimateSkillConfig GetDefaulUltConfig()
		{
			return YuukaDefaultConfig.GetDefaultUltConfig();
		}
	}
	public sealed class YuukaCharacterUltFillerPrototypeMasterSparkDef : YuukaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 30;
			defaulUltConfig.RelativeCards = new List<string> { "RManaCard" };
			defaulUltConfig.Value1 = 1;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YuukaCharacterUltFillerPrototypeMasterSparkDef))]
	public sealed class YuukaCharacterUltFillerPrototypeMasterSpark : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			public YuukaCharacterUltFillerPrototypeMasterSpark <>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__1(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_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: 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);
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { (Card)Library.CreateCard<RManaCard>() });
					<>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()
			{
				<Actions>d__1 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

		public YuukaCharacterUltFillerPrototypeMasterSpark()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(12170);
		}

		[IteratorStateMachine(typeof(<Actions>d__1))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__1(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
	public sealed class YuukaUltADef : YuukaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 15;
			defaulUltConfig.Value1 = 3;
			defaulUltConfig.RelativeEffects = new List<string> { "Graze" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YuukaUltADef))]
	public sealed class YuukaUltA : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			public YuukaUltA <>4__this;

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

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

			[DebuggerHidden]
			public <Actions>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_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "YuukaUltA");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (IEnumerable<Unit>)selector.GetUnits(((UltimateSkill)<>4__this).Battle), ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Graze>((Unit)(object)((UltimateSkill)<>4__this).Owner, (int?)((UltimateSkill)<>4__this).Value1, (int?)0, (int?)0, (int?)0, 0.2f, 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()
			{
				<Actions>d__1 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

		public YuukaUltA()
		{
			((UltimateSkill)this).TargetType = (TargetType)2;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(25100);
		}

		[IteratorStateMachine(typeof(<Actions>d__1))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__1(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
	public sealed class YuukaUltBDef : YuukaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 30;
			defaulUltConfig.RelativeCards = new List<string> { "RManaCard" };
			defaulUltConfig.Value1 = 1;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YuukaUltBDef))]
	public sealed class YuukaUltB : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			public YuukaUltB <>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__1(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_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: 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);
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "YuukaUltB");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { (Card)Library.CreateCard<RManaCard>() });
					<>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__1 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

		public YuukaUltB()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(23061);
		}

		[IteratorStateMachine(typeof(<Actions>d__1))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__1(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
}
namespace YuukaMod.StatusEffects
{
	public sealed class YuukaArrangedKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaArrangedKeywordDef))]
	public sealed class YuukaArrangedKeyword : StatusEffect
	{
	}
	public sealed class YuukaArrangeKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaArrangeKeywordDef))]
	public sealed class YuukaArrangeKeyword : StatusEffect
	{
	}
	public sealed class YuukaFlourishKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaFlourishKeywordDef))]
	public sealed class YuukaFlourishKeyword : StatusEffect
	{
	}
	public sealed class YuukaThirdTurnKeywordDef : YuukaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuukaThirdTurnKeywordDef))]
	public sealed class YuukaThirdTurnKeyword : StatusEffect
	{
	}
	public class YuukaStatusEffectTemplate : 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(YuukaDefaultConfig.GetDefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public static StatusEffectConfig GetDefaultStatusEffectConfig()
		{
			return YuukaDefaultConfig.GetDefaultStatusEffectConfig();
		}
	}
	public sealed class YuukaBloomSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaBloomSeDef))]
	public sealed class YuukaBloomSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarting>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaBloomSe <>4__this;

			private YuukaShedBloomShieldBornSe <pv>5__1;

			private YuukaShedBloomShieldBornSe <pv>5__2;

			private YuukaShedBloomShieldBornSe <pv>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Expected O, but got Unknown
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Expected O, but got Unknown
				//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0303: Expected O, but got Unknown
				//IL_026f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0279: Expected O, but got Unknown
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Expected O, but got Unknown
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Expected O, but got Unknown
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_0341: Unknown result type (might be due to invalid IL or missing references)
				//IL_034b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((StatusEffect)<>4__this).NotifyActivating();
					if (((StatusEffect)<>4__this).Level < 5)
					{
						if (((StatusEffect)<>4__this).Level <= 0)
						{
							<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
							<>1__state = 1;
							return true;
						}
						<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBlossomSmall>() });
						<>1__state = 2;
						return true;
					}
					if (((StatusEffect)<>4__this).Level < 15)
					{
						<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBlossomMedium>() });
						<>1__state = 4;
						return true;
					}
					<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBlossomLarge>() });
					<>1__state = 6;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				case 2:
					<>1__state = -1;
					((StatusEffect)<>4__this).Level = ((StatusEffect)<>4__this).Level - 1;
					if (args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>() != null)
					{
						<pv>5__1 = args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>();
						<>2__current = (BattleAction)new CastBlockShieldAction(args.Unit, args.Unit, 0, ((StatusEffect)<pv>5__1).Level, (BlockShieldType)2, true);
						<>1__state = 3;
						return true;
					}
					goto IL_031c;
				case 3:
					<>1__state = -1;
					<pv>5__1 = null;
					goto IL_031c;
				case 4:
					<>1__state = -1;
					((StatusEffect)<>4__this).Level = ((StatusEffect)<>4__this).Level - 2;
					if (args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>() != null)
					{
						<pv>5__2 = args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>();
						<>2__current = (BattleAction)new CastBlockShieldAction(args.Unit, args.Unit, 0, ((StatusEffect)<pv>5__2).Level * 2, (BlockShieldType)2, true);
						<>1__state = 5;
						return true;
					}
					goto IL_031c;
				case 5:
					<>1__state = -1;
					<pv>5__2 = null;
					goto IL_031c;
				case 6:
					<>1__state = -1;
					((StatusEffect)<>4__this).Level = ((StatusEffect)<>4__this).Level - 3;
					if (args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>() != null)
					{
						<pv>5__3 = args.Unit.GetStatusEffect<YuukaShedBloomShieldBornSe>();
						<>2__current = (BattleAction)new CastBlockShieldAction(args.Unit, args.Unit, 0, ((StatusEffect)<pv>5__3).Level * 3, (BlockShieldType)2, true);
						<>1__state = 7;
						return true;
					}
					goto IL_031c;
				case 7:
					<>1__state = -1;
					<pv>5__3 = null;
					goto IL_031c;
				case 8:
					{
						<>1__state = -1;
						return false;
					}
					IL_031c:
					if (((StatusEffect)<>4__this).Level <= 0)
					{
						<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
						<>1__state = 8;
						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()
			{
				<OnOwnerTurnStarting>d__1 <OnOwnerTurnStarting>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnStarting>d__ = this;
				}
				else
				{
					<OnOwnerTurnStarting>d__ = new <OnOwnerTurnStarting>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnStarting>d__.args = <>3__args;
				return <OnOwnerTurnStarting>d__;
			}

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

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

		[IteratorStateMachine(typeof(<OnOwnerTurnStarting>d__1))]
		private IEnumerable<BattleAction> OnOwnerTurnStarting(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarting>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YuukaBossSleepingTerrorSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaBossSleepingTerrorSeDef))]
	public sealed class YuukaBossSleepingTerrorSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnDamageReceived>d__6 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DamageEventArgs args;

			public DamageEventArgs <>3__args;

			public YuukaBossSleepingTerrorSe <>4__this;

			private int <num>5__1;

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

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

			[DebuggerHidden]
			public <OnDamageReceived>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_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				DamageInfo damageInfo;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					damageInfo = args.DamageInfo;
					<num>5__1 = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage) - <>4__this._internalCount;
					if (<num>5__1 > 0 && !<>4__this._hasTriggered)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>(((StatusEffect)<>4__this).Owner, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					<>4__this._hasTriggered = true;
					((StatusEffect)<>4__this).NotifyActivating();
					((GameEventArgs)args).AddModifier((GameEntity)(object)<>4__this);
					break;
				}
				YuukaBossSleepingTerrorSe yuukaBossSleepingTerrorSe = <>4__this;
				int internalCount = <>4__this._internalCount;
				damageInfo = args.DamageInfo;
				yuukaBossSleepingTerrorSe._internalCount = internalCount - MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
				((StatusEffect)<>4__this).Count = Math.Max(<>4__this._internalCount, 0);
				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()
			{
				<OnDamageReceived>d__6 <OnDamageReceived>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnDamageReceived>d__ = this;
				}
				else
				{
					<OnDamageReceived>d__ = new <OnDamageReceived>d__6(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnDamageReceived>d__.args = <>3__args;
				return <OnDamageReceived>d__;
			}

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

		private int _internalCount;

		private bool _hasTriggered = false;

		public string HasTriggered
		{
			get
			{
				if (_hasTriggered)
				{
					return "Has already triggered this turn.";
				}
				return "Can trigger once per turn.";
			}
		}

		protected override void OnAdded(Unit unit)
		{
			_internalCount = ((StatusEffect)this).Limit;
			((StatusEffect)this).Count = _internalCount;
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(unit.TurnStarting, (GameEventHandler<UnitEventArgs>)OnTurnStarting);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(unit.DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnDamageReceived);
		}

		public void OnTurnStarting(UnitEventArgs args)
		{
			_internalCount = ((StatusEffect)this).Limit;
			((StatusEffect)this).Count = _internalCount;
			_hasTriggered = false;
		}

		[IteratorStateMachine(typeof(<OnDamageReceived>d__6))]
		private IEnumerable<BattleAction> OnDamageReceived(DamageEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnDamageReceived>d__6(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YuukaBouquetBindingSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasLevel = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaBouquetBindingSeDef))]
	public sealed class YuukaBouquetBindingSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardsAddedToDiscard>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardsEventArgs args;

			public CardsEventArgs <>3__args;

			public YuukaBouquetBindingSe <>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 <OnCardsAddedToDiscard>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) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<list>5__1 = null;
				<>s__2 = default(List<Card>.Enumerator);
				<card>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Expected O, but got Unknown
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<list>5__1 = args.Cards.Where((Card card) => card is SummerFlower).ToList();
						if (<list>5__1.Count == 0)
						{
							break;
						}
						<>s__2 = <list>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_010c;
					case 1:
						<>1__state = -3;
						<>2__current = (BattleAction)new AddCardsToDiscardAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBouquetCharm>() });
						<>1__state = 2;
						return true;
					case 2:
						{
							<>1__state = -3;
							<card>5__3 = null;
							goto IL_010c;
						}
						IL_010c:
						if (<>s__2.MoveNext())
						{
							<card>5__3 = <>s__2.Current;
							<>2__current = (BattleAction)new ExileCardAction(<card>5__3);
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__2 = default(List<Card>.Enumerator);
						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;
				((IDisposable)<>s__2).Dispose();
			}

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardsAddingToDrawZoneEventArgs args;

			public CardsAddingToDrawZoneEventArgs <>3__args;

			public YuukaBouquetBindingSe <>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 <OnCardsAddedToDrawZone>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();
					}
				}
				<list>5__1 = null;
				<>s__2 = default(List<Card>.Enumerator);
				<card>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Expected O, but got Unknown
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<list>5__1 = args.Cards.Where((Card card) => card is SummerFlower).ToList();
						if (<list>5__1.Count == 0)
						{
							break;
						}
						<>s__2 = <list>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_0107;
					case 1:
						<>1__state = -3;
						<>2__current = (BattleAction)new AddCardsToDrawZoneAction((IEnumerable<Card>)Library.CreateCards<YuukaCharacterTokenBouquetCharm>(1, false), (DrawZoneTarget)2, (AddCardsType)0);
						<>1__state = 2;
						return true;
					case 2:
						{
							<>1__state = -3;
							<card>5__3 = null;
							goto IL_0107;
						}
						IL_0107:
						if (<>s__2.MoveNext())
						{
							<card>5__3 = <>s__2.Current;
							<>2__current = (BattleAction)new ExileCardAction(<card>5__3);
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__2 = default(List<Card>.Enumerator);
						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;
				((IDisposable)<>s__2).Dispose();
			}

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardsEventArgs args;

			public CardsEventArgs <>3__args;

			public YuukaBouquetBindingSe <>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 <OnCardsAddedToHand>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();
					}
				}
				<list>5__1 = null;
				<>s__2 = default(List<Card>.Enumerator);
				<card>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Expected O, but got Unknown
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<list>5__1 = args.Cards.Where((Card card) => card is SummerFlower).ToList();
						if (<list>5__1.Count == 0)
						{
							break;
						}
						<>s__2 = <list>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_010c;
					case 1:
						<>1__state = -3;
						<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YuukaCharacterTokenBouquetCharm>() });
						<>1__state = 2;
						return true;
					case 2:
						{
							<>1__state = -3;
							<card>5__3 = null;
							goto IL_010c;
						}
						IL_010c:
						if (<>s__2.MoveNext())
						{
							<card>5__3 = <>s__2.Current;
							<>2__current = (BattleAction)new ExileCardAction(<card>5__3);
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__2 = default(List<Card>.Enumerator);
						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;
				((IDisposable)<>s__2).Dispose();
			}

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

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

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToDiscard, (EventSequencedReactor<CardsEventArgs>)OnCardsAddedToDiscard);
			((StatusEffect)this).ReactOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToHand, (EventSequencedReactor<CardsEventArgs>)OnCardsAddedToHand);
			((StatusEffect)this).ReactOwnerEvent<CardsAddingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardsAddedToDrawZone, (EventSequencedReactor<CardsAddingToDrawZoneEventArgs>)OnCardsAddedToDrawZone);
		}

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

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

		[IteratorStateMachine(typeof(<OnCardsAddedToDrawZone>d__3))]
		private IEnumerable<BattleAction> OnCardsAddedToDrawZone(CardsAddingToDrawZoneEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnCardsAddedToDrawZone>d__3(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YuukaDawnsPromiseSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDawnsPromiseSeDef))]
	public sealed class YuukaDawnsPromiseSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsed>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardUsingEventArgs args;

			public CardUsingEventArgs <>3__args;

			public YuukaDawnsPromiseSe <>4__this;

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

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

			[DebuggerHidden]
			public <OnCardUsed>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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					ManaGroup consumingMana = args.ConsumingMana;
					if (((ManaGroup)(ref consumingMana)).Amount >= 3)
					{
						YuukaDawnsPromiseSe yuukaDawnsPromiseSe = <>4__this;
						consumingMana = args.ConsumingMana;
						<>2__current = ((StatusEffect)yuukaDawnsPromiseSe).BuffAction<YuukaDawnsPromiseSe>(((ManaGroup)(ref consumingMana)).Amount, 0, 0, 0, 0.2f);
						<>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()
			{
				<OnCardUsed>d__1 <OnCardUsed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsed>d__ = this;
				}
				else
				{
					<OnCardUsed>d__ = new <OnCardUsed>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardUsed>d__.args = <>3__args;
				return <OnCardUsed>d__;
			}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaDawnsPromiseSe <>4__this;

			private bool <is_upgraded>5__1;

			private YuukaCharacterDawnsFury <attack>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Expected O, but got Unknown
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((StatusEffect)<>4__this).NotifyActivating();
					<is_upgraded>5__1 = ((StatusEffect)<>4__this).Count == 4;
					<attack>5__2 = Library.CreateCard<YuukaCharacterDawnsFury>(<is_upgraded>5__1);
					((Card)<attack>5__2).DeltaDamage = ((Card)<attack>5__2).DeltaDamage + (((StatusEffect)<>4__this).Level - ((Card)<attack>5__2).ConfigDamage);
					<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { <attack>5__2 });
					<>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()
			{
				<OnOwnerTurnStarting>d__2 <OnOwnerTurnStarting>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnStarting>d__ = this;
				}
				else
				{
					<OnOwnerTurnStarting>d__ = new <OnOwnerTurnStarting>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnStarting>d__.args = <>3__args;
				return <OnOwnerTurnStarting>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarting, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarting);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

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

		[IteratorStateMachine(typeof(<OnOwnerTurnStarting>d__2))]
		private IEnumerable<BattleAction> OnOwnerTurnStarting(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarting>d__2(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YuukaDazzlingFlareSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			defaultStatusEffectConfig.HasLevel = false;
			defaultStatusEffectConfig.HasDuration = true;
			defaultStatusEffectConfig.DurationStackType = (StackType)0;
			defaultStatusEffectConfig.DurationDecreaseTiming = (DurationDecreaseTiming)3;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDazzlingFlareSeDef))]
	public sealed class YuukaDazzlingFlareSe : StatusEffect
	{
		public override bool ShouldPreventCardUsage(Card card)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			return (int)card.CardType == 1;
		}
	}
	public sealed class YuukaDrawNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 15;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDrawNextTurnSeDef))]
	public sealed class YuukaDrawNextTurnSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaDrawNextTurnSe <>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()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)new DrawManyCardAction(((StatusEffect)<>4__this).Level);
					<>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()
			{
				<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(UnitEventArgs 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 sealed class YuukaDrawReductionNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaDrawReductionNextTurnSeDef))]
	public sealed class YuukaDrawReductionNextTurnSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaDrawReductionNextTurnSe <>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_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((StatusEffect)<>4__this).NotifyActivating();
					<>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).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
			BattleController battle = ((StatusEffect)this).Battle;
			battle.DrawCardCount -= ((StatusEffect)this).Level;
		}

		protected override void OnRemoved(Unit unit)
		{
			BattleController battle = ((StatusEffect)this).Battle;
			battle.DrawCardCount += ((StatusEffect)this).Level;
		}

		[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 YuukaFervorInTwoTurnsSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 12;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaFervorInTwoTurnsSeDef))]
	public sealed class YuukaFervorInTwoTurnsSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaFervorInTwoTurnsSe <>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_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((StatusEffect)<>4__this).NotifyActivating();
					<>2__current = ((StatusEffect)<>4__this).BuffAction<YuukaFervorNextTurnSe>(((StatusEffect)<>4__this).Level, 0, 0, 0, 0.2f);
					<>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>(unit.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 YuukaFervorNextTurnSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 11;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaFervorNextTurnSeDef))]
	public sealed class YuukaFervorNextTurnSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaFervorNextTurnSe <>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_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((StatusEffect)<>4__this).NotifyActivating();
					<>2__current = ((StatusEffect)<>4__this).BuffAction<YuukaFervorSe>(((StatusEffect)<>4__this).Level, 0, 0, 0, 0.2f);
					<>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>(unit.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 YuukaFervorSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFervorSeDef))]
	public sealed class YuukaFervorSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnEnded>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaFervorSe <>4__this;

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

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

			[DebuggerHidden]
			public <OnOwnerTurnEnded>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_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__4 <OnOwnerTurnEnded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnEnded>d__ = this;
				}
				else
				{
					<OnOwnerTurnEnded>d__ = new <OnOwnerTurnEnded>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnEnded>d__.args = <>3__args;
				return <OnOwnerTurnEnded>d__;
			}

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

		private float AttackRatio => ((float)((StatusEffect)this).Level + 100f) / 100f;

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageDealingEventArgs>(((StatusEffect)this).Owner.DamageDealing, (GameEventHandler<DamageDealingEventArgs>)OnDamageDealing);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
		}

		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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			DamageInfo damageInfo = args.DamageInfo;
			if ((int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				damageInfo = args.DamageInfo;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).MultiplyBy(AttackRatio);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				if ((int)((GameEventArgs)args).Cause != 20)
				{
					((StatusEffect)this).NotifyActivating();
				}
			}
		}

		[IteratorStateMachine(typeof(<OnOwnerTurnEnded>d__4))]
		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnEnded>d__4(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YuukaFloweringResonanceSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFloweringResonanceSeDef))]
	public sealed class YuukaFloweringResonanceSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnBlockShieldGained>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private BlockShieldEventArgs args;

			public BlockShieldEventArgs <>3__args;

			public YuukaFloweringResonanceSe <>4__this;

			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()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Block > 0f)
					{
						<>2__current = ((StatusEffect)<>4__this).BuffAction<NextTurnGainBlock>((int)(args.Block * (float)((StatusEffect)<>4__this).Level), 0, 0, 0, 0.2f);
						<>1__state = 1;
						return true;
					}
					goto IL_0088;
				case 1:
					<>1__state = -1;
					goto IL_0088;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0088:
					if (args.Shield > 0f)
					{
						<>2__current = ((StatusEffect)<>4__this).BuffAction<NextTurnGainBlock>((int)(args.Shield * (float)((StatusEffect)<>4__this).Level), 0, 0, 0, 0.2f);
						<>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()
			{
				<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();
			}
		}

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YuukaFloweringResonanceSe <>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<UnitEventArgs>(unit.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnEnded);
			((StatusEffect)this).ReactOwnerEvent<BlockShieldEventArgs>(((Unit)((StatusEffect)this).Battle.Player).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
			};
		}

		[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
			};
		}
	}
	public sealed class YuukaFlowersBirdsWindAndMoonSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFlowersBirdsWindAndMoonSeDef))]
	public sealed class YuukaFlowersBirdsWindAndMoonSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsed>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardUsingEventArgs args;

			public CardUsingEventArgs <>3__args;

			public YuukaFlowersBirdsWindAndMoonSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0057: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Card.HasKeyword((Keyword)4398046511104L) || ((Enum)args.Card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L))
					{
						((StatusEffect)<>4__this).NotifyActivating();
						if (args.Card is ReimuSakura)
						{
							args.Card.DecreaseBaseCost(<>4__this.Mana);
						}
						<>2__current = (BattleAction)(object)new IncreasePlayCountAction(args.Card, ((StatusEffect)<>4__this).Level);
						<>1__state = 1;
						return true;
					}
					goto IL_00ef;
				case 1:
					<>1__state = -1;
					goto IL_00ef;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00ef:
					if (args.Card is SummerFlower)
					{
						((StatusEffect)<>4__this).NotifyActivating();
						<>2__current = ((StatusEffect)<>4__this).BuffAction<SummerFlowerSe>(args.Card.Value1 * ((StatusEffect)<>4__this).Level, 0, 0, 0, 0.2f);
						<>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()
			{
				<OnCardUsed>d__5 <OnCardUsed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsed>d__ = this;
				}
				else
				{
					<OnCardUsed>d__ = new <OnCardUsed>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardUsed>d__.args = <>3__args;
				return <OnCardUsed>d__;
			}

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

		public ManaGroup Mana { get; private set; }

		protected override void OnAdded(Unit unit)
		{
			//IL_0022: 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)
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
			ManaGroup mana = default(ManaGroup);
			((ManaGroup)(ref mana)).Any = ((StatusEffect)this).Level;
			Mana = mana;
		}

		[IteratorStateMachine(typeof(<OnCardUsed>d__5))]
		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnCardUsed>d__5(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YuukaFrostNocturneSeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(YuukaFrostNocturneSeDef))]
	public sealed class YuukaFrostNocturneSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <StatusEffectAdded>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatusEffectApplyEventArgs args;

			public StatusEffectApplyEventArgs <>3__args;

			public YuukaFrostNocturneSe <>4__this;

			private int <level>5__1;

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

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

			[DebuggerHidden]
			public <StatusEffectAdded>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;
					if (args.Effect is YuukaBloomSe)
					{
						<level>5__1 = args.Level.GetValueOrDefault();
						<>2__current = ((StatusEffect)<>4__this).BuffAction<FrostArmor>(((StatusEffect)<>4__this).Level * <level>5__1, 0, 0, 0, 0.2f);
						<>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()
			{
				<StatusEffectAdded>d__1 <StatusEffectAdded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<StatusEffectAdded>d__ = this;
				}
				else
				{
					<StatusEffectAdded>d__ = new <StatusEffectAdded>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<StatusEffectAdded>d__.args = <>3__args;
				return <StatusEffectAdded>d__;
			}

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

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

		[IteratorStateMachine(typeof(<StatusEffectAdded>d__1))]
		private IEnumerable<BattleAction> StatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StatusEffectAdded>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YuukaGardenArchitectChoice1SeDef : YuukaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YuukaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.CountStackType = (StackType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YuukaGardenArchitectChoice1SeDef))]
	public sealed class YuukaGardenArchitectChoice1Se : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardsAddedToDiscard>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardsEventArgs args;

			public CardsEventArgs <>3__args;

			public YuukaGardenArchitectChoice1Se <>4__this;

			private List<Card> <list>5__1;

			private List<Card>.Enumerator <>s__2;

			private Card <card>5__3;

			private List<Card> <list2>5__4;

			private List<Card>.Enumerator <>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 <OnCardsAddedToDiscard>d__5(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 || (uint)(num - 1) <= 1u)
				{
					try
					{
						if (num == -4 || num == 2)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<list>5__1 = null;
				<>s__2 = default(List<Card>.Enumerator);
				<card>5__3 = null;
				<list2>5__4 = null;
				<>s__5 = default(List<Card>.Enumerator);
				<card2>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<list>5__1 = args.Cards.Where((Card card) => card is SummerFlower).ToList();
						if (<list>5__1.Count == 0)
						{
							break;
						}
						<>s__2 = <list>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_029d;
					case 1:
						<>1__state = -3;
						goto IL_00fc;
					case 2:
						{
							<>1__state = -4;
							<card2>5__6 = null;
							goto IL_0230;
						}
						IL_0295:
						<card>5__3 = null;
						goto IL_029d;
						IL_00fc:
						if (((StatusEffect)<>4__this).Count == 1)
						{
							<list2>5__4 = new List<Card>();
							<list2>5__4 = (from card in ((StatusEffect)<>4__this).Battle.HandZone.Concat(((StatusEffect)<>4__this).Battle.DrawZoneToShow).Concat(((StatusEffect)<>4__this).Battle.DiscardZone)
								where card.HasKeyword((Keyword)4398046511104L) || ((Enum)card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L)
								select card).ToList();
							<>s__5 = <list2>5__4.GetEnumerator();
							<>1__state = -4;
							goto IL_0230;
						}
						((StatusEffect)<>4__this).Count = ((StatusEffect)<>4__this).Count - 1;
						goto IL_0295;
						IL_029d:
						if (<>s__2.MoveNext())
						{
							<card>5__3 = <>s__2.Current;
							if (((Unit)((StatusEffect)<>4__this).Battle.Player).GetStatusEffect<YuukaBouquetBindingSe>() == null)
							{
								<>2__current = (BattleAction)new ExileCardAction(<card>5__3);
								<>1__state = 1;
								return true;
							}
							goto IL_00fc;
						}
						<>m__Finally1();
						<>s__2 = default(List<Card>.Enumerator);
						break;
						IL_0230:
						if (<>s__5.MoveNext())
						{
							<card2>5__6 = <>s__5.Current;
							if (<card>5__3 is ReimuSakura)
							{
								<card>5__3.DecreaseBaseCost(<>4__this.Mana * ((StatusEffect)<>4__this).Level);
							}
							<>2__current = (BattleAction)(object)new IncreasePlayCountAction(<card2>5__6, ((StatusEffect)<>4__this).Level);
							<>1__state = 2;
							return true;
						}
						<>m__Finally2();
						<>s__5 = default(List<Card>.Enumerator);
						((StatusEffect)<>4__this).Count = YuukaGardenArchitectConfig.Option1FlowerToBonus;
						((StatusEffect)<>4__this).NotifyActivating();
						<list2>5__4 = null;
						goto IL_0295;
					}
					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__2).Dispose();
			}

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardsAddingToDrawZoneEventArgs args;

			public CardsAddingToDrawZoneEventArgs <>3__args;

			public YuukaGardenArchitectChoice1Se <>4__this;

			private List<Card> <list>5__1;

			private List<Card>.Enumerator <>s__2;

			private Card <card>5__3;

			private List<Card> <list2>5__4;

			private List<Card>.Enumerator <>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 <OnCardsAddedToDrawZone>d__6(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 || (uint)(num - 1) <= 1u)
				{
					try
					{
						if (num == -4 || num == 2)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<list>5__1 = null;
				<>s__2 = default(List<Card>.Enumerator);
				<card>5__3 = null;
				<list2>5__4 = null;
				<>s__5 = default(List<Card>.Enumerator);
				<card2>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<list>5__1 = args.Cards.Where((Card card) => card is SummerFlower).ToList();
						if (<list>5__1.Count == 0)
						{
							break;
						}
						<>s__2 = <list>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_029d;
					case 1:
						<>1__state = -3;
						goto IL_00fc;
					case 2:
						{
							<>1__state = -4;
							<card2>5__6 = null;
							goto IL_0230;
						}
						IL_0295:
						<card>5__3 = null;
						goto IL_029d;
						IL_00fc:
						if (((StatusEffect)<>4__this).Count == 1)
						{
							<list2>5__4 = new List<Card>();
							<list2>5__4 = (from card in ((StatusEffect)<>4__this).Battle.HandZone.Concat(((StatusEffect)<>4__this).Battle.DrawZoneToShow).Concat(((StatusEffect)<>4__this).Battle.DiscardZone)
								where card.HasKeyword((Keyword)4398046511104L) || ((Enum)card.ConfigRelativeKeywords).HasFlag((Enum)(object)(Keyword)4398046511104L)
								select card).ToList();
							<>s__5 = <list2>5__4.GetEnumerator();
							<>1__state = -4;
							goto IL_0230;
						}
						((StatusEffect)<>4__this).Count = ((StatusEffect)<>4__this).Count - 1;
						goto IL_0295;
						IL_029d:
						if (<>s__2.MoveNext())
						{
							<card>5__3 = <>s__2.Current;
							if (((Unit)((StatusEffect)<>4__this).Battle.Player).GetStatusEffect<YuukaBouquetBindingSe>() == null)
							{
								<>2__current = (BattleAction)new ExileCardAction(<card>5__3);
								<>1__state = 1;
								return true;
							}
							goto IL_00fc;
						}
						<>m__Finally1();
						<>s__2 = default(List<Card>.Enumerator);
						break;
						IL_0230:
						if (<>s__5.MoveNext())
						{
							<card2>5__6 = <>s__5.Current;
							if (<card>5__3 is ReimuSakura)
							{
								<card>5__3.DecreaseBaseCost(<>4__this.Mana * ((StatusEffect)<>4__this).Level);
							}
							<>2__current = (BattleAction)(object)new IncreasePlayCountAction(<card2>5__6, ((StatusEffect)<>4__this).Level);
							<>1__state = 2;
							return true;
						}
						<>m__Finally2();
						<>s__5 = default(List<Card>.Enumerator);
						((StatusEffect)<>4__this).Count = YuukaGardenArchitectConfig.Option1FlowerToBonus;
						((StatusEffect)<>4__this).NotifyActivating();
						<list2>5__4 = null;
						goto IL_0295;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface imp