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.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
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.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards;
using LBoL.EntityLib.Cards.Neutral.White;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Cirno;
using LBoL.EntityLib.StatusEffects.Enemy;
using LBoL.EntityLib.StatusEffects.ExtraTurn;
using LBoL.EntityLib.StatusEffects.Neutral.TwoColor;
using LBoL.EntityLib.StatusEffects.Others;
using LBoL.EntityLib.StatusEffects.Sakuya;
using LBoL.Presentation;
using LBoL.Presentation.UI.Widgets;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using TMPro;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using YoumuCharacterMod.BattleActions;
using YoumuCharacterMod.Cards;
using YoumuCharacterMod.Cards.Template;
using YoumuCharacterMod.DefaultConfig;
using YoumuCharacterMod.GunName;
using YoumuCharacterMod.Illustrator;
using YoumuCharacterMod.ImageLoader;
using YoumuCharacterMod.Localization;
using YoumuCharacterMod.Patches;
using YoumuCharacterMod.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("YoumuCharacterMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+436f932db85133e1b9db5ae90fd96ceb7c4db2af")]
[assembly: AssemblyProduct("YoumuCharacterMod")]
[assembly: AssemblyTitle("YoumuCharacterMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace YoumuCharacterMod
{
	[BepInPlugin("rmrfmaxx.lbol.YoumuCharacterMod", "Youmu Character Mod", "0.7.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static bool modelIsFlipped = true;

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

		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

		public static string PlayerColor = "#00b789";

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

		internal static DirectorySource directorySource = new DirectorySource("rmrfmaxx.lbol.YoumuCharacterMod", "");

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			EntityManager.RegisterSelf();
			harmony.PatchAll();
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "rmrfmaxx.lbol.YoumuCharacterMod";

		public const string Name = "Youmu Character Mod";

		public const string version = "0.7.0";

		public static readonly Harmony harmony = new Harmony("rmrfmaxx.lbol.YoumuCharacterMod");
	}
	public class YoumuLoadouts
	{
		public static string UltimateSkillA = "YoumuUltW";

		public static string UltimateSkillB = "YoumuUltG";

		public static string ExhibitA = "YoumuExhibitW";

		public static string ExhibitB = "YoumuExhibitG";

		public static List<string> DeckA = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YoumuAttackW", "YoumuAttackW", "YoumuBlockG", "YoumuBlockG", "YoumuBlockG", "YoumuInsightfulSword" };

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YoumuAttackG", "YoumuAttackG", "YoumuBlockW", "YoumuBlockW", "YoumuBlockW", "YoumuAsuraSword" };
	}
	public sealed class YoumuPlayerDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(YoumuPlayerDef))]
		public sealed class YoumuMod : PlayerUnit
		{
		}

		public static string playerName = "Youmu";

		public static string modName = "YoumuMod";

		public static DirectorySource YoumuDir = new DirectorySource("rmrfmaxx.lbol.YoumuCharacterMod", "");

		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(modName);
		}

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

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

		public override PlayerUnitConfig MakeConfig()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			int? num = 0;
			string playerColor = BepinexPlugin.PlayerColor;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 2;
			((ManaGroup)(ref val)).White = 2;
			return new PlayerUnitConfig("Youmu", false, "", 0, 6, num, true, (int?)null, (ManaColor)1, (ManaColor)5, val, playerColor, 77, 50, 0, YoumuLoadouts.UltimateSkillA, YoumuLoadouts.UltimateSkillB, YoumuLoadouts.ExhibitA, YoumuLoadouts.ExhibitB, (IReadOnlyList<string>)YoumuLoadouts.DeckA, (IReadOnlyList<string>)YoumuLoadouts.DeckB, 2, 2);
		}
	}
}
namespace YoumuCharacterMod.YoumuUlt
{
	public sealed class YoumuFlashOfTheNetherworldUltDef : YoumuUltTemplate
	{
	}
	[EntityLogic(typeof(YoumuFlashOfTheNetherworldUltDef))]
	public sealed class YoumuFlashOfTheNetherworldUlt : 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 YoumuFlashOfTheNetherworldUlt <>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()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>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 YoumuFlashOfTheNetherworldUlt()
		{
			((UltimateSkill)this).TargetType = (TargetType)2;
			((UltimateSkill)this).GunName = YoumuGunName.FlashOfTheNetherworldSe;
		}

