using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AddWatermark;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using HarmonyLib;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Adventures;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Battle.Interactions;
using LBoL.Core.Cards;
using LBoL.Core.Randoms;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Adventures;
using LBoL.EntityLib.Cards.Neutral.NoColor;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.Exhibits.Shining;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Cirno;
using LBoL.EntityLib.StatusEffects.Neutral.TwoColor;
using LBoL.EntityLib.StatusEffects.Others;
using LBoL.Presentation;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using MoriyaSuwakoMod.BattleActions;
using MoriyaSuwakoMod.Cards.Template;
using MoriyaSuwakoMod.Config;
using MoriyaSuwakoMod.Enemies.Template;
using MoriyaSuwakoMod.Exhibits;
using MoriyaSuwakoMod.GunName;
using MoriyaSuwakoMod.ImageLoader;
using MoriyaSuwakoMod.Localization;
using MoriyaSuwakoMod.Patches;
using MoriyaSuwakoMod.Source.Cards.Template;
using MoriyaSuwakoMod.Source.Exhibits;
using MoriyaSuwakoMod.Source.StatusEffects;
using MoriyaSuwakoMod.Source.Untils;
using MoriyaSuwakoMod.StatusEffects;
using UnityEngine;
using UnityEngine.Experimental.Rendering;

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

		public static string playerName = "MoriyaSuwako";

		public static bool useInGameModel = true;

		public static string modelName = "SuwakoLimao";

		public static bool modelIsFlipped = true;

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

		public static ConfigEntry<bool> enableAct1Boss;

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

		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

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

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

		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();
			if (Chainloader.PluginInfos.ContainsKey("neo.lbol.tools.watermark"))
			{
				WatermarkWrapper.ActivateWatermark();
			}
		}

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

		public const string Name = "MoriyaSuwakoMod";

		public const string version = "0.0.1";

		public static readonly Harmony harmony = new Harmony("author.game.typeofmod.MoriyaSuwako");
	}
	public class MoriyaSuwakoLoadouts
	{
		public static string UltimateSkillA = "MoriyaSuwakoUltA";

		public static string UltimateSkillB = "MoriyaSuwakoUltB";

		public static string ExhibitA = "MoriyaSuwakoExhibitA";

		public static string ExhibitB = "MoriyaSuwakoExhibitB";

		public static List<string> DeckA = new List<string>
		{
			"Shoot", "Shoot", "Boundary", "Boundary", "MoriyaSuwakoShoot", "MoriyaSuwakoShoot", "MoriyaSuwakoSquatGuard", "MoriyaSuwakoSquatGuard", "MoriyaSuwakoSquatGuard", "MoriyaSuwakoVitalityPeel",
			"MoriyaSuwakoControl"
		};

		public static List<string> DeckB = new List<string>
		{
			"Shoot", "Shoot", "Boundary", "Boundary", "MoriyaSuwakoAttack", "MoriyaSuwakoAttack", "MoriyaSuwakoAttack", "MoriyaSuwakoDisguiseGuard", "MoriyaSuwakoDisguiseGuard", "MoriyaSuwakoDefensivePosture",
			"MoriyaSuwakoFrogSortie"
		};

		public static PlayerUnitConfig playerUnitConfig;

		static MoriyaSuwakoLoadouts()
		{
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 0;
			((ManaGroup)(ref val)).Blue = 1;
			((ManaGroup)(ref val)).Black = 1;
			((ManaGroup)(ref val)).Red = 0;
			((ManaGroup)(ref val)).Green = 0;
			((ManaGroup)(ref val)).Colorless = 0;
			((ManaGroup)(ref val)).Philosophy = 2;
			ManaGroup val2 = val;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, true, "", 0, 8, num, true, (int?)null, (ManaColor)2, (ManaColor)3, val2, "#e58c27", 85, 75, 0, UltimateSkillA, UltimateSkillB, ExhibitA, ExhibitB, (IReadOnlyList<string>)DeckA, (IReadOnlyList<string>)DeckB, 3, 2);
		}
	}
	public sealed class MoriyaSuwakoModDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(MoriyaSuwakoModDef))]
		public sealed class MoriyaSuwakoMod : 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)MoriyaSuwakoLocalization.PlayerUnitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

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

		public override PlayerUnitConfig MakeConfig()
		{
			return MoriyaSuwakoLoadouts.playerUnitConfig;
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace MoriyaSuwakoMod.MoriyaSuwakoUlt
{
	public sealed class MoriyaSuwakoUltADef : MoriyaSuwakoUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 36;
			defaulUltConfig.Value1 = 1;
			defaulUltConfig.Keywords = (Keyword)256;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoUltADef))]
	public sealed class MoriyaSuwakoUltA : 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 MoriyaSuwakoUltA <>4__this;

			private EnemyUnit <enemy>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: 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).Owner, "MoriyaSuwakoUltA");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<MoriyaSuwakoFateControlSe>((Unit)(object)((UltimateSkill)<>4__this).Owner, (int?)((UltimateSkill)<>4__this).Value1, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public MoriyaSuwakoUltA()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(7031);
		}

		[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 MoriyaSuwakoUltBDef : MoriyaSuwakoUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Value1 = 20;
			defaulUltConfig.RelativeEffects = new List<string> { "MoriyaSuwakoCurseDivinationSe" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoUltBDef))]
	public sealed class MoriyaSuwakoUltB : 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 MoriyaSuwakoUltB <>4__this;

			private IEnumerator<EnemyUnit> <>s__1;

			private EnemyUnit <enemy>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()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>s__1 = null;
				<enemy>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Owner, "MoriyaSuwakoUltB");
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>s__1 = ((UltimateSkill)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						goto IL_0100;
					case 2:
						{
							<>1__state = -3;
							goto IL_00f8;
						}
						IL_0100:
						if (<>s__1.MoveNext())
						{
							<enemy>5__2 = <>s__1.Current;
							if (((Unit)<enemy>5__2).IsAlive)
							{
								<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<MoriyaSuwakoCurseDivinationSe>((Unit)(object)<enemy>5__2, (int?)((UltimateSkill)<>4__this).Value1, (int?)0, (int?)0, (int?)0, 0.2f, true);
								<>1__state = 2;
								return true;
							}
							goto IL_00f8;
						}
						<>m__Finally1();
						<>s__1 = null;
						return false;
						IL_00f8:
						<enemy>5__2 = null;
						goto IL_0100;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

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

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

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

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

		public UltimateSkillConfig GetDefaulUltConfig()
		{
			return MoriyaSuwakoDefaultConfig.DefaultUltConfig();
		}
	}
}
namespace MoriyaSuwakoMod.StatusEffects
{
	public class MoriyaSuwakoStatusEffectTemplate : StatusEffectTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(MoriyaSuwakoDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public static StatusEffectConfig GetDefaultStatusEffectConfig()
		{
			return MoriyaSuwakoDefaultConfig.DefaultStatusEffectConfig();
		}
	}
}
namespace MoriyaSuwakoMod.Patches
{
	[HarmonyPatch]
	internal class CustomGameEventManager
	{
		public static GameEvent<BuffAttackEventArgs> PreCustomEvent { get; set; }

