using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AddWatermark;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using HarmonyLib;
using JetBrains.Annotations;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Battle.Interactions;
using LBoL.Core.Cards;
using LBoL.Core.Intentions;
using LBoL.Core.Randoms;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Cards;
using LBoL.EntityLib.Cards.Neutral.Black;
using LBoL.EntityLib.Cards.Neutral.NoColor;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.ExtraTurn;
using LBoL.EntityLib.StatusEffects.Others;
using LBoL.Presentation;
using LBoL.Presentation.UI.Widgets;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using PatchouliCharacterMod.BattleActions;
using PatchouliCharacterMod.Cards;
using PatchouliCharacterMod.Cards.Template;
using PatchouliCharacterMod.Config;
using PatchouliCharacterMod.GunName;
using PatchouliCharacterMod.Illustrator;
using PatchouliCharacterMod.ImageLoader;
using PatchouliCharacterMod.Localization;
using PatchouliCharacterMod.Patch;
using PatchouliCharacterMod.StatusEffects;
using TMPro;
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("PatchouliCharacterMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ce3d585cd8f45f86cd7cec5331141b29549931de")]
[assembly: AssemblyProduct("PatchouliCharacterMod")]
[assembly: AssemblyTitle("PatchouliCharacterMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace PatchouliCharacterMod
{
	[BepInPlugin("rmrfmaxx.lbol.PatchouliCharacterMod", "Patchouli Character Mod", "0.3.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static string modUniqueID = "PatchouliMod";

		public static string playerName = "Patchouli";

		public static bool useInGameModel = false;

		public static string modelName = "Patchouli";

		public static bool modelIsFlipped = true;

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

		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("rmrfmaxx.lbol.PatchouliCharacterMod", "");

		public static ConfigEntry<int> startingExhibitSign;

		public static ConfigEntry<int> startingCardSign;

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			startingExhibitSign = ((BaseUnityPlugin)this).Config.Bind<int>("StartingExhibitSign", "StartingExhibitSign", 0, "Sign provided by PatchouliB's starting Exhibit. 0 = Fire, 1 = Water, 2 = Wood, 3 = Metal, 4 = Earth, 5 = Sun, 6 = Moon.");
			startingCardSign = ((BaseUnityPlugin)this).Config.Bind<int>("StartingCardSign", "StartingCardSign", 0, "Sign provided by PatchouliB's starting common card. 0 = Fire, 1 = Water, 2 = Wood, 3 = Metal, 4 = Earth, 5 = Sun, 6 = Moon.");
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			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 = "rmrfmaxx.lbol.PatchouliCharacterMod";

		public const string Name = "Patchouli Character Mod";

		public const string version = "0.3.0";

		public static readonly Harmony harmony = new Harmony("rmrfmaxx.lbol.PatchouliCharacterMod");
	}
	public class PatchouliLoadouts
	{
		public static string UltimateSkillA = "PatchouliUltU";

		public static string UltimateSkillB = "PatchouliUltB";

		public static string ExhibitA = "PatchouliExhibitU";

		public static string ExhibitB = "PatchouliExhibitB";

		public static List<string> DeckA = new List<string>
		{
			"Shoot", "Shoot", "Boundary", "Boundary", "PatchouliAttackU", "PatchouliAttackU", "PatchouliBlockB", "PatchouliBlockB", "PatchouliBlockB", "PatchouliArcaneWard",
			"PatchouliCondensedBubble"
		};

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "PatchouliAttackB", "PatchouliAttackB", "PatchouliBlockU", "PatchouliBlockU", "PatchouliBlockU", "PatchouliElementalManipulation" };
	}
	public sealed class PatchouliPlayerDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(PatchouliPlayerDef))]
		public sealed class PatchouliMod : PlayerUnit
		{
		}

		public static DirectorySource PatchouliDir = new DirectorySource("rmrfmaxx.lbol.PatchouliCharacterMod", "");

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

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

		public override PlayerUnitConfig MakeConfig()
		{
			//IL_0022: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).Blue = 2;
			((ManaGroup)(ref val)).Black = 2;
			return new PlayerUnitConfig(modUniqueID, true, "", 0, 7, num, true, (int?)null, (ManaColor)2, (ManaColor)3, val, "#d2c5df", 74, 85, 0, PatchouliLoadouts.UltimateSkillA, PatchouliLoadouts.UltimateSkillB, PatchouliLoadouts.ExhibitA, PatchouliLoadouts.ExhibitB, (IReadOnlyList<string>)PatchouliLoadouts.DeckA, (IReadOnlyList<string>)PatchouliLoadouts.DeckB, 3, 2);
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace PatchouliCharacterMod.PatchouliUlt
{
	public sealed class PatchouliUltBDef : PatchouliUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 40, 1, 0, (Keyword)256, (IReadOnlyList<string>)new List<string> { "PatchouliSignKeywordSe", "PatchouliMoonSignSe" }, (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(PatchouliUltBDef))]
	public sealed class PatchouliUltB : 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 PatchouliUltB <>4__this;

			private EnemyUnit <enemy>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "PatchouliUltB");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<PatchouliMoonSignSe>((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, (int?)((UltimateSkill)<>4__this).Value1, (int?)0, (int?)PatchouliSignSe.TurnLimit, (int?)0, 0.2f, true);
						<>1__state = 3;
						return true;
					}
					return false;
				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 PatchouliUltB()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = PatchouliGunName.UltimateSkillB;
		}

		[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 PatchouliUltTemplate : 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(PatchouliDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

		public override UltimateSkillConfig MakeConfig()
		{
			throw new NotImplementedException();
		}
	}
	public sealed class PatchouliUltUDef : PatchouliUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 38, 1, 1, (Keyword)256, (IReadOnlyList<string>)new List<string> { "PatchouliBoostSe" }, (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(PatchouliUltUDef))]
	public sealed class PatchouliUltU : 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 PatchouliUltU <>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_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Expected O, but got Unknown
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Battle.Player, "PatchouliUltU");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!((UltimateSkill)<>4__this).Battle.BattleShouldEnd)
					{
						<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<PatchouliAstronomy>(((UltimateSkill)<>4__this).Value1, false), (AddCardsType)0, false);
						<>1__state = 3;
						return true;
					}
					break;
				case 3:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)new BoostAllInHandAction(((UltimateSkill)<>4__this).Value2);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		public PatchouliUltU()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = PatchouliGunName.UltimateSkillU;
		}

		[IteratorStateMachine(typeof(<Actions>d__1))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__1(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
}
namespace PatchouliCharacterMod.StatusEffects
{
	public sealed class PatchouliBoostSeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliBoostSeDef))]
	public sealed class PatchouliBoostSe : StatusEffect
	{
	}
	public sealed class PatchouliCounterSeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliCounterSeDef))]
	public sealed class PatchouliCounterSe : StatusEffect
	{
	}
	public sealed class PatchouliSignKeywordSeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliSignKeywordSeDef))]
	public sealed class PatchouliSignKeywordSe : StatusEffect
	{
	}
	public sealed class PatchouliAstronomyStudySeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliAstronomyStudySeDef))]
	public sealed class PatchouliAstronomyStudySe : 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 PatchouliAstronomyStudySe <>4__this;

			private List<PatchouliAstronomy> <list>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()
			{
				<list>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<list>5__1 = ((StatusEffect)<>4__this).Battle.HandZone.OfType<PatchouliAstronomy>().ToList();
					if (<list>5__1.Count < ((StatusEffect)<>4__this).Level)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<PatchouliAstronomy>(((StatusEffect)<>4__this).Level - <list>5__1.Count, false), (AddCardsType)0, false);
						<>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()
			{
				<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))]
		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnOwnerTurnStarted>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardUsingEventArgs args;

			public CardUsingEventArgs <>3__args;

			public PatchouliAwakenedSpellbookSe <>4__this;

			private PatchouliBoostCard <boostCard>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					Card card = args.Card;
					<boostCard>5__1 = card as PatchouliBoostCard;
					if (<boostCard>5__1 != null && <>4__this.Boost >= <>4__this.BoostThreshold1)
					{
						<>4__this.<>n__0();
						<>4__this.isOwnSign = true;
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<PatchouliFireSignSe>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)PatchouliSignSe.TurnLimit, (int?)0, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

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

			private PatchouliBoostCard <boostCard>5__1;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				Card card = args.Card;
				<boostCard>5__1 = card as PatchouliBoostCard;
				if (<boostCard>5__1 != null)
				{
					<>4__this.Boost = <boostCard>5__1.Boost;
				}
				return false;
			}

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private TriggerSignEventArgs args;

			public TriggerSignEventArgs <>3__args;

			public PatchouliAwakenedSpellbookSe <>4__this;

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

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

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

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

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

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

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

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

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

		public int Boost = 0;

		public int BoostThreshold1 = 5;

		public bool isOwnSign = false;

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private TriggerSignEventArgs args;

			public TriggerSignEventArgs <>3__args;

			public PatchouliCircadianRhythmSe <>4__this;

			private int <sunAmount>5__1;

			private int <moonAmount>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Sign is PatchouliSunSignSe)
					{
						<>4__this.<>n__0();
						<sunAmount>5__1 = ((StatusEffect)((Unit)((StatusEffect)<>4__this).Battle.Player).GetStatusEffect<PatchouliSunSignSe>()).Level;
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<PatchouliMoonSignSe>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)(<sunAmount>5__1 * ((StatusEffect)<>4__this).Level), (int?)null, (int?)PatchouliSignSe.TurnLimit, (int?)null, 0.2f, true);
						<>1__state = 1;
						return true;
					}
					if (args.Sign is PatchouliMoonSignSe)
					{
						<>4__this.<>n__0();
						<moonAmount>5__2 = ((StatusEffect)((Unit)((StatusEffect)<>4__this).Battle.Player).GetStatusEffect<PatchouliMoonSignSe>()).Level;
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<PatchouliSunSignSe>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)(<moonAmount>5__2 * ((StatusEffect)<>4__this).Level), (int?)null, (int?)PatchouliSignSe.TurnLimit, (int?)null, 0.2f, true);
						<>1__state = 2;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<TriggerSignEventArgs>(CustomGameEventPatch.SignActiveTriggered, (EventSequencedReactor<TriggerSignEventArgs>)OnSignActiveTriggered);
		}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private TriggerSignEventArgs args;

			public TriggerSignEventArgs <>3__args;

			public PatchouliCurrentConductorSe <>4__this;

			private int <newDrowning>5__1;

			private IEnumerator<EnemyUnit> <>s__2;

			private Unit <unit>5__3;

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

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

			[DebuggerHidden]
			public <OnSignTriggered>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;
				<unit>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (!(args.Sign is PatchouliWaterSignSe))
						{
							break;
						}
						<>4__this.<>n__0();
						<>s__2 = ((StatusEffect)<>4__this).Battle.AllAliveEnemies.GetEnumerator();
						<>1__state = -3;
						goto IL_012b;
					case 1:
						<>1__state = -3;
						<unit>5__3 = null;
						goto IL_012b;
					case 2:
						{
							<>1__state = -1;
							break;
						}
						IL_012b:
						if (<>s__2.MoveNext())
						{
							<unit>5__3 = (Unit)(object)<>s__2.Current;
							<newDrowning>5__1 = (<unit>5__3.HasStatusEffect<Drowning>() ? ((StatusEffect)<unit>5__3.GetStatusEffect<Drowning>()).Level : 0);
							<newDrowning>5__1 += ((StatusEffect)<>4__this).Level;
							<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Drowning>(<unit>5__3, (int?)<newDrowning>5__1, (int?)0, (int?)null, (int?)null, 0f, true);
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>s__2 = null;
						<>2__current = (BattleAction)(object)new TriggerDrowningAction();
						<>1__state = 2;
						return true;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<TriggerSignEventArgs>(CustomGameEventPatch.SignPassiveTriggered, (EventSequencedReactor<TriggerSignEventArgs>)OnSignTriggered);
			((StatusEffect)this).ReactOwnerEvent<TriggerSignEventArgs>(CustomGameEventPatch.SignActiveTriggered, (EventSequencedReactor<TriggerSignEventArgs>)OnSignTriggered);
		}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private TriggerSignEventArgs args;

			public TriggerSignEventArgs <>3__args;

			public PatchouliEnigmaticMagicSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)new CastBlockShieldAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)((StatusEffect)<>4__this).Battle.Player, ((StatusEffect)<>4__this).Level, 0, (BlockShieldType)2, true);
					<>1__state = 1;
					return true;
				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()
			{
				<OnSignGained>d__1 <OnSignGained>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnSignGained>d__ = this;
				}
				else
				{
					<OnSignGained>d__ = new <OnSignGained>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnSignGained>d__.args = <>3__args;
				return <OnSignGained>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<TriggerSignEventArgs>(CustomGameEventPatch.Spellcasted, (EventSequencedReactor<TriggerSignEventArgs>)OnSignGained);
		}

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

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

			private int <i>5__1;

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

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

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

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

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

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

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

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardEventArgs args;

			public CardEventArgs <>3__args;

			public PatchouliGirlOfShadeSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Invalid comparison between Unknown and I4
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((int)args.Card.CardType == 7 || (int)args.Card.CardType == 8)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)null, (int?)null, (int?)null, 0f, true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardUsingEventArgs args;

			public CardUsingEventArgs <>3__args;

			public PatchouliGrandIncantationSe <>4__this;

			private PatchouliBoostCard <boostCard>5__1;

			private EnemyUnit <enemyUnitWithMaxHP>5__2;

			private float <damage>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					Card card = args.Card;
					<boostCard>5__1 = card as PatchouliBoostCard;
					if (<boostCard>5__1 != null)
					{
						<>4__this.<>n__0();
						<enemyUnitWithMaxHP>5__2 = CollectionsExtensions.MaxBy<EnemyUnit, int>(((StatusEffect)<>4__this).Battle.EnemyGroup.Alives, (Func<EnemyUnit, int>)((EnemyUnit unit) => ((Unit)unit).Hp));
						<damage>5__3 = (float)<>4__this.boost * (float)((StatusEffect)<>4__this).Level;
						<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)<enemyUnitWithMaxHP>5__2, DamageInfo.Reaction(<damage>5__3, false), PatchouliGunName.GrandIncantation, (GunType)0);
						<>1__state = 1;
						return true;
					}
					break;
				}
				case 1:
					<>1__state = -1;
					<>4__this.boost = 0;
					<enemyUnitWithMaxHP>5__2 = null;
					break;
				}
				return false;
			}

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

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

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

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

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

			private PatchouliBoostCard <boostCard>5__1;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				Card card = args.Card;
				<boostCard>5__1 = card as PatchouliBoostCard;
				if (<boostCard>5__1 != null)
				{
					<>4__this.boost = <boostCard>5__1.Boost;
				}
				return false;
			}

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

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

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

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

		private int boost = 0;

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

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class PatchouliIntelligenceSeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliIntelligenceSeDef))]
	public sealed class PatchouliIntelligenceSe : StatusEffect
	{
	}
	public sealed class PatchouliKoakumaFriendSeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliKoakumaFriendSeDef))]
	public sealed class PatchouliKoakumaFriendSe : StatusEffect
	{
	}
	public sealed class PatchouliOneWeekGirlSeDef : PatchouliStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = PatchouliStatusEffectTemplate.DefaultStatusEffectConfig();
			val.IsStackable = false;
			val.LevelStackType = (StackType)3;
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(PatchouliOneWeekGirlSeDef))]
	public sealed class PatchouliOneWeekGirlSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarted>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public PatchouliOneWeekGirlSe <>4__this;

			private Type <type>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					((StatusEffect)<>4__this).Count = (((StatusEffect)<>4__this).Count + 1) % 7;
					<type>5__1 = PatchouliConfigEntry.SignToType((Signs)((StatusEffect)<>4__this).Count);
					<>2__current = (BattleAction)new ApplyStatusEffectAction(<type>5__1, (Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)0, (int?)PatchouliSignSe.TurnLimit, (int?)0, 0.2f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public string NextSign
		{
			get
			{
				string[] array = ((StatusEffect)this).Brief.Split(" ");
				return array[(((StatusEffect)this).Count + 1) % 7];
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatusEffectEventArgs args;

			public StatusEffectEventArgs <>3__args;

			public PatchouliSaintElmoPillarSe <>4__this;

			private int <damage>5__1;

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

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

			[DebuggerHidden]
			public <OnStatusEffectRemoved>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_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (args.Effect is Reflect)
					{
						<damage>5__1 = args.Effect.Level * ((StatusEffect)<>4__this).Level;
						<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (IEnumerable<Unit>)((StatusEffect)<>4__this).Battle.EnemyGroup.Alives, DamageInfo.Reaction((float)<damage>5__1, false), PatchouliGunName.PatchouliSaintElmoPillar, (GunType)0);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

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

		[IteratorStateMachine(typeof(<OnStatusEffectRemoved>d__1))]
		private IEnumerable<BattleAction> OnStatusEffectRemoved(StatusEffectEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnStatusEffectRemoved>d__1(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class PatchouliSpellPowerGraspSeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliSpellPowerGraspSeDef))]
	public sealed class PatchouliSpellPowerGraspSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnStarted>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 PatchouliSpellPowerGraspSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)(object)new BoostAllInHandAction(((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()
			{
				<OnPlayerTurnStarted>d__1 <OnPlayerTurnStarted>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnStarted>d__ = this;
				}
				else
				{
					<OnPlayerTurnStarted>d__ = new <OnPlayerTurnStarted>d__1(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 OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnStarted);
		}

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public class PatchouliStatusEffectTemplate : 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(PatchouliDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public static StatusEffectConfig DefaultStatusEffectConfig()
		{
			return PatchouliDefaultConfig.DefaultStatusEffectConfig();
		}
	}
	public sealed class PatchouliTemporaryIntelligenceSeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliTemporaryIntelligenceSeDef))]
	public sealed class PatchouliTemporaryIntelligenceSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<UnitEventArgs>(unit.TurnEnded, (GameEventHandler<UnitEventArgs>)delegate
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Expected O, but got Unknown
				((GameEntity)this).React(Reactor.op_Implicit((BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f)));
			});
		}
	}
	public sealed class PatchouliTheUnmovingGreatLibrarySeDef : PatchouliStatusEffectTemplate
	{
	}
	[EntityLogic(typeof(PatchouliTheUnmovingGreatLibrarySeDef))]
	public sealed class PatchouliTheUnmovingGreatLibrarySe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnSignActiveTriggered>d__1 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private TriggerSignEventArgs args;

			public TriggerSignEventArgs <>3__args;

			public PatchouliTheUnmovingGreatLibrarySe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.<>n__0();
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<PatchouliIntelligenceSe>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)null, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<TriggerSignEventArgs>(CustomGameEventPatch.SignActiveTriggered, (EventSequencedReactor<TriggerSignEventArgs>)OnSignActiveTriggered);
		}

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

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

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

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

			[DebuggerHidden]
			public <OnCardUsed>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_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Expected O, but got Unknown
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!(args.Card is PatchouliBoostCard))
					{
						break;
					}
					if (<>4__this.Boost >= <>4__this.BoostThreshold1)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new DrawManyCardAction(((StatusEffect)<>4__this).Level);
						<>1__state = 1;
						return true;
					}
					goto IL_00a5;
				case 1:
					<>1__state = -1;
					goto IL_00a5;
				case 2:
					<>1__state = -1;
					goto IL_00ec;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_00ec:
					if (<>4__this.Boost >= <>4__this.BoostThreshold3)
					{
						<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Firepower>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)((StatusEffect)<>4__this).Level, (int?)null, (int?)null, (int?)null, 0f, true);
						<>1__state = 3;
						return true;
					}
					break;
					IL_00a5:
					if (<>4__this.Boost >= <>4__this.BoostThreshold2)
					{
						<>2__current = (BattleAction)new GainManaAction(<>4__this.Mana);
						<>1__state = 2;
						return true;
					}
					goto IL_00ec;
				}
				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__14 <OnCardUsed>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardUsed>d__ = this;
				}
				else
				{
					<OnCardUsed>d__ = new <OnCardUsed>d__14(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardUsed>d__.args = <>3__args;
				return <OnCardUsed>d__;
			}

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

		[CompilerGenerated]
		private sealed class <OnCardUsing>d__13 : 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 PatchouliVoileSe <>4__this;

			private PatchouliBoostCard <boostCard>5__1;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				Card card = args.Card;
				<boostCard>5__1 = card as PatchouliBoostCard;
				if (<boostCard>5__1 != null)
				{
					<>4__this.Boost = <boostCard>5__1.Boost;
				}
				return false;
			}

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

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

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

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

		private int Boost = 0;

		public int BoostThreshold1 { get; } = 3;


		public int BoostThreshold2 { get; } = 6;


		public int BoostThreshold3 { get; } = 9;


		public ManaGroup Mana
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Blue = ((StatusEffect)this).Level;
				return result;
			}
		}

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

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

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class PatchouliEarthSignSeDef : PatchouliSignTemplate
	{
	}
	[EntityLogic(typeof(PatchouliEarthSignSeDef))]
	public sealed class PatchouliEarthSignSe : PatchouliSignSe
	{
		[CompilerGenerated]
		private sealed class <SignAction>d__14 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private bool isActive;

			public bool <>3__isActive;

			public PatchouliEarthSignSe <>4__this;

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

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

			[DebuggerHidden]
			public <SignAction>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_004f: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					<>2__current = (BattleAction)(object)ConvertManaAction.PhilosophyRandomMana(((StatusEffect)<>4__this).Battle.BattleMana, <>4__this.Amount(isActive), ((StatusEffect)<>4__this).Battle.GameRun.BattleRng);
					<>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()
			{
				<SignAction>d__14 <SignAction>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SignAction>d__ = this;
				}
				else
				{
					<SignAction>d__ = new <SignAction>d__14(0)
					{
						<>4__this = <>4__this
					};
				}
				<SignAction>d__.isActive = <>3__isActive;
				return <SignAction>d__;
			}

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

		public override int BasePassive { get; set; } = 1;


		public override int BaseActive { get; set; } = 2;


		public override int Sign { get; set; } = 4;


		public override ManaGroup Mana
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Philosophy = BaseManaAmount;
				return result;
			}
		}

		[IteratorStateMachine(typeof(<SignAction>d__14))]
		public override IEnumerable<BattleAction> SignAction(bool isActive = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SignAction>d__14(-2)
			{
				<>4__this = this,
				<>3__isActive = isActive
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class PatchouliFireSignSeDef : PatchouliSignTemplate
	{
	}
	[EntityLogic(typeof(PatchouliFireSignSeDef))]
	public sealed class PatchouliFireSignSe : PatchouliSignSe
	{
		[CompilerGenerated]
		private sealed class <SignAction>d__16 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private bool isActive;

			public bool <>3__isActive;

			public PatchouliFireSignSe <>4__this;

			private EnemyUnit <enemyUnitWithMinHP>5__1;

			private int <fireDamageMultiplier>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					<enemyUnitWithMinHP>5__1 = CollectionsExtensions.MinBy<EnemyUnit, int>(((StatusEffect)<>4__this).Battle.EnemyGroup.Alives, (Func<EnemyUnit, int>)((EnemyUnit unit) => ((Unit)unit).Hp));
					<fireDamageMultiplier>5__2 = 1;
					if (((Unit)((StatusEffect)<>4__this).Battle.Player).HasStatusEffect<PatchouliKoakumaFriendSe>())
					{
						<fireDamageMultiplier>5__2 += ((StatusEffect)((Unit)((StatusEffect)<>4__this).Battle.Player).GetStatusEffect<PatchouliKoakumaFriendSe>()).Level;
					}
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)<enemyUnitWithMinHP>5__1, DamageInfo.Reaction((float)(<>4__this.Amount(isActive) * <fireDamageMultiplier>5__2), false), PatchouliGunName.FireSign, (GunType)0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public override int BasePassive { get; set; } = 3;


		public override int BaseActive { get; set; } = 5;


		public override int Sign { get; set; } = 0;


		public override ManaGroup Mana
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Red = BaseManaAmount;
				return result;
			}
		}

		public override int Multiplier
		{
			get
			{
				int num = 1;
				if (((Unit)((StatusEffect)this).Battle.Player).HasStatusEffect<PatchouliKoakumaFriendSe>())
				{
					num += ((StatusEffect)((Unit)((StatusEffect)this).Battle.Player).GetStatusEffect<PatchouliKoakumaFriendSe>()).Level;
				}
				return num;
			}
		}

		[IteratorStateMachine(typeof(<SignAction>d__16))]
		public override IEnumerable<BattleAction> SignAction(bool isActive = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SignAction>d__16(-2)
			{
				<>4__this = this,
				<>3__isActive = isActive
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class PatchouliMetalSignSeDef : PatchouliSignTemplate
	{
	}
	[EntityLogic(typeof(PatchouliMetalSignSeDef))]
	public sealed class PatchouliMetalSignSe : PatchouliSignSe
	{
		[CompilerGenerated]
		private sealed class <SignAction>d__14 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private bool isActive;

			public bool <>3__isActive;

			public PatchouliMetalSignSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					<>2__current = (BattleAction)(object)new ApplyStatusEffectAction<Reflect>((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (int?)<>4__this.Amount(isActive), (int?)0, (int?)null, (int?)null, 0f, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((Unit)((StatusEffect)<>4__this).Battle.Player).HasStatusEffect<Reflect>())
					{
						((Unit)((StatusEffect)<>4__this).Battle.Player).GetStatusEffect<Reflect>().Gun = ((((Unit)((StatusEffect)<>4__this).Battle.Player).GetStatusEffect<Reflect>().Gun == "弹幕对决") ? "弹幕对决B" : "弹幕对决");
					}
					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()
			{
				<SignAction>d__14 <SignAction>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<SignAction>d__ = this;
				}
				else
				{
					<SignAction>d__ = new <SignAction>d__14(0)
					{
						<>4__this = <>4__this
					};
				}
				<SignAction>d__.isActive = <>3__isActive;
				return <SignAction>d__;
			}

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

		public override int BasePassive { get; set; } = 3;


		public override int BaseActive { get; set; } = 5;


		public override int Sign { get; set; } = 3;


		public override ManaGroup Mana
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Colorless = BaseManaAmount;
				return result;
			}
		}

		[IteratorStateMachine(typeof(<SignAction>d__14))]
		public override IEnumerable<BattleAction> SignAction(bool isActive = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SignAction>d__14(-2)
			{
				<>4__this = this,
				<>3__isActive = isActive
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class PatchouliMoonSignSeDef : PatchouliSignTemplate
	{
	}
	[EntityLogic(typeof(PatchouliMoonSignSeDef))]
	public sealed class PatchouliMoonSignSe : PatchouliSignSe
	{
		[CompilerGenerated]
		private sealed class <SignAction>d__14 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private bool isActive;

			public bool <>3__isActive;

			public PatchouliMoonSignSe <>4__this;

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

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

			[DebuggerHidden]
			public <SignAction>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_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>4__this.<>n__0();
					<>2__current = (BattleAction)new CastBlockShieldAction((Unit)(object)((StatusEffect)<>4__this).Battle.Player, (Unit)(object)((StatusEffect)<>4__this).Battle.Player, <>4__this.Amount(isActive), 0, (BlockShieldType)2, true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public override int BasePassive { get; set; } = 2;


		public override int BaseActive { get; set; } = 4;


		public override int Sign { get; set; } = 6;


		public override ManaGroup Mana
		{
			get
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup result = default(ManaGroup);
				((ManaGroup)(ref result)).Black = BaseManaAmount;
				return result;
			}
		}

		[IteratorStateMachine(typeof(<SignAction>d__14))]
		public override IEnumerable<BattleAction> SignAction(bool isActive = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SignAction>d__14(-2)
			{
				<>4__this = this,
				<>3__isActive = isActive
			};
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public class PatchouliSignSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <GainManaAction>d__53 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			public PatchouliSignSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private StatusEffectApplyEventArgs args;

			public StatusEffectApplyEventArgs <>3__args;

			public PatchouliSignSe <>4__this;

			private PatchouliSignSe <signSe>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					StatusEffect effect = args.Effect;
					<signSe>5__1 = effect as PatchouliSignSe;
					if (<signSe>5__1 != null && <signSe>5__1.Sign == <>4__this.Sign)
					{
						<>2__current = (BattleAction)(object)new TriggerSignAction(<>4__this, isActive: false, spellcasting: true);
						<>1__state = 1;
						return true;
					}
					break;
				}
				case 1: