using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
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.Intentions;
using LBoL.Core.Randoms;
using LBoL.Core.Stations;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards.Character.Reimu;
using LBoL.EntityLib.Cards.Enemy;
using LBoL.EntityLib.Cards.Neutral.Black;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.ExtraTurn;
using LBoL.EntityLib.StatusEffects.Neutral.TwoColor;
using LBoL.Presentation;
using LBoL.Presentation.Effect;
using LBoL.Presentation.UI.Panels;
using LBoL.Presentation.Units;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using lvalonexrumia.Cards;
using lvalonexrumia.Cards.Template;
using lvalonexrumia.Config;
using lvalonexrumia.Enemies;
using lvalonexrumia.Enemies.Template;
using lvalonexrumia.GunName;
using lvalonexrumia.ImageLoader;
using lvalonexrumia.Localization;
using lvalonexrumia.Patches;
using lvalonexrumia.StatusEffects;
using lvalonmeme.StatusEffects;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("LBoL.Base")]
[assembly: IgnoresAccessChecksTo("LBoL.ConfigData")]
[assembly: IgnoresAccessChecksTo("LBoL.Core")]
[assembly: IgnoresAccessChecksTo("LBoL.EntityLib")]
[assembly: IgnoresAccessChecksTo("LBoL.Presentation")]
[assembly: IgnoresAccessChecksTo("Untitled.ConfigDataBuilder.Base")]
[assembly: AssemblyCompany("lvalonexrumia")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+886013379fbbf569cf9ba1a53077d79fee08af53")]
[assembly: AssemblyProduct("lvalonexrumia")]
[assembly: AssemblyTitle("lvalonexrumia")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace lvalonmeme.StatusEffects
{
	public sealed class sedecreaseDef : lvalonexrumiaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(sedecreaseDef))]
	public sealed class sedecrease : StatusEffect
	{
	}
	public sealed class seincreaseDef : lvalonexrumiaStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(seincreaseDef))]
	public sealed class seincrease : StatusEffect
	{
	}
	public sealed class sebosshealDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "seincrease" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebosshealDef))]
	public sealed class sebossheal : StatusEffect
	{
		public override bool ForceNotShowDownText => true;
	}
}
namespace lvalonexrumia
{
	[BepInPlugin("llbol.char.exrumia", "EX Rumia", "1.0.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static string modUniqueID = "lvalonexrumia";

		public static string playerName = "EXRumia";

		public static bool useInGameModel = false;

		public static string modelName = "Youmu";

		public static bool modelIsFlipped = true;

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

		public static ConfigEntry<bool> enableAct1Boss;

		public static CustomConfigEntry<bool> enableAct1BossEntry = new CustomConfigEntry<bool>(value: false, "Act 1 Boss", "EnableAct1Boss", "Act 1 Boss");

		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("llbol.char.exrumia", "");

		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("lvalonexrumia", func, (Assembly)null);
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "llbol.char.exrumia";

		public const string Name = "EX Rumia";

		public const string version = "1.0.6";

		public static readonly Harmony harmony = new Harmony("llbol.char.exrumia");
	}
	public class lvalonexrumiaLoadouts
	{
		public static string UltimateSkillA = "exulta";

		public static string UltimateSkillB = "exultb";

		public static string ExhibitA = "exexa";

		public static string ExhibitB = "exexb";

		public static List<string> DeckA = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "cardexaa", "cardexaa", "cardexab", "cardexab", "cardbite", "cardbloodwork" };

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "cardexba", "cardexba", "cardexbb", "cardexbb", "cardexbb", "cardblooduse" };

		public static PlayerUnitConfig playerUnitConfig;

		static lvalonexrumiaLoadouts()
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Black = 2;
			((ManaGroup)(ref val)).Red = 2;
			ManaGroup val2 = val;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, false, "", 0, 1000, num, true, (int?)null, (ManaColor)3, (ManaColor)4, val2, "#FF0808", 100, 50, 0, UltimateSkillA, UltimateSkillB, ExhibitA, ExhibitB, (IReadOnlyList<string>)DeckA, (IReadOnlyList<string>)DeckB, 3, 3);
		}
	}
	public sealed class lvalonexrumiaDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(lvalonexrumiaDef))]
		public sealed class lvalonexrumia : PlayerUnit
		{
		}

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

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

		public override EikiSummonInfo AssociateEikiSummon()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new EikiSummonInfo(typeof(global::lvalonexrumia.Enemies.lvalonexrumia), (string)null);
		}

		public override PlayerUnitConfig MakeConfig()
		{
			return lvalonexrumiaLoadouts.playerUnitConfig;
		}
	}
	public abstract class toolbox
	{
		[CompilerGenerated]
		private sealed class <EnumerateALLCardTypes>d__6 : IEnumerable<(Type, CardConfig)>, IEnumerable, IEnumerator<(Type, CardConfig)>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private (Type, CardConfig) <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<CardConfig> <>s__1;

			private CardConfig <item>5__2;

			private Type <type2>5__3;

			(Type, CardConfig) IEnumerator<(Type, CardConfig)>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00a4;
					}
					<>1__state = -1;
					<>s__1 = CardConfig.AllConfig().GetEnumerator();
					<>1__state = -3;
					goto IL_00b3;
					IL_00a4:
					<type2>5__3 = null;
					<item>5__2 = null;
					goto IL_00b3;
					IL_00b3:
					if (<>s__1.MoveNext())
					{
						<item>5__2 = <>s__1.Current;
						<type2>5__3 = TypeFactory<Card>.TryGetType(<item>5__2.Id);
						if ((object)<type2>5__3 != null)
						{
							<>2__current = (<type2>5__3, <item>5__2);
							<>1__state = 1;
							return true;
						}
						goto IL_00a4;
					}
					<>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<(Type, CardConfig)> IEnumerable<(Type, CardConfig)>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateALLCardTypes>d__6(0);
			}

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

		[CompilerGenerated]
		private sealed class <EnumerateALLExhibitTypes>d__7 : IEnumerable<(Type, ExhibitConfig)>, IEnumerable, IEnumerator<(Type, ExhibitConfig)>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private (Type, ExhibitConfig) <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<ExhibitConfig> <>s__1;

			private ExhibitConfig <item>5__2;

			private Type <type>5__3;

			(Type, ExhibitConfig) IEnumerator<(Type, ExhibitConfig)>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

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

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00a4;
					}
					<>1__state = -1;
					<>s__1 = ExhibitConfig.AllConfig().GetEnumerator();
					<>1__state = -3;
					goto IL_00b3;
					IL_00a4:
					<type>5__3 = null;
					<item>5__2 = null;
					goto IL_00b3;
					IL_00b3:
					if (<>s__1.MoveNext())
					{
						<item>5__2 = <>s__1.Current;
						<type>5__3 = TypeFactory<Exhibit>.TryGetType(<item>5__2.Id);
						if ((object)<type>5__3 != null)
						{
							<>2__current = (<type>5__3, <item>5__2);
							<>1__state = 1;
							return true;
						}
						goto IL_00a4;
					}
					<>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<(Type, ExhibitConfig)> IEnumerable<(Type, ExhibitConfig)>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateALLExhibitTypes>d__7(0);
			}

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

		public static int hpfrompercent(Unit unit, int percent, bool maxhp)
		{
			if (unit == null)
			{
				return 0;
			}
			if (maxhp)
			{
				return Convert.ToInt32(Math.Round((double)unit.MaxHp * (double)percent / 100.0, MidpointRounding.AwayFromZero));
			}
			return Convert.ToInt32(Math.Round((double)unit.Hp * (double)percent / 100.0, MidpointRounding.AwayFromZero));
		}

		public static Card[] RollCardsCustomIgnore(RandomGen rng, CardWeightTable weightTable, int count, ManaGroup? manaLimit = null, bool colorLimit = false, bool applyFactors = false, bool battleRolling = false, bool ensureCount = false, Predicate<Card> filter = null)
		{
			GameMaster instance = Singleton<GameMaster>.Instance;
			GameRunController val = ((instance != null) ? instance.CurrentGameRun : null);
			if (val == null)
			{
				throw new InvalidOperationException("Rolling cards when run is not started.");
			}
			UniqueRandomPool<Type> val2 = val.CreateValidCardsPool(weightTable, manaLimit, colorLimit, applyFactors, battleRolling, (Predicate<CardConfig>)null);
			UniqueRandomPool<Card> val3 = new UniqueRandomPool<Card>(false);
			foreach (RandomPoolEntry<Type> item in val2)
			{
				Card val4 = Library.CreateCard(item.Elem);
				if (filter(val4))
				{
					((GameEntity)val4).GameRun = val;
					val3.Add(val4, item.Weight);
				}
			}
			return val3.SampleMany(rng, count, ensureCount);
		}

		public static Card[] RollCardsCustom(RandomGen rng, CardWeightTable weightTable, int count, ManaGroup? manaLimit = null, bool colorLimit = false, bool applyFactors = false, bool battleRolling = false, bool ensureCount = false, Predicate<Card> filter = null)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			GameMaster instance = Singleton<GameMaster>.Instance;
			GameRunController val = ((instance != null) ? instance.CurrentGameRun : null);
			if (val == null)
			{
				throw new InvalidOperationException("Rolling cards when run is not started.");
			}
			UniqueRandomPool<Type> val2 = val.CreateValidCardsPool(weightTable, manaLimit, colorLimit, applyFactors, battleRolling, (Predicate<CardConfig>)null);
			UniqueRandomPool<Card> val3 = new UniqueRandomPool<Card>(false);
			foreach (RandomPoolEntry<Type> item in val2)
			{
				Card val4 = Library.CreateCard(item.Elem);
				if (filter(val4))
				{
					ManaGroup baseMana = val.BaseMana;
					if (((ManaGroup)(ref baseMana)).CanAfford(val4.Cost))
					{
						((GameEntity)val4).GameRun = val;
						val3.Add(val4, item.Weight);
					}
				}
			}
			return val3.SampleMany(rng, count, ensureCount);
		}

		public static Card[] RepeatableAllCards(RandomGen rng, CardWeightTable weightTable, int count, bool ensureCount = false, Predicate<Card> filter = null)
		{
			GameMaster instance = Singleton<GameMaster>.Instance;
			GameRunController val = ((instance != null) ? instance.CurrentGameRun : null);
			if (val == null)
			{
				throw new InvalidOperationException("Rolling cards when run is not started.");
			}
			UniqueRandomPool<Type> val2 = CreateAllCardsPool(weightTable);
			RepeatableRandomPool<Card> val3 = new RepeatableRandomPool<Card>();
			foreach (RandomPoolEntry<Type> item in val2)
			{
				Card val4 = Library.CreateCard(item.Elem);
				if (filter(val4))
				{
					((GameEntity)val4).GameRun = val;
					val3.Add(val4, item.Weight);
				}
			}
			return val3.SampleMany(rng, count, ensureCount);
		}

		public static Card[] UniqueAllCards(RandomGen rng, CardWeightTable weightTable, int count, bool ensureCount = false, Predicate<Card> filter = null)
		{
			GameMaster instance = Singleton<GameMaster>.Instance;
			GameRunController val = ((instance != null) ? instance.CurrentGameRun : null);
			if (val == null)
			{
				throw new InvalidOperationException("Rolling cards when run is not started.");
			}
			UniqueRandomPool<Type> val2 = CreateAllCardsPool(weightTable);
			UniqueRandomPool<Card> val3 = new UniqueRandomPool<Card>(false);
			foreach (RandomPoolEntry<Type> item in val2)
			{
				Card val4 = Library.CreateCard(item.Elem);
				if (filter(val4))
				{
					((GameEntity)val4).GameRun = val;
					val3.Add(val4, item.Weight);
				}
			}
			return val3.SampleMany(rng, count, ensureCount);
		}

		public static UniqueRandomPool<Type> CreateAllCardsPool(CardWeightTable weightTable, [MaybeNull] Predicate<CardConfig> filter = null)
		{
			GameRunController currentGameRun = Singleton<GameMaster>.Instance.CurrentGameRun;
			HashSet<string> hashSet = new HashSet<string>(from e in currentGameRun.Player.Exhibits
				where e.OwnerId != null
				select e.OwnerId);
			UniqueRandomPool<Type> val = new UniqueRandomPool<Type>(false);
			foreach (var (type, obj) in EnumerateALLCardTypes())
			{
				if (filter == null || filter(obj))
				{
					val.Add(type, 1f);
				}
			}
			return val;
		}

		[IteratorStateMachine(typeof(<EnumerateALLCardTypes>d__6))]
		public static IEnumerable<(Type, CardConfig)> EnumerateALLCardTypes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateALLCardTypes>d__6(-2);
		}

		[IteratorStateMachine(typeof(<EnumerateALLExhibitTypes>d__7))]
		public static IEnumerable<(Type, ExhibitConfig)> EnumerateALLExhibitTypes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateALLExhibitTypes>d__7(-2);
		}

		public static UniqueRandomPool<Type> CreateAllExhibitsPool(ExhibitWeightTable weightTable, [MaybeNull] Predicate<ExhibitConfig> filter = null)
		{
			UniqueRandomPool<Type> result = new UniqueRandomPool<Type>(false);
			foreach (var item2 in EnumerateALLExhibitTypes())
			{
				ExhibitConfig item = item2.Item2;
				if (filter != null && filter(item))
				{
				}
			}
			return result;
		}

		public static Card createcardwithidBACKUP(string id)
		{
			UniqueRandomPool<Type> val = new UniqueRandomPool<Type>(false);
			foreach (var (type, val2) in EnumerateALLCardTypes())
			{
				if (val2.Id == id)
				{
					val.Add(type, 1f);
				}
			}
			UniqueRandomPool<Card> val3 = new UniqueRandomPool<Card>(false);
			foreach (RandomPoolEntry<Type> item in val)
			{
				Card val4 = Library.CreateCard(item.Elem);
				val3.Add(val4, item.Weight);
			}
			return val3.Sample(RandomGen.InitGen);
		}

		public static Card createcardwithid(string id)
		{
			return TypeFactory<Card>.CreateInstance(TypeFactory<Card>.TryGetType(id));
		}
	}
}
namespace lvalonexrumia.lvalonexrumiaUlt
{
	public sealed class exultaDef : lvalonexrumiaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 10;
			defaulUltConfig.Value1 = 1;
			defaulUltConfig.Value2 = 3;
			defaulUltConfig.RelativeEffects = new List<string> { "sebloodmark" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(exultaDef))]
	public sealed class exulta : 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 exulta <>4__this;

			private EnemyUnit <enemy>5__1;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "exulta");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					if (((Unit)<enemy>5__1).IsAlive && !((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<sebloodmark>((Unit)(object)<enemy>5__1, (int?)((UltimateSkill)<>4__this).Value1, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					<i>5__2 = 0;
					goto IL_017e;
				case 3:
					{
						<>1__state = -1;
						goto IL_016d;
					}
					IL_017e:
					if (<i>5__2 >= ((UltimateSkill)<>4__this).Value2)
					{
						break;
					}
					if (((Unit)<enemy>5__1).IsAlive && !((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
					{
						<>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 = 3;
						return true;
					}
					goto IL_016d;
					IL_016d:
					<i>5__2++;
					goto IL_017e;
				}
				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 exulta()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(7021);
		}

		[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 exultbDef : lvalonexrumiaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 10;
			defaulUltConfig.Value1 = 1;
			defaulUltConfig.Value2 = 2;
			defaulUltConfig.RelativeEffects = new List<string> { "sebleed" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(exultbDef))]
	public sealed class exultb : 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 exultb <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private Unit <unit>5__2;

			private int <i>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "exultb");
						<>1__state = 1;
						result = true;
						goto end_IL_0000;
					case 1:
						<>1__state = -1;
						<>s__1 = ((UltimateSkill)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						goto IL_010f;
					case 2:
						<>1__state = -3;
						<unit>5__2 = null;
						goto IL_010f;
					case 3:
						{
							<>1__state = -1;
							<i>5__3++;
							break;
						}
						IL_010f:
						if (<>s__1.MoveNext())
						{
							<unit>5__2 = (Unit)(object)<>s__1.Current;
							if (((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
							{
								result = false;
								<>m__Finally1();
							}
							else
							{
								<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<sebleed>(<unit>5__2, (int?)1, (int?)0, (int?)0, (int?)0, 0.2f, true);
								<>1__state = 2;
								result = true;
							}
						}
						else
						{
							<>m__Finally1();
							<>s__1 = null;
							if (!((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
							{
								<i>5__3 = 0;
								break;
							}
							result = false;
						}
						goto end_IL_0000;
					}
					if (<i>5__3 < ((UltimateSkill)<>4__this).Value2)
					{
						<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (IEnumerable<Unit>)((UltimateSkill)<>4__this).Battle.AllAliveEnemies, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
						<>1__state = 3;
						result = true;
					}
					else
					{
						result = false;
					}
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<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 exultb()
		{
			((UltimateSkill)this).TargetType = (TargetType)2;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(7071);
		}

		[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 extenshadedDef : lvalonexrumiaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			return GetDefaulUltConfig();
		}
	}
	[EntityLogic(typeof(extenshadedDef))]
	public sealed class extenshaded : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__0 : 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 extenshaded <>4__this;

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

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

			[DebuggerHidden]
			public <Actions>d__0(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__0 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

		[IteratorStateMachine(typeof(<Actions>d__0))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__0(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
	public sealed class exshadowcutDef : lvalonexrumiaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			return GetDefaulUltConfig();
		}
	}
	[EntityLogic(typeof(exshadowcutDef))]
	public sealed class exshadowcut : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__0 : 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 exshadowcut <>4__this;

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

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

			[DebuggerHidden]
			public <Actions>d__0(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__0 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

		[IteratorStateMachine(typeof(<Actions>d__0))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__0(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
	public sealed class exgojoDef : lvalonexrumiaUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			return GetDefaulUltConfig();
		}
	}
	[EntityLogic(typeof(exgojoDef))]
	public sealed class exgojo : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__0 : 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 exgojo <>4__this;

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

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

			[DebuggerHidden]
			public <Actions>d__0(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__0 <Actions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Actions>d__ = this;
				}
				else
				{
					<Actions>d__ = new <Actions>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				<Actions>d__.selector = <>3__selector;
				return <Actions>d__;
			}

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

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

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

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

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

		public UltimateSkillConfig GetDefaulUltConfig()
		{
			return lvalonexrumiaDefaultConfig.DefaultUltConfig();
		}
	}
}
namespace lvalonexrumia.StatusEffects
{
	public sealed class seaccelDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "Graze" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(seaccelDef))]
	public sealed class seaccel : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarting>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public seaccel <>4__this;

			private Unit <owner>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Expected O, but got Unknown
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						break;
					}
					((StatusEffect)<>4__this).NotifyActivating();
					<owner>5__1 = ((StatusEffect)<>4__this).Owner;
					if (<owner>5__1 != null && !<owner>5__1.IsDead)
					{
						if (((StatusEffect)<>4__this).Level <= 0)
						{
							<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
							<>1__state = 1;
							return true;
						}
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Graze>(((StatusEffect)<>4__this).Owner, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 2;
						return true;
					}
					goto IL_0148;
				case 1:
					<>1__state = -1;
					return false;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 3;
					return true;
				case 3:
					{
						<>1__state = -1;
						goto IL_0148;
					}
					IL_0148:
					<owner>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()
			{
				<OnOwnerTurnStarting>d__1 <OnOwnerTurnStarting>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnOwnerTurnStarting>d__ = this;
				}
				else
				{
					<OnOwnerTurnStarting>d__ = new <OnOwnerTurnStarting>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnOwnerTurnStarting>d__.args = <>3__args;
				return <OnOwnerTurnStarting>d__;
			}

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

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

		[IteratorStateMachine(typeof(<OnOwnerTurnStarting>d__1))]
		private IEnumerable<BattleAction> OnOwnerTurnStarting(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarting>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class seadrenalineDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "seatkincrease", "sebloodclot" };
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(seadrenalineDef))]
	public sealed class seadrenaline : sereact
	{
		[CompilerGenerated]
		private sealed class <HandleLifeChanged>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private Unit receive;

			public Unit <>3__receive;

			private int amount;

			public int <>3__amount;

			private Unit source;

			public Unit <>3__source;

			private ActionCause cause;

			public ActionCause <>3__cause;

			private GameEntity actionSource;

			public GameEntity <>3__actionSource;

			public seadrenaline <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((StatusEffect)<>4__this).Count = <>4__this.lifeneed;
					((StatusEffect)<>4__this).Highlight = ((StatusEffect)<>4__this).Owner.Hp < <>4__this.lifeneed;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					if (actionSource != <>4__this && amount < 0 && (receive == null || receive == ((StatusEffect)<>4__this).Battle.Player) && !((StatusEffect)<>4__this).Battle.BattleShouldEnd && ((Unit)((StatusEffect)<>4__this).Battle.Player).Hp < toolbox.hpfrompercent((Unit)(object)Singleton<GameMaster>.Instance.CurrentGameRun.Player, 50, maxhp: true))
					{
						((StatusEffect)<>4__this).NotifyActivating();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<seatkincrease>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)(((StatusEffect)<>4__this).Level * 5), (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<sebloodclot>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				<HandleLifeChanged>d__4 <HandleLifeChanged>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<HandleLifeChanged>d__ = this;
				}
				else
				{
					<HandleLifeChanged>d__ = new <HandleLifeChanged>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				<HandleLifeChanged>d__.receive = <>3__receive;
				<HandleLifeChanged>d__.amount = <>3__amount;
				<HandleLifeChanged>d__.source = <>3__source;
				<HandleLifeChanged>d__.cause = <>3__cause;
				<HandleLifeChanged>d__.actionSource = <>3__actionSource;
				return <HandleLifeChanged>d__;
			}

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

		public int atkincrease
		{
			get
			{
				if (((StatusEffect)this).Owner == null)
				{
					return 0;
				}
				return ((StatusEffect)this).Level * 5;
			}
		}

		protected override void dosmth()
		{
			((StatusEffect)this).Count = base.lifeneed;
			((StatusEffect)this).Highlight = ((StatusEffect)this).Owner.Hp < base.lifeneed;
		}

		protected override void OnHealingReceived(HealEventArgs args)
		{
			dosmth();
		}

		[IteratorStateMachine(typeof(<HandleLifeChanged>d__4))]
		protected override IEnumerable<BattleAction> HandleLifeChanged(Unit receive, int amount, Unit source, ActionCause cause, GameEntity actionSource)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HandleLifeChanged>d__4(-2)
			{
				<>4__this = this,
				<>3__receive = receive,
				<>3__amount = amount,
				<>3__source = source,
				<>3__cause = cause,
				<>3__actionSource = actionSource
			};
		}
	}
	public sealed class seatkincreaseDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.Order = 20;
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(seatkincreaseDef))]
	public sealed class seatkincrease : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnTurnEnded>d__7 : 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 seatkincrease <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.truecount = (int)((double)<>4__this.truecount / 10.0) * 5;
					((StatusEffect)<>4__this).Count = <>4__this.truecount;
					if (((StatusEffect)<>4__this).Count <= 0)
					{
						<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				((StatusEffect)<>4__this).NotifyActivating();
				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()
			{
				<OnTurnEnded>d__7 <OnTurnEnded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnTurnEnded>d__ = this;
				}
				else
				{
					<OnTurnEnded>d__ = new <OnTurnEnded>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnTurnEnded>d__.args = <>3__args;
				return <OnTurnEnded>d__;
			}

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

		private int truecount = 0;

		public int truecounter => truecount;

		public override bool ForceNotShowDownText => true;

		protected override void OnAdded(Unit unit)
		{
			if (truecount == 0)
			{
				truecount = ((StatusEffect)this).Level;
				((StatusEffect)this).Count = truecount;
			}
			((StatusEffect)this).Level = 0;
			((StatusEffect)this).HandleOwnerEvent<DamageDealingEventArgs>(((StatusEffect)this).Owner.DamageDealing, (GameEventHandler<DamageDealingEventArgs>)OnDamageDealing);
			((StatusEffect)this).HandleOwnerEvent<StatusEffectApplyEventArgs>(((StatusEffect)this).Owner.StatusEffectAdded, (GameEventHandler<StatusEffectApplyEventArgs>)OnStatusEffectAdded);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((StatusEffect)this).Owner.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnTurnEnded);
		}

		private void OnStatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			if (args.Effect is seatkincrease)
			{
				truecount += args.Effect.Level;
				((StatusEffect)this).Count = truecount;
				((StatusEffect)this).Level = 0;
			}
		}

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

		private void OnDamageDealing(DamageDealingEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			DamageInfo damageInfo = args.DamageInfo;
			if ((int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				damageInfo = args.DamageInfo;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).MultiplyBy((float)truecount * 1f / 100f + 1f);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
				if ((int)((GameEventArgs)args).Cause != 20)
				{
					((StatusEffect)this).NotifyActivating();
				}
			}
		}
	}
	public sealed class sebewaterDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebewaterDef))]
	public sealed class sebewater : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsed>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardUsingEventArgs args;

			public CardUsingEventArgs <>3__args;

			public sebewater <>4__this;

			private SelectCardInteraction <interaction>5__1;

			private IReadOnlyList<Card> <cards>5__2;

			private IEnumerator<Card> <>s__3;

			private Card <card>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<interaction>5__1 = null;
				<cards>5__2 = null;
				<>s__3 = null;
				<card>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Expected O, but got Unknown
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Expected O, but got Unknown
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Expected O, but got Unknown
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (((StatusEffect)<>4__this).Battle.BattleShouldEnd || (!(args.Card is cardredblood) && !(args.Card is carddarkblood)))
						{
							return false;
						}
						((StatusEffect)<>4__this).NotifyActivating();
						if (((StatusEffect)<>4__this).Battle.DiscardZone.Count > 0)
						{
							<interaction>5__1 = new SelectCardInteraction(0, ((StatusEffect)<>4__this).Level, (IEnumerable<Card>)((StatusEffect)<>4__this).Battle.DiscardZone, (SelectedCardHandling)0)
							{
								Source = (GameEntity)(object)<>4__this
							};
							<>2__current = (BattleAction)new InteractionAction((Interaction)(object)<interaction>5__1, false);
							<>1__state = 1;
							return true;
						}
						goto IL_01bf;
					case 1:
						<>1__state = -1;
						<cards>5__2 = <interaction>5__1.SelectedCards;
						if (<cards>5__2.Count > 0)
						{
							<>s__3 = <cards>5__2.GetEnumerator();
							<>1__state = -3;
							goto IL_0194;
						}
						goto IL_01b0;
					case 2:
						<>1__state = -3;
						<card>5__4 = null;
						goto IL_0194;
					case 3:
						{
							<>1__state = -1;
							return false;
						}
						IL_0194:
						if (<>s__3.MoveNext())
						{
							<card>5__4 = <>s__3.Current;
							<>2__current = (BattleAction)new MoveCardToDrawZoneAction(<card>5__4, (DrawZoneTarget)2);
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>s__3 = null;
						goto IL_01b0;
						IL_01bf:
						<>2__current = (BattleAction)new DrawManyCardAction(((StatusEffect)<>4__this).Level);
						<>1__state = 3;
						return true;
						IL_01b0:
						<interaction>5__1 = null;
						<cards>5__2 = null;
						goto IL_01bf;
					}
				}
				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__3 != null)
				{
					<>s__3.Dispose();
				}
			}

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

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

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

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

		[IteratorStateMachine(typeof(<OnCardUsed>d__1))]
		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnCardUsed>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class sebleedDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)1;
			defaultStatusEffectConfig.HasCount = true;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "sedecrease" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebleedDef))]
	public sealed class sebleed : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnDamageReceived>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DamageEventArgs args;

			public DamageEventArgs <>3__args;

			public sebleed <>4__this;

			private DamageInfo <damageInfo>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<damageInfo>5__1 = args.DamageInfo;
					if ((int)((DamageInfo)(ref <damageInfo>5__1)).DamageType == 2)
					{
						((StatusEffect)<>4__this).NotifyActivating();
						if (args.Target.IsNotAlive)
						{
							return false;
						}
						<>2__current = (BattleAction)(object)new ChangeLifeAction(-(int)Math.Ceiling((float)args.Target.MaxHp * 0.01f), args.Target);
						<>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()
			{
				<OnDamageReceived>d__5 <OnDamageReceived>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnDamageReceived>d__ = this;
				}
				else
				{
					<OnDamageReceived>d__ = new <OnDamageReceived>d__5(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnDamageReceived>d__.args = <>3__args;
				return <OnDamageReceived>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OnTurnEnding>d__6 : 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 sebleed <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					((StatusEffect)<>4__this).NotifyActivating();
					if (((StatusEffect)<>4__this).Level > 1)
					{
						int level = ((StatusEffect)<>4__this).Level;
						((StatusEffect)<>4__this).Level = level - 1;
						break;
					}
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		public int truecount
		{
			get
			{
				if (((StatusEffect)this).Owner != null)
				{
					return (int)Math.Ceiling((float)((StatusEffect)this).Owner.MaxHp * 0.01f);
				}
				return 0;
			}
		}

		public int lifenow
		{
			get
			{
				if (((StatusEffect)this).Owner != null)
				{
					return ((StatusEffect)this).Owner.Hp;
				}
				return 0;
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).Count = (int)Math.Ceiling((float)unit.MaxHp * 0.01f);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(unit.DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnDamageReceived);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnEnding, (EventSequencedReactor<UnitEventArgs>)OnTurnEnding);
		}

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

		[IteratorStateMachine(typeof(<OnTurnEnding>d__6))]
		private IEnumerable<BattleAction> OnTurnEnding(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnTurnEnding>d__6(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class sebleedslashDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "sebloodsword", "sebloodmark" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebleedslashDef))]
	public sealed class sebleedslash : 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 sebleedslash <>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()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					if (args.Card.Config.Colors.Contains((ManaColor)3))
					{
						((StatusEffect)<>4__this).NotifyActivating();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<sebloodsword>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		private void OnTurnEnded(UnitEventArgs args)
		{
		}

		[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
			};
		}
	}
	public sealed class sebloodcircleDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebloodcircleDef))]
	public sealed class sebloodcircle : 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 sebloodcircle <>4__this;

			private List<Card> <list>5__1;

			private SelectCardInteraction <interaction>5__2;

			private IReadOnlyList<Card> <cards>5__3;

			private IEnumerator<Card> <>s__4;

			private Card <card>5__5;

			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()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<list>5__1 = null;
				<interaction>5__2 = null;
				<cards>5__3 = null;
				<>s__4 = null;
				<card>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Expected O, but got Unknown
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<list>5__1 = ((StatusEffect)<>4__this).Battle.ExileZone.Where((Card card) => card is carddarkblood || card is cardredblood).ToList();
						if (((StatusEffect)<>4__this).Battle.BattleShouldEnd || <list>5__1.Count == 0)
						{
							return false;
						}
						((StatusEffect)<>4__this).NotifyActivating();
						<interaction>5__2 = new SelectCardInteraction(0, <list>5__1.Count, (IEnumerable<Card>)<list>5__1, (SelectedCardHandling)0)
						{
							Source = (GameEntity)(object)<>4__this
						};
						<>2__current = (BattleAction)new InteractionAction((Interaction)(object)<interaction>5__2, false);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<cards>5__3 = <interaction>5__2.SelectedCards;
						if (<cards>5__3.Count <= 0)
						{
							break;
						}
						<>s__4 = <cards>5__3.GetEnumerator();
						<>1__state = -3;
						goto IL_019f;
					case 2:
						{
							<>1__state = -3;
							goto IL_0197;
						}
						IL_019f:
						if (<>s__4.MoveNext())
						{
							<card>5__5 = <>s__4.Current;
							if (!((StatusEffect)<>4__this).Battle.HandIsFull)
							{
								<>2__current = (BattleAction)new MoveCardAction(<card>5__5, (CardZone)2);
								<>1__state = 2;
								return true;
							}
							goto IL_0197;
						}
						<>m__Finally1();
						<>s__4 = null;
						break;
						IL_0197:
						<card>5__5 = null;
						goto IL_019f;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

		public override bool ForceNotShowDownText => true;

		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 sebloodclotDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 9;
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebloodclotDef))]
	public sealed class sebloodclot : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnRoundEnded>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public sebloodclot <>4__this;

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

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

			[DebuggerHidden]
			public <OnRoundEnded>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_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 (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public int Value
		{
			get
			{
				if (((StatusEffect)this).Owner == null)
				{
					return 5;
				}
				if (((StatusEffect)this).Level == 0)
				{
					return 5;
				}
				return Math.Min(5 * ((StatusEffect)this).Level, 50);
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(unit.DamageReceiving, (GameEventHandler<DamageEventArgs>)OnDamageReceiving);
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(((StatusEffect)this).Battle.RoundEnded, (EventSequencedReactor<GameEventArgs>)OnRoundEnded);
		}

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

		private void OnDamageReceiving(DamageEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			if ((int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				((DamageInfo)(ref damageInfo)).Damage = ((DamageInfo)(ref damageInfo)).Amount * (1f - (float)Value / 100f);
				args.DamageInfo = damageInfo;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}
	}
	public sealed class sebloodcontractDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "sebloodsword" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebloodcontractDef))]
	public sealed class sebloodcontract : sereact
	{
		[CompilerGenerated]
		private sealed class <HandleLifeChanged>d__0 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private Unit receive;

			public Unit <>3__receive;

			private int amount;

			public int <>3__amount;

			private Unit source;

			public Unit <>3__source;

			private ActionCause cause;

			public ActionCause <>3__cause;

			private GameEntity actionSource;

			public GameEntity <>3__actionSource;

			public sebloodcontract <>4__this;

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

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

			[DebuggerHidden]
			public <HandleLifeChanged>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;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					if (actionSource != <>4__this && amount < 0 && (receive == null || receive == ((StatusEffect)<>4__this).Battle.Player) && !((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						((StatusEffect)<>4__this).NotifyActivating();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<sebloodsword>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				<HandleLifeChanged>d__0 <HandleLifeChanged>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<HandleLifeChanged>d__ = this;
				}
				else
				{
					<HandleLifeChanged>d__ = new <HandleLifeChanged>d__0(0)
					{
						<>4__this = <>4__this
					};
				}
				<HandleLifeChanged>d__.receive = <>3__receive;
				<HandleLifeChanged>d__.amount = <>3__amount;
				<HandleLifeChanged>d__.source = <>3__source;
				<HandleLifeChanged>d__.cause = <>3__cause;
				<HandleLifeChanged>d__.actionSource = <>3__actionSource;
				return <HandleLifeChanged>d__;
			}

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

		[IteratorStateMachine(typeof(<HandleLifeChanged>d__0))]
		protected override IEnumerable<BattleAction> HandleLifeChanged(Unit receive, int amount, Unit source, ActionCause cause, GameEntity actionSource)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HandleLifeChanged>d__0(-2)
			{
				<>4__this = this,
				<>3__receive = receive,
				<>3__amount = amount,
				<>3__source = source,
				<>3__cause = cause,
				<>3__actionSource = actionSource
			};
		}
	}
	public sealed class sebloodmarkDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Order = 9;
			defaultStatusEffectConfig.Type = (StatusEffectType)1;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebloodmarkDef))]
	public sealed class sebloodmark : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnTurnEnding>d__4 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public sebloodmark <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					((StatusEffect)<>4__this).NotifyActivating();
					if (((StatusEffect)<>4__this).Level > 1)
					{
						int level = ((StatusEffect)<>4__this).Level;
						((StatusEffect)<>4__this).Level = level - 1;
						break;
					}
					<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		public int Value
		{
			get
			{
				if (((StatusEffect)this).Owner == null)
				{
					return 20;
				}
				if (((StatusEffect)this).Level == 0)
				{
					return 20;
				}
				return 20 * ((StatusEffect)this).Level;
			}
		}

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(unit.DamageReceiving, (GameEventHandler<DamageEventArgs>)OnDamageReceiving);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnStarting, (EventSequencedReactor<UnitEventArgs>)OnTurnEnding);
		}

		private void OnDamageReceiving(DamageEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			if ((int)((DamageInfo)(ref damageInfo)).DamageType == 2)
			{
				((DamageInfo)(ref damageInfo)).Damage = ((DamageInfo)(ref damageInfo)).Amount * (1f + (float)Value / 100f);
				args.DamageInfo = damageInfo;
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DamageEventArgs args;

			public DamageEventArgs <>3__args;

			public sebloodofmysword <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!args.Target.IsNotAlive && args.Target.Hp != 0)
					{
						DamageInfo damageInfo = args.DamageInfo;
						if ((int)((DamageInfo)(ref damageInfo)).DamageType == 2)
						{
							<>2__current = (BattleAction)(object)new ChangeLifeAction(((StatusEffect)<>4__this).Level, args.Target);
							<>1__state = 1;
							return true;
						}
					}
					return false;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<TempFirepower>(((StatusEffect)<>4__this).Owner, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)0, (int?)0, 0.2f, true);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

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

		[IteratorStateMachine(typeof(<OnDamageDealt>d__1))]
		private IEnumerable<BattleAction> OnDamageDealt(DamageEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnDamageDealt>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class sebloodstormDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebloodstormDef))]
	public sealed class sebloodstorm : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnStatusEffectAdded>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatusEffectApplyEventArgs args;

			public StatusEffectApplyEventArgs <>3__args;

			public sebloodstorm <>4__this;

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

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

			[DebuggerHidden]
			public <OnStatusEffectAdded>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_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Effect is sebloodstorm && ((StatusEffect)<>4__this).Level >= <>4__this.lim)
					{
						((StatusEffect)<>4__this).NotifyActivating();
						<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<cardbloodstorm>(((StatusEffect)<>4__this).Level / <>4__this.lim, false), (AddCardsType)0, false);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					((StatusEffect)<>4__this).Level = ((StatusEffect)<>4__this).Level % <>4__this.lim;
					if (((StatusEffect)<>4__this).Level == 0)
					{
						<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		public int lim => 4;

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

		[IteratorStateMachine(typeof(<OnStatusEffectAdded>d__3))]
		private IEnumerable<BattleAction> OnStatusEffectAdded(StatusEffectApplyEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnStatusEffectAdded>d__3(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class sebloodswordDef : lvalonexrumiaStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = lvalonexrumiaStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(sebloodswordDef))]
	public sealed class sebloodsword : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnStatusEffectAdded>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatusEffectApplyEventArgs args;

			public StatusEffectApplyEventArgs <>3__args;

			public sebloodsword <>4__this;

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

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

			[DebuggerHidden]
			public <OnStatusEffectAdded>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_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Effect is sebloodsword && ((StatusEffect)<>4__this).Level >= <>4__this.lim)
					{
						((StatusEffect)<>4__this).NotifyActivating();
						<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<cardbloodsword>(((StatusEffect)<>4__this).Level / <>4__this.lim, false), (AddCardsType)0, false);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					((StatusEffect)<>4__this).Level = ((StatusEffect)<>4__this).Level % <>4__this.lim;
					if (((StatusEffect)<>4__this).Level == 0)
					{
						<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		public int lim => 5;

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