		public static GameEvent<BuffAttackEventArgs> PostCustomEvent { get; set; }

		[HarmonyPatch(typeof(GameRunController), "EnterBattle")]
		private static bool Prefix(GameRunController __instance)
		{
			PreCustomEvent = new GameEvent<BuffAttackEventArgs>();
			PostCustomEvent = new GameEvent<BuffAttackEventArgs>();
			return true;
		}
	}
}
namespace MoriyaSuwakoMod.model
{
	public sealed class MoriyaSuwakoModel : UnitModelTemplate
	{
		public static bool useInGameModel = BepinexPlugin.useInGameModel;

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

		public static string spellsprite_name = "MoriyaSuwakoSkillStand.png";

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

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

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

		public override UniTask<Sprite> LoadSpellSprite()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (useInGameModel)
			{
				return ResourceLoader.LoadSpriteAsync(spellsprite_name, BepinexPlugin.directorySource, 100, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://");
			}
			return ResourceLoader.LoadSpriteAsync(spellsprite_name, BepinexPlugin.directorySource, 100, (GraphicsFormat)4, 1, (FilterMode)1, (SpriteMeshType)1, (Rect?)null, (Vector2?)null, "file://");
		}

		public override UnitModelConfig MakeConfig()
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (useInGameModel)
			{
				UnitModelConfig val = ObjectExtensions.Copy<UnitModelConfig>(UnitModelConfig.FromName(model_name));
				val.HasSpellPortrait = true;
				val.Flip = BepinexPlugin.modelIsFlipped;
				val.SpellColor = new List<Color32>
				{
					new Color32((byte)230, (byte)72, (byte)230, byte.MaxValue),
					new Color32((byte)213, (byte)118, (byte)223, byte.MaxValue),
					new Color32((byte)213, (byte)118, (byte)223, (byte)150),
					new Color32((byte)208, (byte)127, (byte)220, byte.MaxValue)
				};
				val.SpellScale = 0.45f;
				return val;
			}
			UnitModelConfig val2 = ObjectExtensions.Copy<UnitModelConfig>(((UnitModelTemplate)this).DefaultConfig());
			val2.Flip = BepinexPlugin.modelIsFlipped;
			val2.Type = 0;
			val2.Offset = new Vector2(0f, -0.1f);
			val2.HasSpellPortrait = true;
			return val2;
		}
	}
}
namespace MoriyaSuwakoMod.Localization
{
	public sealed class MoriyaSuwakoLocalization
	{
		public static string Cards = "Cards";