		[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 YoumuUltGDef : YoumuUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 12, 3, 1, (Keyword)256, (IReadOnlyList<string>)new List<string> { "LockedOn" }, (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(YoumuUltGDef))]
	public sealed class YoumuUltG : 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 YoumuUltG <>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_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Expected O, but got Unknown
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Expected O, but got Unknown
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: 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 DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, YoumuGunName.UltimateSkillGBurst, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, YoumuGunName.UltimateSkillGBurst, (GunType)0);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					if (((Unit)<enemy>5__1).IsAlive)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>((Unit)(object)<enemy>5__1, (int?)((UltimateSkill)<>4__this).Value1, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 4;
						return true;
					}
					break;
				case 4:
					<>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()
			{
				<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 YoumuUltG()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = YoumuGunName.UltimateSkillG;
		}

		[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 class YoumuUltTemplate : 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(YoumuDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

		public override UltimateSkillConfig MakeConfig()
		{
			return YoumuDefaultConfig.DefaultUltConfig();
		}
	}
	public sealed class YoumuUltWDef : YoumuUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 30, 2, 0, (Keyword)256, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string> { "YoumuSlashOfPresent" });
		}
	}
	[EntityLogic(typeof(YoumuUltWDef))]
	public sealed class YoumuUltW : 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 YoumuUltW <>4__this;

			private EnemyUnit <enemy>5__1;

			private int <i>5__2;

			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_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: 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;
					if (((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<i>5__2 = 0;
					break;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < ((UltimateSkill)<>4__this).Value1)
				{
					<>2__current = (BattleAction)new AddCardsToHandAction((Card[])(object)new Card[1] { Library.CreateCard<YoumuSlashOfPresent>() });
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<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 YoumuUltW()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = YoumuGunName.UltimateSkillW;
		}

		[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 YoumuCharacterMod.StatusEffects
{
	public sealed class YoumuAgelessObsessionSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuAgelessObsessionSeDef))]
	public sealed class YoumuAgelessObsessionSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((StatusEffect)this).HandleOwnerEvent<StatusEffectApplyEventArgs>(((Unit)allAliveEnemy).StatusEffectAdding, (GameEventHandler<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdding);
			}
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Battle.EnemySpawned, (GameEventHandler<UnitEventArgs>)OnEnemySpawned);
		}

		private void OnEnemySpawned(UnitEventArgs args)
		{
			((StatusEffect)this).HandleOwnerEvent<StatusEffectApplyEventArgs>(args.Unit.StatusEffectAdding, (GameEventHandler<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdding);
		}

		private void OnEnemyStatusEffectAdding(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is LockedOn)
			{
				((StatusEffect)this).NotifyActivating();
				StatusEffect effect = args.Effect;
				effect.Level *= ((StatusEffect)this).Level + 1;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}
	}
	public sealed class YoumuAscensionToBuddhahoodSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuAscensionToBuddhahoodSeDef))]
	public sealed class YoumuAscensionToBuddhahoodSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsing>d__3 : 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 YoumuAscensionToBuddhahoodSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if (!args.Card.IsCopy && args.Card.CanBeDuplicated && ((StatusEffect)<>4__this).Count > 0)
				{
					<>4__this.<>n__0();
					args.Card.IsEcho = true;
					int count = ((StatusEffect)<>4__this).Count;
					((StatusEffect)<>4__this).Count = count - 1;
				}
				if (((StatusEffect)<>4__this).Count <= 0)
				{
					((StatusEffect)<>4__this).Highlight = false;
				}
				return false;
			}

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

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

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

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

		[CompilerGenerated]
		private sealed class <OnOwnerStatusEffectAdded>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 YoumuAscensionToBuddhahoodSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if (args.Effect is YoumuAscensionToBuddhahoodSe)
				{
					((StatusEffect)<>4__this).Count = ((StatusEffect)<>4__this).Count + args.Level.Value;
				}
				if (((StatusEffect)<>4__this).Count > 0)
				{
					((StatusEffect)<>4__this).Highlight = 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()
			{
				<OnOwnerStatusEffectAdded>d__1 <OnOwnerStatusEffectAdded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerStatusEffectAdded>d__ = this;
				}
				else
				{
					<OnOwnerStatusEffectAdded>d__ = new <OnOwnerStatusEffectAdded>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerStatusEffectAdded>d__.args = <>3__args;
				return <OnOwnerStatusEffectAdded>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OnTurnStarted>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 YoumuAscensionToBuddhahoodSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				((StatusEffect)<>4__this).Count = ((StatusEffect)<>4__this).Level;
				if (((StatusEffect)<>4__this).Count > 0)
				{
					((StatusEffect)<>4__this).Highlight = 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()
			{
				<OnTurnStarted>d__2 <OnTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnTurnStarted>d__ = this;
				}
				else
				{
					<OnTurnStarted>d__ = new <OnTurnStarted>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnTurnStarted>d__.args = <>3__args;
				return <OnTurnStarted>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsing);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnTurnStarted);
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)((StatusEffect)this).Battle.Player).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnOwnerStatusEffectAdded);
		}

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

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuBizarenessSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuBizarenessSeDef))]
	public sealed class YoumuBizarenessSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnEnemyStatusEffectAdded>d__2 : 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 YoumuBizarenessSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Effect is LockedOn)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Poison>(args.Unit, (int?)((StatusEffect)<>4__this).Level, (int?)null, (int?)null, (int?)null, 0f, true);
						<>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()
			{
				<OnEnemyStatusEffectAdded>d__2 <OnEnemyStatusEffectAdded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnEnemyStatusEffectAdded>d__ = this;
				}
				else
				{
					<OnEnemyStatusEffectAdded>d__ = new <OnEnemyStatusEffectAdded>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnEnemyStatusEffectAdded>d__.args = <>3__args;
				return <OnEnemyStatusEffectAdded>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)allAliveEnemy).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
			}
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Battle.EnemySpawned, (GameEventHandler<UnitEventArgs>)OnEnemySpawned);
		}

		private void OnEnemySpawned(UnitEventArgs args)
		{
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(args.Unit.StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
		}

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuBloodOfAsuraSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuBloodOfAsuraSeDef))]
	public sealed class YoumuBloodOfAsuraSe : 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 YoumuBloodOfAsuraSe <>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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((int)args.Card.CardType == 1)
					{
						<>4__this.<>n__0();
						<>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;
					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();
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((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
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuDivineSeveringSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuDivineSeveringSeDef))]
	public sealed class YoumuDivineSeveringSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnUnsheathe>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnsheatheEventArgs args;

			public UnsheatheEventArgs <>3__args;

			public YoumuDivineSeveringSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				((StatusEffect)<>4__this).Count = ((StatusEffect)<>4__this).Count + ((StatusEffect)<>4__this).Level;
				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()
			{
				<OnUnsheathe>d__2 <OnUnsheathe>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnUnsheathe>d__ = this;
				}
				else
				{
					<OnUnsheathe>d__ = new <OnUnsheathe>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnUnsheathe>d__.args = <>3__args;
				return <OnUnsheathe>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnsheatheEventArgs>(CustomGameEventPatch.Unsheathed, (EventSequencedReactor<UnsheatheEventArgs>)OnUnsheathe);
			((StatusEffect)this).HandleOwnerEvent<DamageDealingEventArgs>(unit.DamageDealing, (GameEventHandler<DamageDealingEventArgs>)OnDamageDealing);
		}

		private void OnDamageDealing(DamageDealingEventArgs args)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			GameEntity actionSource = ((GameEventArgs)args).ActionSource;
			Card val = (Card)(object)((actionSource is Card) ? actionSource : null);
			if (val != null && YoumuCard.IsSlashCard(val) && (int)val.CardType == 1)
			{
				DamageInfo damageInfo = args.DamageInfo;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).IncreaseBy(((StatusEffect)this).Count);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}

		[IteratorStateMachine(typeof(<OnUnsheathe>d__2))]
		private IEnumerable<BattleAction> OnUnsheathe(UnsheatheEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnUnsheathe>d__2(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YoumuDrawNextTurnSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuDrawNextTurnSeDef))]
	public sealed class YoumuDrawNextTurnSe : 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 YoumuDrawNextTurnSe <>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 YoumuDualWielderGreenSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			val.RelativeEffects = new List<string> { "YoumuUnsheatheSe" };
			return val;
		}
	}
	[EntityLogic(typeof(YoumuDualWielderGreenSeDef))]
	public sealed class YoumuDualWielderGreenSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnManaConsumed>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private ManaEventArgs args;

			public ManaEventArgs <>3__args;

			public YoumuDualWielderGreenSe <>4__this;

			private (int, int) <valueTuple>5__1;

			private int <div>5__2;

			private int <item>5__3;

			private int <i>5__4;

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

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

			[DebuggerHidden]
			public <OnManaConsumed>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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<i>5__4++;
				}
				else
				{
					<>1__state = -1;
					YoumuDualWielderGreenSe youmuDualWielderGreenSe = <>4__this;
					int count = ((StatusEffect)<>4__this).Count;
					ManaGroup value = args.Value;
					((StatusEffect)youmuDualWielderGreenSe).Count = count + ((ManaGroup)(ref value)).Green;
					YoumuDualWielderGreenSe youmuDualWielderGreenSe2 = <>4__this;
					int count2 = ((StatusEffect)<>4__this).Count;
					value = args.Value;
					((StatusEffect)youmuDualWielderGreenSe2).Count = count2 + ((ManaGroup)(ref value)).Philosophy;
					<valueTuple>5__1 = MathExtensions.DivRem(((StatusEffect)<>4__this).Count, ((StatusEffect)<>4__this).Limit);
					<div>5__2 = <valueTuple>5__1.Item1;
					<item>5__3 = <valueTuple>5__1.Item2;
					((StatusEffect)<>4__this).Count = <item>5__3;
					if (<div>5__2 == 0)
					{
						goto IL_014c;
					}
					<>4__this.<>n__0();
					((StatusEffect)<>4__this).Highlight = false;
					<i>5__4 = 0;
				}
				if (<i>5__4 < <div>5__2 * ((StatusEffect)<>4__this).Level)
				{
					<>2__current = (BattleAction)(object)new UnsheatheAction();
					<>1__state = 1;
					return true;
				}
				goto IL_014c;
				IL_014c:
				if (((StatusEffect)<>4__this).Count == ((StatusEffect)<>4__this).Limit - 1)
				{
					((StatusEffect)<>4__this).Highlight = 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()
			{
				<OnManaConsumed>d__5 <OnManaConsumed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnManaConsumed>d__ = this;
				}
				else
				{
					<OnManaConsumed>d__ = new <OnManaConsumed>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnManaConsumed>d__.args = <>3__args;
				return <OnManaConsumed>d__;
			}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public YoumuDualWielderGreenSe <>4__this;

			private int <i>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<i>5__1 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__1++;
					break;
				}
				if (<i>5__1 < ((StatusEffect)<>4__this).Level)
				{
					<>2__current = (BattleAction)(object)new UnsheatheAction();
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

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

		public ManaGroup Green { get; set; }

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<ManaEventArgs>(((StatusEffect)this).Battle.ManaConsumed, (EventSequencedReactor<ManaEventArgs>)OnManaConsumed);
		}

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

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

		public YoumuDualWielderGreenSe()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Green = 1;
			Green = val;
			((StatusEffect)this)..ctor();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuDualWielderWhiteSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			val.RelativeEffects = new List<string> { "LockedOn" };
			return val;
		}
	}
	[EntityLogic(typeof(YoumuDualWielderWhiteSeDef))]
	public sealed class YoumuDualWielderWhiteSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnManaConsumed>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private ManaEventArgs args;

			public ManaEventArgs <>3__args;

			public YoumuDualWielderWhiteSe <>4__this;

			private (int, int) <valueTuple>5__1;

			private int <div>5__2;

			private int <item>5__3;

			private IEnumerator<EnemyUnit> <>s__4;

			private Unit <unit>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__4 = null;
				<unit>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						<unit>5__5 = null;
					}
					else
					{
						<>1__state = -1;
						YoumuDualWielderWhiteSe youmuDualWielderWhiteSe = <>4__this;
						int count = ((StatusEffect)<>4__this).Count;
						ManaGroup value = args.Value;
						((StatusEffect)youmuDualWielderWhiteSe).Count = count + ((ManaGroup)(ref value)).White;
						YoumuDualWielderWhiteSe youmuDualWielderWhiteSe2 = <>4__this;
						int count2 = ((StatusEffect)<>4__this).Count;
						value = args.Value;
						((StatusEffect)youmuDualWielderWhiteSe2).Count = count2 + ((ManaGroup)(ref value)).Philosophy;
						<valueTuple>5__1 = MathExtensions.DivRem(((StatusEffect)<>4__this).Count, ((StatusEffect)<>4__this).Limit);
						<div>5__2 = <valueTuple>5__1.Item1;
						<item>5__3 = <valueTuple>5__1.Item2;
						((StatusEffect)<>4__this).Count = <item>5__3;
						if (<div>5__2 == 0)
						{
							goto IL_01ac;
						}
						<>4__this.<>n__0();
						((StatusEffect)<>4__this).Highlight = false;
						<>s__4 = ((StatusEffect)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
					}
					if (<>s__4.MoveNext())
					{
						<unit>5__5 = (Unit)(object)<>s__4.Current;
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>(<unit>5__5, (int?)(((StatusEffect)<>4__this).Level * <div>5__2), (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__4 = null;
					goto IL_01ac;
					IL_01ac:
					if (((StatusEffect)<>4__this).Count == ((StatusEffect)<>4__this).Limit - 1)
					{
						((StatusEffect)<>4__this).Highlight = true;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public YoumuDualWielderWhiteSe <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <unit>5__2;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>4__this.<>n__0();
						<>s__1 = ((StatusEffect)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<unit>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<unit>5__2 = (Unit)(object)<>s__1.Current;
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<LockedOn>(<unit>5__2, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

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

		public ManaGroup White { get; set; }

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<ManaEventArgs>(((StatusEffect)this).Battle.ManaConsumed, (EventSequencedReactor<ManaEventArgs>)OnManaConsumed);
		}

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

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

		public YoumuDualWielderWhiteSe()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 1;
			White = val;
			((StatusEffect)this)..ctor();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuFlashOfTheNetherworldSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuFlashOfTheNetherworldSeDef))]
	public sealed class YoumuFlashOfTheNetherworldSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsed>d__6 : 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 YoumuFlashOfTheNetherworldSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if (((Unit)((StatusEffect)<>4__this).Battle.Player).IsExtraTurn)
				{
					((StatusEffect)<>4__this).Count = ((StatusEffect)<>4__this).Battle.TurnCardUsageHistory.Count;
				}
				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__6 <OnCardUsed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsed>d__ = this;
				}
				else
				{
					<OnCardUsed>d__ = new <OnCardUsed>d__6(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 <OnTurnEnded>d__5 : 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 YoumuFlashOfTheNetherworldSe <>4__this;

			private string <gunName>5__1;

			private Guns <guns>5__2;

			private List<GunPair>.Enumerator <>s__3;

			private GunPair <gunPair>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<gunName>5__1 = null;
				<guns>5__2 = null;
				<>s__3 = default(List<GunPair>.Enumerator);
				<gunPair>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Expected O, but got Unknown
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (!((Unit)((StatusEffect)<>4__this).Battle.Player).IsExtraTurn)
						{
							break;
						}
						<>4__this.<>n__0();
						<gunName>5__1 = YoumuGunName.FlashOfTheNetherworldSe;
						if (((StatusEffect)<>4__this).Count >= <>4__this.Threshold)
						{
							<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((StatusEffect)<>4__this).Battle.Player, "YoumuFlashOfTheNetherworldUlt");
							<>1__state = 1;
							return true;
						}
						goto IL_00c0;
					case 1:
						<>1__state = -1;
						goto IL_00c0;
					case 2:
						{
							<>1__state = -3;
							<gunPair>5__4 = null;
							goto IL_0178;
						}
						IL_0178:
						if (<>s__3.MoveNext())
						{
							<gunPair>5__4 = <>s__3.Current;
							<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)((StatusEffect)<>4__this).Level, false), <gunPair>5__4.GunName, (GunType)0);
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>s__3 = default(List<GunPair>.Enumerator);
						<gunName>5__1 = null;
						<guns>5__2 = null;
						break;
						IL_00c0:
						<guns>5__2 = new Guns(YoumuGunName.FlashOfTheNetherworldSe, ((StatusEffect)<>4__this).Count, false);
						<>s__3 = <guns>5__2.GunPairs.GetEnumerator();
						<>1__state = -3;
						goto IL_0178;
					}
					((StatusEffect)<>4__this).Count = 0;
					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__3).Dispose();
			}

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

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

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

		public int Threshold { get; set; } = 5;


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

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuGreatEnlightenmentSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuGreatEnlightenmentSeDef))]
	public sealed class YoumuGreatEnlightenmentSe : 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 YoumuGreatEnlightenmentSe <>4__this;

			private int <i>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<i>5__1 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__1++;
					break;
				}
				if (<i>5__1 < ((StatusEffect)<>4__this).Level)
				{
					<>2__current = (BattleAction)(object)new UnsheatheAction();
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<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 YoumuHakugyokurouSeDef : YoumuStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = YoumuStatusEffectTemplate.DefaultStatusEffectConfig();
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(YoumuHakugyokurouSeDef))]
	public sealed class YoumuHakugyokurouSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsed>d__9 : 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 YoumuHakugyokurouSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Invalid comparison between Unknown and I4
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((int)args.Card.CardType == 1)
					{
						<>4__this.<>n__0();
						((StatusEffect)<>4__this).Count = ((StatusEffect)<>4__this).Count + 1;
						if (((StatusEffect)<>4__this).Count == <>4__this.Threshold - 1)
						{
							((StatusEffect)<>4__this).Highlight = true;
						}
						if (((StatusEffect)<>4__this).Count >= <>4__this.Threshold)
						{
							((StatusEffect)<>4__this).Count = 0;
							<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)<>4__this.TotalDamage, false), YoumuGunName.Hakugyokurou, (GunType)0);
							<>1__state = 1;
							return true;
						}
					}
					break;
				case 1:
					<>1__state = -1;
					((StatusEffect)<>4__this).Highlight = false;
					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__9 <OnCardUsed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsed>d__ = this;
				}
				else
				{
					<OnCardUsed>d__ = new <OnCardUsed>d__9(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 <OnTurnStarted>d__8 : 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 YoumuHakugyokurouSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)new GainManaAction(<>4__this.Mana);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public int Threshold { get; } = 8;


		public int TotalDamage => ((StatusEffect)this).Level;

		public ManaGroup Mana
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: 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)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Philosophy = ((StatusEffect)this).Level / 40;
				return result;
			}
		}

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

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuInfiniteKalpasSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuInfiniteKalpasSeDef))]
	public sealed class YoumuInfiniteKalpasSe : 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 YoumuInfiniteKalpasSe <>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()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<>4__this.<>n__0();
				if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
				{
					return false;
				}
				<>4__this.<>n__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()
			{
				<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 YoumuInnerEyeSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuInnerEyeSeDef))]
	public sealed class YoumuInnerEyeSe : 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 YoumuInnerEyeSe <>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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((int)args.Card.CardType == 1)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<YoumuRiposteSe>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (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;
					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();
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((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
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuRiposteSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuRiposteSeDef))]
	public sealed class YoumuRiposteSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnPlayerDamageReceived>d__14 : 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 YoumuRiposteSe <>4__this;

			private ReflectDamage <reflectDamage>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Expected O, but got Unknown
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_00b9;
				case 1:
					<>1__state = -1;
					goto IL_00b1;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00b9:
					if (<>4__this.ReflectDamages.Count > 0)
					{
						<reflectDamage>5__1 = <>4__this.ReflectDamages.Dequeue();
						if (<reflectDamage>5__1.Target.IsAlive)
						{
							<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, <reflectDamage>5__1.Target, DamageInfo.Reaction((float)<reflectDamage>5__1.Damage, false), YoumuGunName.RiposteSe, (GunType)0);
							<>1__state = 1;
							return true;
						}
						goto IL_00b1;
					}
					((StatusEffect)<>4__this).Level = Math.Max(((StatusEffect)<>4__this).Level - <>4__this.totalDamageReduction, 0);
					<>4__this.totalDamageReduction = 0;
					if (((StatusEffect)<>4__this).Level <= 0)
					{
						<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
						<>1__state = 2;
						return true;
					}
					break;
					IL_00b1:
					<reflectDamage>5__1 = null;
					goto IL_00b9;
				}
				return false;
			}

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

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

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

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

		public string Gun { get; set; } = YoumuGunName.RiposteSe;


		private int totalDamageReduction { get; set; } = 0;


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


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

		private void OnPlayerDamageTaking(DamageEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			DamageInfo damageInfo = args.DamageInfo;
			int num = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
			if (num >= 1 && (int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				((StatusEffect)this).NotifyActivating();
				int num2 = Math.Min(num, ((StatusEffect)this).Level);
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).ReduceActualDamageBy(num2);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				totalDamageReduction += num2;
				if (args.Source != ((StatusEffect)this).Owner && args.Source.IsAlive)
				{
					ReflectDamages.Enqueue(new ReflectDamage(args.Source, num2));
				}
			}
		}

		[IteratorStateMachine(typeof(<OnPlayerDamageReceived>d__14))]
		private IEnumerable<BattleAction> OnPlayerDamageReceived(DamageEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnPlayerDamageReceived>d__14(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YoumuSilentNirvanaSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuSilentNirvanaSeDef))]
	public sealed class YoumuSilentNirvanaSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnEnemyStatusEffectAdded>d__2 : 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 YoumuSilentNirvanaSe <>4__this;

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

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

			[DebuggerHidden]
			public <OnEnemyStatusEffectAdded>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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Invalid comparison between Unknown and I4
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((int)args.Effect.Type == 1)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new CastBlockShieldAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)((StatusEffect)<>4__this).Battle.Player, ((StatusEffect)<>4__this).Level, 0, (BlockShieldType)2, true);
						<>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()
			{
				<OnEnemyStatusEffectAdded>d__2 <OnEnemyStatusEffectAdded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnEnemyStatusEffectAdded>d__ = this;
				}
				else
				{
					<OnEnemyStatusEffectAdded>d__ = new <OnEnemyStatusEffectAdded>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnEnemyStatusEffectAdded>d__.args = <>3__args;
				return <OnEnemyStatusEffectAdded>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			foreach (EnemyUnit allAliveEnemy in ((StatusEffect)this).Battle.AllAliveEnemies)
			{
				((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(((Unit)allAliveEnemy).StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
			}
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(((StatusEffect)this).Battle.EnemySpawned, (GameEventHandler<UnitEventArgs>)OnEnemySpawned);
		}

		private void OnEnemySpawned(UnitEventArgs args)
		{
			((StatusEffect)this).ReactOwnerEvent<StatusEffectApplyEventArgs>(args.Unit.StatusEffectAdded, (EventSequencedReactor<StatusEffectApplyEventArgs>)OnEnemyStatusEffectAdded);
		}

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuSpiritMediumBindSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuSpiritMediumBindSeDef))]
	public sealed class YoumuSpiritMediumBindSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardExiled>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardEventArgs args;

			public CardEventArgs <>3__args;

			public YoumuSpiritMediumBindSe <>4__this;

			private int <damage>5__1;

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

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

			[DebuggerHidden]
			public <OnCardExiled>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_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<damage>5__1 = ((StatusEffect)<>4__this).Level;
					<>2__current = (BattleAction)new DamageAction(((StatusEffect)<>4__this).Owner, (IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.AllAliveEnemies, DamageInfo.Reaction((float)<damage>5__1, false), YoumuGunName.SpiritMediumBindSe, (GunType)0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<CardEventArgs>(((StatusEffect)this).Battle.CardExiled, (EventSequencedReactor<CardEventArgs>)OnCardExiled);
		}

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YoumuSwordAuraSeDef : YoumuStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(YoumuSwordAuraSeDef))]
	public sealed class YoumuSwordAuraSe : 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 YoumuSwordAuraSe <>4__this;

			private IEnumerator<BattleAction> <>s__1;

			private BattleAction <battleAction>5__2;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
						{
							return false;
						}
						<>s__1 = <>4__this.TakeEffect().GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<battleAction>5__2 = null;
						break;
					}
					if (<>s__1.MoveNext())
					{
						<battleAction>5__2 = <>s__1.Current;
						<>2__current = <battleAction>5__2;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<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();
			}
		}

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public YoumuSwordAuraSe <>4__this;

			private List<Card> <list>5__1;

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

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

			[DebuggerHidden]
			public <TakeEffect>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedT