using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using HarmonyLib;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Battle.Interactions;
using LBoL.Core.Cards;
using LBoL.Core.Randoms;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards.Neutral.NoColor;
using LBoL.EntityLib.EnemyUnits.Character;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Enemy;
using LBoL.Presentation;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using RemiliaCharacterMod.Cards;
using RemiliaCharacterMod.Cards.Template;
using RemiliaCharacterMod.Config;
using RemiliaCharacterMod.Enemies.Template;
using RemiliaCharacterMod.GunName;
using RemiliaCharacterMod.ImageLoader;
using RemiliaCharacterMod.Localization;
using RemiliaCharacterMod.StatusEffects;
using UnityEngine;
using UnityEngine.Experimental.Rendering;

[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("RemiliaCharacterMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+c4bdb9eece779879a9b905bf0863d5ebddfddc18")]
[assembly: AssemblyProduct("RemiliaCharacterMod")]
[assembly: AssemblyTitle("RemiliaCharacterMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace RemiliaCharacterMod
{
	[BepInPlugin("rmrfmaxxc.character.RemiliaCharacter", "RemiliaCharacterMod", "0.1.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static string modUniqueID = "RemiliaCharacterMod";

		public static string playerName = "RemiliaCharacter";

		public static bool useInGameModel = true;

		public static string modelName = "Remilia";

		public static bool modelIsFlipped = true;

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

		public static ConfigEntry<bool> enableAct1Boss;

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

		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

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

		internal static DirectorySource directorySource = new DirectorySource("rmrfmaxxc.character.RemiliaCharacter", "");

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			enableAct1Boss = ((BaseUnityPlugin)this).Config.Bind<bool>(enableAct1BossEntry.Section, enableAct1BossEntry.Key, enableAct1BossEntry.Value, enableAct1BossEntry.Description);
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			CardIndexGenerator.PromiseClearIndexSet();
			EntityManager.RegisterSelf();
			harmony.PatchAll();
			Func<Sprite> func = () => ResourceLoader.LoadSprite("BossIcon.png", (IResourceSource)(object)directorySource, (Rect?)null, 1, (Vector2?)null);
			EnemyUnitTemplate.AddBossNodeIcon("RemiliaCharacterMod", func, (Assembly)null);
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "rmrfmaxxc.character.RemiliaCharacter";

		public const string Name = "RemiliaCharacterMod";

		public const string version = "0.1.3";

		public static readonly Harmony harmony = new Harmony("rmrfmaxxc.character.RemiliaCharacter");
	}
	public class RemiliaCharacterLoadouts
	{
		public static string UltimateSkillU = "RemiliaCharacterUltU";

		public static string UltimateSkillB = "RemiliaCharacterUltB";

		public static string ExhibitU = "RemiliaCharacterExhibitU";

		public static string ExhibitB = "RemiliaCharacterExhibitB";

		public static List<string> DeckA = new List<string>
		{
			"Shoot", "Shoot", "Boundary", "Boundary", "RemiliaCharacterAttackU", "RemiliaCharacterAttackB", "RemiliaCharacterBlockR", "RemiliaCharacterBlockR", "RemiliaCharacterBlockR", "RemiliaCharacterMistForm",
			"RemiliaCharacterDescendantOfTepes"
		};

		public static List<string> DeckB = new List<string>
		{
			"Shoot", "Shoot", "Boundary", "Boundary", "RemiliaCharacterAttackU", "RemiliaCharacterAttackB", "RemiliaCharacterBlockR", "RemiliaCharacterBlockR", "RemiliaCharacterBlockR", "RemiliaCharacterScarletBat",
			"RemiliaCharacterHeartBreak"
		};

		public static PlayerUnitConfig playerUnitConfig;

		static RemiliaCharacterLoadouts()
		{
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Blue = 1;
			((ManaGroup)(ref val)).Black = 1;
			((ManaGroup)(ref val)).Red = 2;
			ManaGroup val2 = val;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, true, "", 0, 8, num, true, (int?)null, (ManaColor)2, (ManaColor)3, val2, "#FF3333", 75, 99, 0, UltimateSkillU, UltimateSkillB, ExhibitU, ExhibitB, (IReadOnlyList<string>)DeckA, (IReadOnlyList<string>)DeckB, 3, 2);
		}
	}
	public sealed class RemiliaCharacterModDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(RemiliaCharacterModDef))]
		public sealed class RemiliaCharacterMod : PlayerUnit
		{
			[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 RemiliaCharacterMod <>4__this;

				private List<EnemyUnit>.Enumerator <>s__1;

				private EnemyUnit <Remilia>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 || (uint)(num - 1) <= 4u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<>s__1 = default(List<EnemyUnit>.Enumerator);
					<Remilia>5__2 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0159: Unknown result type (might be due to invalid IL or missing references)
					//IL_0163: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>s__1 = ((Unit)<>4__this).Battle.AllAliveEnemies.Where((EnemyUnit unit) => unit is Remilia).ToList().GetEnumerator();
							<>1__state = -3;
							goto IL_0214;
						case 1:
							<>1__state = -3;
							<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((Unit)<>4__this).Battle.Player, "RemiliaCharacterScarletDestiny");
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -3;
							<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)((Unit)<Remilia>5__2).GetStatusEffect<ScarletDestiny>(), true, 0.1f);
							<>1__state = 3;
							return true;
						case 3:
							<>1__state = -3;
							<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, ((GameEntity)<>4__this).LocalizeProperty("CustomChatRemilia2", false, true), 3f, 0f, 3.2f, true);
							<>1__state = 4;
							return true;
						case 4:
							<>1__state = -3;
							<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<Remilia>5__2, ((GameEntity)<>4__this).LocalizeProperty("CustomChatRemilia3", false, true), 3f, 0f, 0f, true);
							<>1__state = 5;
							return true;
						case 5:
							{
								<>1__state = -3;
								goto IL_020c;
							}
							IL_020c:
							<Remilia>5__2 = null;
							goto IL_0214;
							IL_0214:
							if (<>s__1.MoveNext())
							{
								<Remilia>5__2 = <>s__1.Current;
								if (((Unit)<Remilia>5__2).HasStatusEffect<ScarletDestiny>())
								{
									<>2__current = (BattleAction)(object)PerformAction.Chat((Unit)(object)<>4__this, ((GameEntity)<>4__this).LocalizeProperty("CustomChatRemilia1", false, true), 3f, 0f, 3.2f, true);
									<>1__state = 1;
									return true;
								}
								goto IL_020c;
							}
							<>m__Finally1();
							<>s__1 = default(List<EnemyUnit>.Enumerator);
							if (((Unit)((Unit)<>4__this).Battle.Player).HasStatusEffect<FoxCharm>() && ((StatusEffect)((Unit)((Unit)<>4__this).Battle.Player).GetStatusEffect<FoxCharm>()).Limit < 5)
							{
								((StatusEffect)((Unit)((Unit)<>4__this).Battle.Player).GetStatusEffect<FoxCharm>()).Limit = 5;
								((StatusEffect)((Unit)((Unit)<>4__this).Battle.Player).GetStatusEffect<FoxCharm>()).Count = 5;
								((GameEntity)((Unit)((Unit)<>4__this).Battle.Player).GetStatusEffect<FoxCharm>()).NotifyChanged();
							}
							return false;
						}
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

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

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

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

				[DebuggerHidden]
				IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
				{
					<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 OnEnterBattle(BattleController battle)
			{
				((Unit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Unit)this).Battle.Player).TurnStarted, (Func<UnitEventArgs, IEnumerable<BattleAction>>)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
				};
			}
		}

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

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

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

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

		public override PlayerUnitConfig MakeConfig()
		{
			return RemiliaCharacterLoadouts.playerUnitConfig;
		}
	}
}
namespace RemiliaCharacterMod.RemiliaCharacterUlt
{
	public sealed class RemiliaCharacterScarletDestinyDef : RemiliaCharacterUltTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterScarletDestinyDef))]
	public sealed class RemiliaCharacterScarletDestiny : 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 RemiliaCharacterScarletDestiny <>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 RemiliaCharacterScarletDestiny()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(4158);
		}

		[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 RemiliaCharacterUltBDef : RemiliaCharacterUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig val = DefaulUltConfig();
			val.Damage = 36;
			return val;
		}
	}
	[EntityLogic(typeof(RemiliaCharacterUltBDef))]
	public sealed class RemiliaCharacterUltB : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__2 : 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 RemiliaCharacterUltB <>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__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "RemiliaCharacterUltB");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainManaAction(<>4__this.Mana);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public ManaGroup Mana;

		public RemiliaCharacterUltB()
		{
			//IL_0003: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup mana = default(ManaGroup);
			((ManaGroup)(ref mana)).Red = 1;
			((ManaGroup)(ref mana)).Black = 1;
			Mana = mana;
			((UltimateSkill)this)..ctor();
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(4091);
		}

		[IteratorStateMachine(typeof(<Actions>d__2))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__2(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
	public class RemiliaCharacterUltTemplate : 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(RemiliaCharacterDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

		public override UltimateSkillConfig MakeConfig()
		{
			return DefaulUltConfig();
		}

		public UltimateSkillConfig DefaulUltConfig()
		{
			return RemiliaCharacterDefaultConfig.DefaultUltConfig();
		}
	}
	public sealed class RemiliaCharacterUltUDef : RemiliaCharacterUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig val = DefaulUltConfig();
			val.RelativeCards = new List<string> { "RemiliaCharacterDemonLordArrow" };
			val.Damage = 24;
			return val;
		}
	}
	[EntityLogic(typeof(RemiliaCharacterUltUDef))]
	public sealed class RemiliaCharacterUltU : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__5 : 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 RemiliaCharacterUltU <>4__this;

			private EnemyUnit <enemy>5__1;

			private Card <card>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "RemiliaCharacterUltU");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<card>5__2 = (Card)(object)Library.CreateCard<RemiliaCharacterDemonLordArrow>(false);
					<card>5__2.SetTurnCost(<>4__this.Mana);
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)new List<Card> { <card>5__2 }, (AddCardsType)0, false);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public ManaGroup Mana { get; set; }

		public RemiliaCharacterUltU()
		{
			//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)).Any = 0;
			Mana = val;
			((UltimateSkill)this)..ctor();
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(4092);
		}

		[IteratorStateMachine(typeof(<Actions>d__5))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__5(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
}
namespace RemiliaCharacterMod.StatusEffects
{
	public sealed class RemiliaCharacterAmuletFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterAmuletFateSeDef))]
	public sealed class RemiliaCharacterAmuletFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterAmuletFateSe <>4__this;

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

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

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

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

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

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

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

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

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterArrowFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterArrowFateSeDef))]
	public sealed class RemiliaCharacterArrowFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterArrowFateSe <>4__this;

			private Card <card>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<card>5__1 = (Card)(object)Library.CreateCard<RemiliaCharacterDemonLordArrow>(false);
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)new List<Card> { <card>5__1 }, (AddCardsType)0, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public ManaGroup Mana { get; }

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

		public RemiliaCharacterArrowFateSe()
		{
			//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)).Any = 0;
			Mana = val;
			base..ctor();
		}
	}
	public sealed class RemiliaCharacterBarrierFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterBarrierFateSeDef))]
	public sealed class RemiliaCharacterBarrierFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterBarrierFateSe <>4__this;

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

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

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

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

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

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

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

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

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterBombardNightFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterBombardNightFateSeDef))]
	public sealed class RemiliaCharacterBombardNightFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterBombardNightFateSe <>4__this;

			private EnemyUnit <enemyUnit>5__1;

			private IEnumerator<RemiliaCharacterBombardNightFateSe> <>s__2;

			private RemiliaCharacterBombardNightFateSe <se>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						<enemyUnit>5__1 = CollectionsExtensions.MaxBy<EnemyUnit, int>(((StatusEffect)<>4__this).Battle.EnemyGroup.Alives, (Func<EnemyUnit, int>)((EnemyUnit unit) => ((Unit)unit).Hp));
						<>2__current = (BattleAction)new DamageAction(((StatusEffect)<>4__this).Owner, (Unit)(object)<enemyUnit>5__1, DamageInfo.Attack((float)((StatusEffect)<>4__this).Level, false), GunNameID.GetGunFromId(4700), (GunType)0);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					if (!((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						<>2__current = ((StatusEffect)<>4__this).BuffAction<RemiliaCharacterBombardNightSe>(<>4__this.Bonus, 0, 0, 0, 0.2f);
						<>1__state = 2;
						return true;
					}
					goto IL_01b1;
				case 2:
					{
						<>1__state = -1;
						<>s__2 = ((Unit)((StatusEffect)<>4__this).Battle.Player).StatusEffects.OfType<RemiliaCharacterBombardNightFateSe>().GetEnumerator();
						try
						{
							while (<>s__2.MoveNext())
							{
								<se>5__3 = <>s__2.Current;
								RemiliaCharacterBombardNightFateSe remiliaCharacterBombardNightFateSe = <se>5__3;
								((StatusEffect)remiliaCharacterBombardNightFateSe).Level = ((StatusEffect)remiliaCharacterBombardNightFateSe).Level + 5;
								((GameEntity)<se>5__3).NotifyChanged();
								<se>5__3 = null;
							}
						}
						finally
						{
							if (<>s__2 != null)
							{
								<>s__2.Dispose();
							}
						}
						<>s__2 = null;
						goto IL_01b1;
					}
					IL_01b1:
					<enemyUnit>5__1 = null;
					break;
				}
				return false;
			}

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

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

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

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

		public int Bonus => 5;

		public DamageInfo Damage => DamageInfo.Attack((float)((StatusEffect)this).Level, false);

		[IteratorStateMachine(typeof(<FateAction>d__4))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__4(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterCradleFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterCradleFateSeDef))]
	public sealed class RemiliaCharacterCradleFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterCradleFateSe <>4__this;

			private Card <card>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<card>5__1 = (Card)(object)Library.CreateCard<RemiliaCharacterDemonLordCradle>(false);
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)new List<Card> { <card>5__1 }, (AddCardsType)0, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public ManaGroup Mana { get; }

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

		public RemiliaCharacterCradleFateSe()
		{
			//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)).Any = 0;
			Mana = val;
			base..ctor();
		}
	}
	public sealed class RemiliaCharacterDarkRitualFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterDarkRitualFateSeDef))]
	public sealed class RemiliaCharacterDarkRitualFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterDarkRitualFateSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainManaAction(<>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()
			{
				<FateAction>d__2 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

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

		[IteratorStateMachine(typeof(<FateAction>d__2))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__2(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterDrawFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterDrawFateSeDef))]
	public sealed class RemiliaCharacterDrawFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterDrawFateSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new DrawManyCardAction(((StatusEffect)<>4__this).Level);
					<>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()
			{
				<FateAction>d__0 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public class RemiliaCharacterFateSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterFateSe <>4__this;

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

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

			[DebuggerHidden]
			public <FateAction>d__5(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()
			{
				<FateAction>d__5 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

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

			private IEnumerator<BattleAction> <>s__1;

			private BattleAction <ba>5__2;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						<ba>5__2 = null;
					}
					else
					{
						<>1__state = -1;
						if (!<>4__this.SawActivation)
						{
							goto IL_00ba;
						}
						<>s__1 = <>4__this.ReduceCountdown().GetEnumerator();
						<>1__state = -3;
					}
					if (<>s__1.MoveNext())
					{
						<ba>5__2 = <>s__1.Current;
						<>2__current = <ba>5__2;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__1 = null;
					<>4__this.SawActivation = false;
					goto IL_00ba;
					IL_00ba:
					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()
			{
				<OnCardUsed>d__3 <OnCardUsed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsed>d__ = this;
				}
				else
				{
					<OnCardUsed>d__ = new <OnCardUsed>d__3(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 <ReduceCountdown>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterFateSe <>4__this;

			private IEnumerator<BattleAction> <>s__1;

			private BattleAction <ba>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						int count = ((StatusEffect)<>4__this).Count;
						((StatusEffect)<>4__this).Count = count - 1;
						if (((StatusEffect)<>4__this).Count == 1)
						{
							((StatusEffect)<>4__this).Highlight = true;
						}
						if (((StatusEffect)<>4__this).Count > 0 || ((StatusEffect)<>4__this).Battle.BattleShouldEnd)
						{
							break;
						}
						<>s__1 = <>4__this.FateAction().GetEnumerator();
						<>1__state = -3;
						goto IL_00fa;
					}
					case 1:
						<>1__state = -3;
						<ba>5__2 = null;
						goto IL_00fa;
					case 2:
						{
							<>1__state = -1;
							break;
						}
						IL_00fa:
						if (<>s__1.MoveNext())
						{
							<ba>5__2 = <>s__1.Current;
							<>2__current = <ba>5__2;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__1 = null;
						<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
						<>1__state = 2;
						return 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__1 != null)
				{
					<>s__1.Dispose();
				}
			}

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

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

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

		private bool SawActivation = false;

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsing, (GameEventHandler<CardUsingEventArgs>)OnCardUsing);
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
		}

		private void OnCardUsing(CardUsingEventArgs args)
		{
			SawActivation = true;
		}

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

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

		[IteratorStateMachine(typeof(<FateAction>d__5))]
		protected virtual IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__5(-2)
			{
				<>4__this = this
			};
		}
	}
	public class RemiliaCharacterFateTemplate : RemiliaCharacterStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = RemiliaCharacterStatusEffectTemplate.DefaultStatusEffectConfig();
			val.IsStackable = false;
			val.HasCount = true;
			return val;
		}
	}
	public sealed class RemiliaCharacterFirepowerFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterFirepowerFateSeDef))]
	public sealed class RemiliaCharacterFirepowerFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterFirepowerFateSe <>4__this;

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

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

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

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

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

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

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

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

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterFlameFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterFlameFateSeDef))]
	public sealed class RemiliaCharacterFlameFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterFlameFateSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<RManaCard>(((StatusEffect)<>4__this).Level, false), (AddCardsType)0, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterHeartBreakFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterHeartBreakFateSeDef))]
	public sealed class RemiliaCharacterHeartBreakFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterHeartBreakFateSe <>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 <FateAction>d__0(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;
						<>s__1 = ((StatusEffect)<>4__this).DebuffAction<TempFirepowerNegative>((IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.AllAliveEnemies, ((StatusEffect)<>4__this).Level, 0, 0, 0, true, 0.2f).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()
			{
				<FateAction>d__0 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterLockOnFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterLockOnFateSeDef))]
	public sealed class RemiliaCharacterLockOnFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterLockOnFateSe <>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 <FateAction>d__0(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;
						<>s__1 = ((StatusEffect)<>4__this).DebuffAction<LockedOn>((IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.AllAliveEnemies, ((StatusEffect)<>4__this).Level, 0, 0, 0, true, 0.2f).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()
			{
				<FateAction>d__0 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterRainbowFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterRainbowFateSeDef))]
	public sealed class RemiliaCharacterRainbowFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterRainbowFateSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<PManaCard>(((StatusEffect)<>4__this).Level, false), (AddCardsType)0, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterScarletFateFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterScarletFateFateSeDef))]
	public sealed class RemiliaCharacterScarletFateFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterScarletFateFateSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Effect((Unit)(object)((StatusEffect)<>4__this).Battle.Player, "ExtraTime", 0f, (string)null, 0f, (EffectBehavior)0, 0f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Sfx("ExtraTurnLaunch", 0f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Animation((Unit)(object)((StatusEffect)<>4__this).Battle.Player, "spell", 1.6f, (string)null, 0f, -1);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = ((StatusEffect)<>4__this).BuffAction<ExtraTurn>(((StatusEffect)<>4__this).Level, 0, 0, 0, 0.2f);
					<>1__state = 4;
					return true;
				case 4:
					<>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()
			{
				<FateAction>d__0 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterUpgradeFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterUpgradeFateSeDef))]
	public sealed class RemiliaCharacterUpgradeFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterUpgradeFateSe <>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 <FateAction>d__0(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<list>5__1 = CollectionsExtensions.SampleManyOrAll<Card>((IEnumerable<Card>)((StatusEffect)<>4__this).Battle.HandZone.Where((Card card) => card.CanUpgradeAndPositive).ToList(), ((StatusEffect)<>4__this).Level, ((GameEntity)<>4__this).GameRun.BattleRng).ToList();
					if (<list>5__1.Count > 0)
					{
						<>2__current = (BattleAction)new UpgradeCardsAction((IEnumerable<Card>)<list>5__1);
						<>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()
			{
				<FateAction>d__0 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterVulnerableFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterVulnerableFateSeDef))]
	public sealed class RemiliaCharacterVulnerableFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterVulnerableFateSe <>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 <FateAction>d__0(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;
						<>s__1 = ((StatusEffect)<>4__this).DebuffAction<Vulnerable>((IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.AllAliveEnemies, 0, ((StatusEffect)<>4__this).Level, 0, 0, true, 0.2f).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()
			{
				<FateAction>d__0 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterWardFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterWardFateSeDef))]
	public sealed class RemiliaCharacterWardFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterWardFateSe <>4__this;

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

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

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

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

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

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

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

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

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterWeakFateSeDef : RemiliaCharacterFateTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterWeakFateSeDef))]
	public sealed class RemiliaCharacterWeakFateSe : RemiliaCharacterFateSe
	{
		[CompilerGenerated]
		private sealed class <FateAction>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public RemiliaCharacterWeakFateSe <>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 <FateAction>d__0(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;
						<>s__1 = ((StatusEffect)<>4__this).DebuffAction<Weak>((IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.AllAliveEnemies, 0, ((StatusEffect)<>4__this).Level, 0, 0, true, 0.2f).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()
			{
				<FateAction>d__0 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <FateAction>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		[IteratorStateMachine(typeof(<FateAction>d__0))]
		protected override IEnumerable<BattleAction> FateAction()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FateAction>d__0(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class RemiliaCharacterFateKeywordSeDef : RemiliaCharacterStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(RemiliaCharacterFateKeywordSeDef))]
	public sealed class RemiliaCharacterFateKeywordSe : StatusEffect
	{
	}
	public sealed class RemiliaCharacterTributeKeywordSeDef : RemiliaCharacterStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(RemiliaCharacterTributeKeywordSeDef))]
	public sealed class RemiliaCharacterTributeKeywordSe : StatusEffect
	{
	}
	public sealed class RemiliaCharacterAscendingIntoNaughtSeDef : RemiliaCharacterStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterAscendingIntoNaughtSeDef))]
	public sealed class RemiliaCharacterAscendingIntoNaughtSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public RemiliaCharacterAscendingIntoNaughtSe <>4__this;

			private List<Card> <ToAdd>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<ToAdd>5__1 = ((IEnumerable<Card>)Library.CreateCards<RemiliaCharacterDemonLordArrow>(((StatusEffect)<>4__this).Level, false)).ToList();
					<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)<ToAdd>5__1, (AddCardsType)0, false);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public ManaGroup Mana;

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

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

		public RemiliaCharacterAscendingIntoNaughtSe()
		{
			//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 mana = default(ManaGroup);
			((ManaGroup)(ref mana)).Any = 1;
			Mana = mana;
			((StatusEffect)this)..ctor();
		}
	}
	public sealed class RemiliaCharacterBombardNightSeDef : RemiliaCharacterStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterBombardNightSeDef))]
	public sealed class RemiliaCharacterBombardNightSe : StatusEffect
	{
	}
	public sealed class RemiliaCharacterClocktowerSeDef : RemiliaCharacterStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterClocktowerSeDef))]
	public sealed class RemiliaCharacterClocktowerSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__3 : 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 RemiliaCharacterClocktowerSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new GainManaAction(<>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()
			{
				<OnOwnerTurnStarted>d__3 <OnOwnerTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnStarted>d__ = this;
				}
				else
				{
					<OnOwnerTurnStarted>d__ = new <OnOwnerTurnStarted>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnStarted>d__.args = <>3__args;
				return <OnOwnerTurnStarted>d__;
			}

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

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

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

		[IteratorStateMachine(typeof(<OnOwnerTurnStarted>d__3))]
		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarted>d__3(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class RemiliaCharacterClownishCalendulaSeDef : RemiliaCharacterStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = RemiliaCharacterStatusEffectTemplate.DefaultStatusEffectConfig();
			val.Type = (StatusEffectType)2;
			return val;
		}
	}
	[EntityLogic(typeof(RemiliaCharacterClownishCalendulaSeDef))]
	public sealed class RemiliaCharacterClownishCalendulaSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsed>d__2 : 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 RemiliaCharacterClownishCalendulaSe <>4__this;

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

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

			[DebuggerHidden]
			public <OnCardUsed>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_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)new DamageAction(((StatusEffect)<>4__this).Owner, ((StatusEffect)<>4__this).Owner, DamageInfo.Reaction((float)((StatusEffect)<>4__this).Level, false), <>4__this.GunName, (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()
			{
				<OnCardUsed>d__2 <OnCardUsed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsed>d__ = this;
				}
				else
				{
					<OnCardUsed>d__ = new <OnCardUsed>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardUsed>d__.args = <>3__args;
				return <OnCardUsed>d__;
			}

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

		public string GunName = GunNameID.GetGunFromId(4531);

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class RemiliaCharacterCurseOfVladTepesSeDef : RemiliaCharacterStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(RemiliaCharacterCurseOfVladTepesSeDef))]
	public sealed class RemiliaCharacterCurseOfVladTepesSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnStatusEffectRemoved>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatusEffectEventArgs args;

			public StatusEffectEventArgs <>3__args;

			public RemiliaCharacterCurseOfVladTepesSe <>4__this;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>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_004e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Effect is RemiliaCharacterFateSe)
					{
						<>2__current = (BattleAction)new GainManaAction(<>4__this.Mana);
						<>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()
			{
				<OnStatusEffectRemoved>d__3 <OnStatusEffectRemoved>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnStatusEffectRemoved>d__ = this;
				}
				else
				{
					<OnStatusEffectRemoved>d__ = new <OnStatusEffectRemoved>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnStatusEffectRemoved>d__.args = <>3__args;
				return <OnStatusEffectRemoved>d__;
			}

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

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this