		public static string Exhibits = "Exhibits";

		public static string PlayerUnit = "PlayerUnit";

		public static string EnemiesUnit = "EnemyUnit";

		public static string UnitModel = "UnitModel";

		public static string UltimateSkills = "UltimateSkills";

		public static string StatusEffects = "StatusEffects";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		public static string GetGunFromId(int id)
		{
			string text = "";
			try
			{
				return (from config in gunConfig
					where config.Id == id
					select config.Name).ToList()[0];
			}
			catch
			{
				Debug.Log((object)("id: " + id + " doesn't exist. Check whether the ID is correct."));
				return "Instant";
			}
		}
	}
}
namespace MoriyaSuwakoMod.Exhibits
{
	public class MoriyaSuwakoExhibitTemplate : ExhibitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(MoriyaSuwakoDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public ExhibitConfig GetDefaultExhibitConfig()
		{
			return MoriyaSuwakoDefaultConfig.DefaultExhibitConfig();
		}
	}
	public sealed class MoriyaSuwakoExhibitADef : MoriyaSuwakoExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Value1 = 1;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Blue = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)2;
			defaultExhibitConfig.RelativeEffects = new List<string> { "MoriyaSuwakoFateControlSe" };
			defaultExhibitConfig.BaseManaRequirement = (ManaColor)2;
			defaultExhibitConfig.Value2 = 20;
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoExhibitADef))]
	public sealed class MoriyaSuwakoExhibitA : ShiningExhibit
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarted>d__2 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public MoriyaSuwakoExhibitA <>4__this;

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

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

			[DebuggerHidden]
			public <OnPlayerTurnStarted>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 (((Unit)((Exhibit)<>4__this).Battle.Player).TurnCounter >= 1 && ((Unit)((Exhibit)<>4__this).Battle.Player).TurnCounter <= 2)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<MoriyaSuwakoFateControlSe>((Unit)(object)((Exhibit)<>4__this).Owner, (int?)((Exhibit)<>4__this).Value1, (int?)null, (int?)null, (int?)null, 0f, true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

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

		protected override void OnAdded(PlayerUnit player)
		{
			((Exhibit)this).HandleGameRunEvent<PowerEventArgs>(((Exhibit)this).Owner.PowerGained, (GameEventHandler<PowerEventArgs>)OnPowerGained);
		}

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

		private void OnPowerGained(PowerEventArgs args)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			((Exhibit)this).NotifyActivating();
			if (args.Power > 0 && (int)((GameEventArgs)args).Cause != 20)
			{
				int num = MathExtensions.ToInt(Math.Floor((double)(args.Power * ((Exhibit)this).Value2) / 100.0));
				PowerEventArgs val = new PowerEventArgs
				{
					Power = num,
					CanCancel = false,
					Cause = (ActionCause)20
				};
				val.Power = ((GameEntity)this).GameRun.InternalGainPower(val.Power);
				((GameEntity)this).GameRun.Player.PowerGained.Execute(val);
				((GameEntity)this).GameRun.VisualTrigger.OnGainPower(num, true);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
	public sealed class MoriyaSuwakoExhibitBDef : MoriyaSuwakoExhibitTemplate
	{
		public override ExhibitConfig MakeConfig()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			ExhibitConfig defaultExhibitConfig = GetDefaultExhibitConfig();
			defaultExhibitConfig.Value1 = 1;
			defaultExhibitConfig.Value2 = 1;
			defaultExhibitConfig.Value3 = 15;
			ManaGroup value = default(ManaGroup);
			((ManaGroup)(ref value)).Black = 1;
			defaultExhibitConfig.Mana = value;
			defaultExhibitConfig.BaseManaColor = (ManaColor)3;
			defaultExhibitConfig.BaseManaRequirement = (ManaColor)3;
			defaultExhibitConfig.RelativeEffects = new List<string> { "Amulet", "AmuletForCard" };
			return defaultExhibitConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoExhibitBDef))]
	public sealed class MoriyaSuwakoExhibitB : ShiningExhibit
	{
		[CompilerGenerated]
		private sealed class <OnBattleStarted>d__2 : 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 MoriyaSuwakoExhibitB <>4__this;

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

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

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

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

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

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

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

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

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

		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<GameEventArgs>(((Exhibit)this).Battle.BattleStarted, (EventSequencedReactor<GameEventArgs>)OnBattleStarted, (GameEventPriority)int.MinValue);
		}

		protected override void OnAdded(PlayerUnit player)
		{
			((Exhibit)this).HandleGameRunEvent<StationEventArgs>(((GameEntity)this).GameRun.StationEntering, (GameEventHandler<StationEventArgs>)OnStationEntered);
		}

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

		private void OnStationEntered(StationEventArgs args)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			int money = ((GameEntity)this).GameRun.Money;
			if ((int)args.Station.Type == 5 && money > 0)
			{
				((Exhibit)this).NotifyActivating();
				int num = MathExtensions.ToInt(Math.Floor((double)(money * ((Exhibit)this).Value3) / 100.0));
				((GameEntity)this).GameRun.GainMoney(num, true, (VisualSourceData)null);
			}
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((Exhibit)this).NotifyActivating();
		}
	}
}
namespace MoriyaSuwakoMod.Enemies
{
	public sealed class MoriyaSuwakoEnemyGroupDef : MoriyaSuwakoEnemyGroupTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("MoriyaSuwakoMod");
		}

		public override EnemyGroupConfig MakeConfig()
		{
			EnemyGroupConfig enemyGroupDefaultConfig = GetEnemyGroupDefaultConfig();
			enemyGroupDefaultConfig.Name = "MoriyaSuwakoMod";
			enemyGroupDefaultConfig.FormationName = "Single";
			enemyGroupDefaultConfig.Enemies = new List<string> { "MoriyaSuwakoMod" };
			enemyGroupDefaultConfig.EnemyType = (EnemyType)3;
			enemyGroupDefaultConfig.RollBossExhibit = true;
			return enemyGroupDefaultConfig;
		}
	}
	public sealed class MoriyaSuwakoEnemyUnitDef : MoriyaSuwakoEnemyUnitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("MoriyaSuwakoMod");
		}

		public override EnemyUnitConfig MakeConfig()
		{
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			EnemyUnitConfig enemyUnitDefaultConfig = GetEnemyUnitDefaultConfig();
			enemyUnitDefaultConfig.IsPreludeOpponent = BepinexPlugin.enableAct1Boss.Value;
			enemyUnitDefaultConfig.BaseManaColor = new List<ManaColor> { (ManaColor)1 };
			enemyUnitDefaultConfig.Type = (EnemyType)3;
			enemyUnitDefaultConfig.MaxHp = 250;
			enemyUnitDefaultConfig.MaxHpHard = 255;
			enemyUnitDefaultConfig.MaxHpLunatic = 260;
			enemyUnitDefaultConfig.Damage1 = 10;
			enemyUnitDefaultConfig.Damage1Hard = 11;
			enemyUnitDefaultConfig.Damage1Lunatic = 12;
			enemyUnitDefaultConfig.Damage2 = 15;
			enemyUnitDefaultConfig.Damage2Hard = 16;
			enemyUnitDefaultConfig.Damage2Lunatic = 17;
			enemyUnitDefaultConfig.Damage3 = 20;
			enemyUnitDefaultConfig.Damage3Hard = 21;
			enemyUnitDefaultConfig.Damage3Lunatic = 22;
			enemyUnitDefaultConfig.Damage4 = 25;
			enemyUnitDefaultConfig.Damage4Hard = 26;
			enemyUnitDefaultConfig.Damage4Lunatic = 27;
			enemyUnitDefaultConfig.Defend = 10;
			enemyUnitDefaultConfig.DefendHard = 11;
			enemyUnitDefaultConfig.DefendLunatic = 12;
			enemyUnitDefaultConfig.Count1 = 1;
			enemyUnitDefaultConfig.Count1Hard = 1;
			enemyUnitDefaultConfig.Count1Lunatic = 2;
			enemyUnitDefaultConfig.Count2 = 1;
			enemyUnitDefaultConfig.Count2Hard = 1;
			enemyUnitDefaultConfig.Count2Lunatic = 2;
			enemyUnitDefaultConfig.PowerLoot = new MinMax(100, 100);
			enemyUnitDefaultConfig.BluePointLoot = new MinMax(100, 100);
			enemyUnitDefaultConfig.Gun1 = new List<string> { GunNameID.GetGunFromId(800) };
			enemyUnitDefaultConfig.Gun2 = new List<string> { GunNameID.GetGunFromId(800) };
			enemyUnitDefaultConfig.Gun3 = new List<string> { GunNameID.GetGunFromId(800) };
			enemyUnitDefaultConfig.Gun4 = new List<string> { GunNameID.GetGunFromId(800) };
			return enemyUnitDefaultConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoEnemyUnitDef))]
	public sealed class MoriyaSuwakoMod : EnemyUnit
	{
		private enum MoveType
		{
			BasicAttack,
			BasicDefend
		}

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public MoriyaSuwakoMod <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)new EnemyMoveAction((EnemyUnit)(object)<>4__this, ((EnemyUnit)<>4__this).GetMove(1), true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new CastBlockShieldAction((Unit)(object)<>4__this, ((EnemyUnit)<>4__this).Defend, 0, (BlockShieldType)1, 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()
			{
				<BasicDefendAction>d__15 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <BasicDefendAction>d__15(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

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

			private IEnemyMove <>2__current;

			private int <>l__initialThreadId;

			public MoriyaSuwakoMod <>4__this;

			private MoveType <>s__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					MoveType next = <>4__this.Next;
					<>s__1 = next;
					switch (<>s__1)
					{
					case MoveType.BasicAttack:
						<>2__current = ((EnemyUnit)<>4__this).AttackMove(<>4__this.BasicAttackMove, ((EnemyUnit)<>4__this).Gun1, ((EnemyUnit)<>4__this).Damage1, 1, false, "Instant", false);
						<>1__state = 1;
						return true;
					case MoveType.BasicDefend:
						<>2__current = (IEnemyMove)new SimpleEnemyMove(Intention.Defend().WithMoveName(((EnemyUnit)<>4__this).GetMove(1)), <>4__this.BasicDefendAction());
						<>1__state = 2;
						return true;
					default:
						return false;
					}
				}
				case 1:
					<>1__state = -1;
					<>4__this.Last = MoveType.BasicAttack;
					return false;
				case 2:
					<>1__state = -1;
					<>4__this.Last = MoveType.BasicDefend;
					return false;
				}
			}

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

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

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

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

		private MoveType Last { get; set; }

		private MoveType Next { get; set; }

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

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

		protected override void OnEnterBattle(BattleController battle)
		{
			Last = MoveType.BasicDefend;
			Next = MoveType.BasicAttack;
		}

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

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

		protected override void UpdateMoveCounters()
		{
			Next = ((Last == MoveType.BasicAttack) ? MoveType.BasicDefend : MoveType.BasicAttack);
		}
	}
}
namespace MoriyaSuwakoMod.Enemies.Template
{
	public abstract class MoriyaSuwakoEnemyGroupTemplate : EnemyGroupTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(MoriyaSuwakoDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override EnemyGroupConfig MakeConfig()
		{
			return MoriyaSuwakoDefaultConfig.EnemyGroupDefaultConfig();
		}

		public EnemyGroupConfig GetEnemyGroupDefaultConfig()
		{
			return MoriyaSuwakoDefaultConfig.EnemyGroupDefaultConfig();
		}
	}
	public class MoriyaSuwakoEnemyUnitTemplate : EnemyUnitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit(MoriyaSuwakoDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

		public override EnemyUnitConfig MakeConfig()
		{
			return MoriyaSuwakoDefaultConfig.EnemyUnitDefaultConfig();
		}

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

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

		public EnemyUnitConfig GetEnemyUnitDefaultConfig()
		{
			return MoriyaSuwakoDefaultConfig.EnemyUnitDefaultConfig();
		}
	}
}
namespace MoriyaSuwakoMod.Config
{
	public struct CustomConfigEntry<T>
	{
		public T Value { get; set; }

		public string Section { get; set; }

		public string Key { get; set; }

		public string Description { get; set; }

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

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

		public static CardConfig CardDefaultConfig()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			return new CardConfig(0, "", 10, true, new string[0][], "", "", 0, false, true, false, true, true, (Rarity)0, (CardType)0, (TargetType?)null, (IReadOnlyList<ManaColor>)new List<ManaColor>(), false, default(ManaGroup), (ManaGroup?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)0, (Keyword)0, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), OwnerName, "", "", false, (string)null, (IReadOnlyList<string>)new List<string>());
		}

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

		public static StatusEffectConfig DefaultStatusEffectConfig()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			return new StatusEffectConfig(0, "", 10, (StatusEffectType)0, false, true, (int?)null, true, (StackType?)(StackType)0, false, (StackType?)(StackType)0, (DurationDecreaseTiming)0, false, (StackType?)(StackType)3, (StackType?)(StackType)3, false, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (string)null, "Default", "Default", "Default");
		}

		public static UltimateSkillConfig DefaultUltConfig()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 1, 0, 0, (Keyword)256, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}

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

		public static EnemyGroupConfig EnemyGroupDefaultConfig()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			return new EnemyGroupConfig("", false, (IReadOnlyList<string>)new List<string>(), "", "Single", (IReadOnlyList<string>)new List<string>(), (EnemyType)3, false, 1f, true, new Vector2(-4f, 0.5f), "", "", (string)null);
		}
	}
}
namespace MoriyaSuwakoMod.Source.Untils
{
	public static class CardUtil
	{
		public static bool ExistIntervenen(Card card)
		{
			if (!(card is MoriyaSuwakoInterveneCard))
			{
				return false;
			}
			if (card.IsUpgraded)
			{
				return card.Config.UpgradedRelativeEffects.Contains("MoriyaSuwakoInterveneSe");
			}
			return card.Config.RelativeEffects.Contains("MoriyaSuwakoInterveneSe");
		}
	}
}
namespace MoriyaSuwakoMod.Source.StatusEffects
{
	public sealed class MoriyaSuwakoAngerSeDef : MoriyaSuwakoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = MoriyaSuwakoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoAngerSeDef))]
	public sealed class MoriyaSuwakoAngerSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnEnded>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 MoriyaSuwakoAngerSe <>4__this;

			private bool <battleShouldEnd>5__1;

			private IEnumerator<BattleAction> <>s__2;

			private BattleAction <battleAction>5__3;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<battleShouldEnd>5__1 = ((StatusEffect)<>4__this).Battle.BattleShouldEnd;
						if (<battleShouldEnd>5__1)
						{
							return false;
						}
						<>s__2 = ((StatusEffect)<>4__this).DebuffAction<MoriyaSuwakoCurseDivinationSe>((IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.AllAliveEnemies, ((StatusEffect)<>4__this).Level, 0, 0, 0, true, 0.2f).GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<battleAction>5__3 = null;
						break;
					}
					if (<>s__2.MoveNext())
					{
						<battleAction>5__3 = <>s__2.Current;
						<>2__current = <battleAction>5__3;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__2 = 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__2 != null)
				{
					<>s__2.Dispose();
				}
			}

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

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

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

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

		[IteratorStateMachine(typeof(<OnOwnerTurnEnded>d__1))]
		private IEnumerable<BattleAction> OnOwnerTurnEnded(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnEnded>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class MoriyaSuwakoBeNoInjurytSeDef : MoriyaSuwakoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = MoriyaSuwakoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoBeNoInjurytSeDef))]
	public sealed class MoriyaSuwakoBeNoInjurytSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnBattleEnding>d__1 : 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 MoriyaSuwakoBeNoInjurytSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((Unit)((StatusEffect)<>4__this).Battle.Player).IsAlive)
					{
						<>2__current = (BattleAction)new HealAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)((StatusEffect)<>4__this).Battle.Player, ((StatusEffect)<>4__this).Level, (HealType)0, 0.2f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					<>4__this.<>n__0();
					break;
				}
				return false;
			}

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

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

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

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

		[CompilerGenerated]
		private sealed class <OnPlayerDamage>d__2 : 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 MoriyaSuwakoBeNoInjurytSe <>4__this;

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

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

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

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

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

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

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

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

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(((StatusEffect)this).Battle.BattleEnding, (EventSequencedReactor<GameEventArgs>)OnBattleEnding, (GameEventPriority)int.MinValue);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(((Unit)((StatusEffect)this).Battle.Player).DamageTaking, (EventSequencedReactor<DamageEventArgs>)OnPlayerDamage);
		}

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class MoriyaSuwakoBetSeDef : MoriyaSuwakoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = MoriyaSuwakoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoBetSeDef))]
	public sealed class MoriyaSuwakoBetSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnPlayerDamage>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 MoriyaSuwakoBetSe <>4__this;

			private int <sub>5__1;

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

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

			[DebuggerHidden]
			public <OnPlayerDamage>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_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				DamageInfo damageInfo = args.DamageInfo;
				<sub>5__1 = (int)((DamageInfo)(ref damageInfo)).Damage;
				((GameEntity)<>4__this).GameRun.LoseMoney(<sub>5__1);
				<>4__this.<>n__0();
				return false;
			}

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private HealEventArgs args;

			public HealEventArgs <>3__args;

			public MoriyaSuwakoBetSe <>4__this;

			private int <add>5__1;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<add>5__1 = (int)(args.Amount * (float)((StatusEffect)<>4__this).Level);
				((GameEntity)<>4__this).GameRun.GainMoney(<add>5__1, true, (VisualSourceData)null);
				<>4__this.<>n__0();
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<OnPlayerHeal>d__2 <OnPlayerHeal>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerHeal>d__ = this;
				}
				else
				{
					<OnPlayerHeal>d__ = new <OnPlayerHeal>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerHeal>d__.args = <>3__args;
				return <OnPlayerHeal>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).DamageTaking, (EventSequencedReactor<DamageEventArgs>)OnPlayerDamage);
			((StatusEffect)this).ReactOwnerEvent<HealEventArgs>(((Unit)((StatusEffect)this).Battle.Player).HealingReceived, (EventSequencedReactor<HealEventArgs>)OnPlayerHeal);
		}

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class MoriyaSuwakoBlessingSeDef : MoriyaSuwakoStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(MoriyaSuwakoBlessingSeDef))]
	public sealed class MoriyaSuwakoBlessingSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardUsed>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardUsingEventArgs args;

			public CardUsingEventArgs <>3__args;

			public MoriyaSuwakoBlessingSe <>4__this;

			private int <num>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this.firstCard)
					{
						<>4__this.firstCard = false;
						return false;
					}
					<num>5__1 = ((StatusEffect)<>4__this).Level - 1;
					((StatusEffect)<>4__this).Level = <num>5__1;
					if (((StatusEffect)<>4__this).Level <= 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;
				}
				return false;
			}

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

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

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

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

		private bool firstCard = true;

		protected override void OnAdded(Unit unit)
		{
			CardToFree(((StatusEffect)this).Battle.EnumerateAllCards());
			((StatusEffect)this).ReactOwnerEvent<CardUsingEventArgs>(((StatusEffect)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
			((StatusEffect)this).HandleOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToDiscard, (GameEventHandler<CardsEventArgs>)OnAddCard);
			((StatusEffect)this).HandleOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToHand, (GameEventHandler<CardsEventArgs>)OnAddCard);
			((StatusEffect)this).HandleOwnerEvent<CardsEventArgs>(((StatusEffect)this).Battle.CardsAddedToExile, (GameEventHandler<CardsEventArgs>)OnAddCard);
			((StatusEffect)this).HandleOwnerEvent<CardsAddingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardsAddedToDrawZone, (GameEventHandler<CardsAddingToDrawZoneEventArgs>)OnAddCardToDraw);
		}

		private void CardToFree(IEnumerable<Card> cards)
		{
			foreach (Card card in cards)
			{
				card.FreeCost = true;
			}
		}

		private void OnAddCardToDraw(CardsAddingToDrawZoneEventArgs args)
		{
			CardToFree(args.Cards);
		}

		private void OnAddCard(CardsEventArgs args)
		{
			CardToFree(args.Cards);
		}

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

		protected override void OnRemoved(Unit unit)
		{
			foreach (Card item in ((StatusEffect)this).Battle.EnumerateAllCards())
			{
				item.FreeCost = false;
			}
		}
	}
	public sealed class MoriyaSuwakoCausalTamperingSeDef : MoriyaSuwakoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = MoriyaSuwakoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoCausalTamperingSeDef))]
	public sealed class MoriyaSuwakoCausalTamperingSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public MoriyaSuwakoCausalTamperingSe <>4__this;

			private bool <battleShouldEnd>5__1;

			private SelectCardInteraction <interaction>5__2;

			private IReadOnlyList<Card> <cards>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Expected O, but got Unknown
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Expected O, but got Unknown
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<battleShouldEnd>5__1 = ((StatusEffect)<>4__this).Battle.BattleShouldEnd;
					if (<battleShouldEnd>5__1)
					{
						return false;
					}
					if (((StatusEffect)<>4__this).Level <= 0)
					{
						return false;
					}
					<interaction>5__2 = new SelectCardInteraction(0, ((StatusEffect)<>4__this).Level, (IEnumerable<Card>)((StatusEffect)<>4__this).Battle.HandZone, (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)
					{
						<>2__current = (BattleAction)new DiscardManyAction((IEnumerable<Card>)<cards>5__3);
						<>1__state = 2;
						return true;
					}
					goto IL_0112;
				case 2:
					<>1__state = -1;
					goto IL_0112;
				case 3:
					{
						<>1__state = -1;
						return false;
					}
					IL_0112:
					<>2__current = (BattleAction)new DrawManyCardAction(<cards>5__3.Count);
					<>1__state = 3;
					return true;
				}
			}

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

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

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

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

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

		[IteratorStateMachine(typeof(<OnOwnerTurnStarted>d__1))]
		protected IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarted>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class MoriyaSuwakoCorruptTerritoryDrawSeDef : MoriyaSuwakoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = MoriyaSuwakoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoCorruptTerritoryDrawSeDef))]
	public sealed class MoriyaSuwakoCorruptTerritoryDrawSe : 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 MoriyaSuwakoCorruptTerritoryDrawSe <>4__this;

			private bool <battleShouldEnd>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Invalid comparison between Unknown and I4
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<battleShouldEnd>5__1 = ((StatusEffect)<>4__this).Battle.BattleShouldEnd;
					if (<battleShouldEnd>5__1)
					{
						return false;
					}
					if ((int)args.Card.CardType != 1)
					{
						return false;
					}
					if (((StatusEffect)<>4__this).Level <= 0)
					{
						return false;
					}
					<>2__current = (BattleAction)new DrawManyCardAction(((StatusEffect)<>4__this).Level);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<BattleAction> IEnumerable<BattleAction>.GetEnumerator()
			{
				<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 MoriyaSuwakoCorruptTerritorySeDef : MoriyaSuwakoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = MoriyaSuwakoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "MoriyaSuwakoCorruptTerritoryDrawSe" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoCorruptTerritorySeDef))]
	public sealed class MoriyaSuwakoCorruptTerritorySe : 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 MoriyaSuwakoCorruptTerritorySe <>4__this;

			private bool <battleShouldEnd>5__1;

			private List<Card> <list>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 <OnCardUsed>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Invalid comparison between Unknown and I4
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Invalid comparison between Unknown and I4
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Expected O, but got Unknown
				int level;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<battleShouldEnd>5__1 = ((StatusEffect)<>4__this).Battle.BattleShouldEnd;
					if (<battleShouldEnd>5__1)
					{
						return false;
					}
					if ((int)args.Card.CardType != 1)
					{
						return false;
					}
					<list>5__2 = ((StatusEffect)<>4__this).Battle.HandZone.ToList();
					if (<list>5__2.Count > 0 && ((StatusEffect)<>4__this).Level > 0)
					{
						CollectionsExtensions.Shuffle<Card>((IList<Card>)<list>5__2, ((GameEntity)<>4__this).GameRun.BattleRng);
						<i>5__3 = 0;
						goto IL_0139;
					}
					goto IL_0166;
				case 1:
					<>1__state = -1;
					goto IL_0126;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_0126:
					<i>5__3++;
					goto IL_0139;
					IL_0139:
					if (<i>5__3 < Math.Min(<list>5__2.Count, ((StatusEffect)<>4__this).Level))
					{
						if ((int)<list>5__2[<i>5__3].Zone == 2)
						{
							<>2__current = (BattleAction)new DiscardAction(<list>5__2[<i>5__3]);
							<>1__state = 1;
							return true;
						}
						goto IL_0126;
					}
					goto IL_0166;
					IL_0166:
					if (((StatusEffect)<>4__this).Level == 0)
					{
						<>4__this.sub++;
					}
					else
					{
						<>4__this.sub = 0;
					}
					if (((StatusEffect)<>4__this).Level == 0 && <>4__this.sub > ((StatusEffect)<>4__this).Level)
					{
						<>2__current = ((StatusEffect)<>4__this).BuffAction<MoriyaSuwakoCorruptTerritoryDrawSe>(1, 0, 0, 0, 0.2f);
						<>1__state = 2;
						return true;
					}
					level = ((StatusEffect)<>4__this).Level;
					((StatusEffect)<>4__this).Level = level - 1;
					return false;
				}
			}

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

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

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

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

		private int sub = 0;

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardEventArgs args;

			public CardEventArgs <>3__args;

			public MoriyaSuwakoCurseDivinationSe <>4__this;

			private bool <battleShouldEnd>5__1;

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

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

			[DebuggerHidden]
			public <OnCardDiscarded>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 == null)
					{
						return false;
					}
					<battleShouldEnd>5__1 = ((StatusEffect)<>4__this).Battle.BattleShouldEnd;
					if (<battleShouldEnd>5__1)
					{
						return false;
					}
					<>2__current = (BattleAction)(object)DamageAction.LoseLife(((StatusEffect)<>4__this).Owner, ((StatusEffect)<>4__this).Level, "MoriyaSuwakoCurseDivination");
					<>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()
			{
				<OnCardDiscarded>d__2 <OnCardDiscarded>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardDiscarded>d__ = this;
				}
				else
				{
					<OnCardDiscarded>d__ = new <OnCardDiscarded>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardDiscarded>d__.args = <>3__args;
				return <OnCardDiscarded>d__;
			}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public MoriyaSuwakoCurseDivinationSe <>4__this;

			private bool <battleShouldEnd>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<battleShouldEnd>5__1 = ((StatusEffect)<>4__this).Battle.BattleShouldEnd;
					if (<battleShouldEnd>5__1)
					{
						return false;
					}
					if (((StatusEffect)<>4__this).Level <= 0)
					{
						return false;
					}
					int level = ((StatusEffect)<>4__this).Level;
					((StatusEffect)<>4__this).Level = level - 1;
					if (((StatusEffect)<>4__this).Level <= 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;
				}
				<>4__this.<>n__0();
				return false;
			}

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

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

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

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

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

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class MoriyaSuwakoDefensivePostureSeDef : MoriyaSuwakoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			return MoriyaSuwakoStatusEffectTemplate.GetDefaultStatusEffectConfig();
		}
	}
	[EntityLogic(typeof(MoriyaSuwakoDefensivePostureSeDef))]
	public sealed class MoriyaSuwakoDefensivePostureSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnOwnerTurnStarted>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public MoriyaSuwakoDefensivePostureSe <>4__this;

			private bool <battleShouldEnd>5__1;

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

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

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

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

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

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatisticalDamageEventArgs args;

			public StatisticalDamageEventArgs <>3__args;

			public MoriyaSuwakoDefensivePostureSe <>4__this;

			private bool <battleShouldEnd>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00ea: Unknown result type (might be due to invalid IL or