using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AddWatermark;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Cysharp.Threading.Tasks;
using HarmonyLib;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.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.Character.Cirno;
using LBoL.EntityLib.Cards.Character.Marisa;
using LBoL.EntityLib.Cards.Character.Sakuya;
using LBoL.EntityLib.Cards.Neutral.Black;
using LBoL.EntityLib.Cards.Neutral.Red;
using LBoL.EntityLib.Cards.Neutral.White;
using LBoL.EntityLib.EnemyUnits.Character;
using LBoL.EntityLib.Exhibits;
using LBoL.EntityLib.StatusEffects.Basic;
using LBoL.EntityLib.StatusEffects.Cirno;
using LBoL.EntityLib.StatusEffects.Enemy;
using LBoL.EntityLib.StatusEffects.Neutral.TwoColor;
using LBoL.EntityLib.StatusEffects.Others;
using LBoL.Presentation;
using LBoL.Presentation.UI.ExtraWidgets;
using LBoL.Presentation.UI.Panels;
using LBoL.Presentation.UI.Widgets;
using LBoL.Presentation.Units;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.CustomKeywords;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.Utils;
using PullFix.Patches;
using UnityEngine;
using UnityEngine.Experimental.Rendering;
using YukariYakumoMod.BattleActions;
using YukariYakumoMod.Cards;
using YukariYakumoMod.Cards.Template;
using YukariYakumoMod.Config;
using YukariYakumoMod.Enemies.Template;
using YukariYakumoMod.GunName;
using YukariYakumoMod.ImageLoader;
using YukariYakumoMod.Localization;
using YukariYakumoMod.Model;
using YukariYakumoMod.Patches;
using YukariYakumoMod.SFX;
using YukariYakumoMod.SFX.Template;
using YukariYakumoMod.StatusEffects;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("LBoL.Base")]
[assembly: IgnoresAccessChecksTo("LBoL.ConfigData")]
[assembly: IgnoresAccessChecksTo("LBoL.Core")]
[assembly: IgnoresAccessChecksTo("LBoL.EntityLib")]
[assembly: IgnoresAccessChecksTo("LBoL.Presentation")]
[assembly: IgnoresAccessChecksTo("Untitled.ConfigDataBuilder.Base")]
[assembly: AssemblyCompany("YukariYakumoMod_windows")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("YukariYakumoMod_windows")]
[assembly: AssemblyTitle("YukariYakumoMod_windows")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace PullFix.Patches
{
	[HarmonyPatch(typeof(UnitView))]
	internal class UnitView_SetTrigger_Patch
	{
		[CompilerGenerated]
		private sealed class <AnimateCrash>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateCrash>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.crash2,
						YukariYakumoModel.crash3,
						YukariYakumoModel.crash4,
						YukariYakumoModel.crash5,
						YukariYakumoModel.crash6
					};
					<i>5__2 = 0;
					goto IL_0138;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0138;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0138:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateCrashStart>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

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

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

			[DebuggerHidden]
			public <AnimateCrashStart>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					__instance.spriteRenderer.sprite = YukariYakumoModel.crash1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)YukariYakumoModel.crash1)
					{
						<>2__current = AnimateCrash(__instance);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <AnimateDefend>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateDefend>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.defend1,
						YukariYakumoModel.defend2,
						YukariYakumoModel.defend3,
						YukariYakumoModel.defend4
					};
					<i>5__2 = 0;
					goto IL_012c;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_012c;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_012c:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateGraze>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateGraze>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.graze4,
						YukariYakumoModel.graze5,
						YukariYakumoModel.graze6,
						YukariYakumoModel.graze7,
						YukariYakumoModel.graze8,
						YukariYakumoModel.graze9,
						YukariYakumoModel.graze10,
						YukariYakumoModel.graze11
					};
					<i>5__2 = 0;
					goto IL_015c;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_015c;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_015c:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateGrazeStart>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateGrazeStart>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.graze1,
						YukariYakumoModel.graze2,
						YukariYakumoModel.graze3
					};
					<i>5__2 = 0;
					goto IL_0120;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0120;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0120:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateGraze(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateGuard>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateGuard>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.guard1,
						YukariYakumoModel.guard2,
						YukariYakumoModel.guard3,
						YukariYakumoModel.guard4
					};
					<i>5__2 = 0;
					goto IL_012c;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_012c;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_012c:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateHit>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateHit>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.hit1,
						YukariYakumoModel.hit2
					};
					<i>5__2 = 0;
					goto IL_0114;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0114;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0114:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateIdle>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateIdle>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.idle1,
						YukariYakumoModel.idle2,
						YukariYakumoModel.idle3,
						YukariYakumoModel.idle4,
						YukariYakumoModel.idle5,
						YukariYakumoModel.idle6,
						YukariYakumoModel.idle7,
						YukariYakumoModel.idle8,
						YukariYakumoModel.idle9,
						YukariYakumoModel.idle10,
						YukariYakumoModel.idle11
					};
					<i>5__2 = 0;
					goto IL_0180;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0180;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0180:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateIntro>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateIntro>d__12(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.intro1,
						YukariYakumoModel.intro2,
						YukariYakumoModel.intro3,
						YukariYakumoModel.intro4,
						YukariYakumoModel.intro5,
						YukariYakumoModel.intro6,
						YukariYakumoModel.intro7,
						YukariYakumoModel.intro8,
						YukariYakumoModel.intro9,
						YukariYakumoModel.intro10,
						YukariYakumoModel.intro11,
						YukariYakumoModel.intro12
					};
					<i>5__2 = 0;
					goto IL_018c;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_018c;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_018c:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateShoot>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateShoot>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.shoot1,
						YukariYakumoModel.shoot2,
						YukariYakumoModel.shoot3,
						YukariYakumoModel.shoot4,
						YukariYakumoModel.shoot5,
						YukariYakumoModel.shoot6,
						YukariYakumoModel.shoot7,
						YukariYakumoModel.shoot8,
						YukariYakumoModel.shoot9,
						YukariYakumoModel.shoot10,
						YukariYakumoModel.shoot11
					};
					<i>5__2 = 0;
					goto IL_0180;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0180;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0180:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateSkill>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateSkill>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.skill1,
						YukariYakumoModel.skill2,
						YukariYakumoModel.skill3,
						YukariYakumoModel.skill4,
						YukariYakumoModel.skill5,
						YukariYakumoModel.skill6,
						YukariYakumoModel.skill7,
						YukariYakumoModel.skill8,
						YukariYakumoModel.skill9
					};
					<i>5__2 = 0;
					goto IL_0168;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0168;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_0168:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <AnimateSpell>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public UnitView __instance;

			private List<Sprite> <spriteList>5__1;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <AnimateSpell>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<spriteList>5__1 = new List<Sprite>
					{
						YukariYakumoModel.spell1,
						YukariYakumoModel.spell2,
						YukariYakumoModel.spell3,
						YukariYakumoModel.spell4,
						YukariYakumoModel.spell5,
						YukariYakumoModel.spell6,
						YukariYakumoModel.spell7,
						YukariYakumoModel.spell8
					};
					<i>5__2 = 0;
					goto IL_015c;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_015c;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_015c:
					if (<i>5__2 < <spriteList>5__1.Count())
					{
						if (<i>5__2 > 0 && !((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<i>5__2 - 1]))
						{
							return false;
						}
						Sprite val2 = (__instance.spriteRenderer.sprite = <spriteList>5__1[<i>5__2]);
						<>2__current = val2;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)<spriteList>5__1[<spriteList>5__1.Count() - 1])
					{
						<>2__current = AnimateIdle(__instance);
						<>1__state = 3;
						return true;
					}
					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();
			}
		}

		[HarmonyPatch("SetTrigger", new Type[] { typeof(string) })]
		private static bool Prefix(UnitView __instance, string triggerName)
		{
			if (__instance._modelName == "YukariYakumoMod")
			{
				switch (triggerName)
				{
				case "defend":
					((MonoBehaviour)__instance).StartCoroutine(AnimateDefend(__instance));
					break;
				case "guard":
					((MonoBehaviour)__instance).StartCoroutine(AnimateGuard(__instance));
					break;
				case "crash":
					((MonoBehaviour)__instance).StartCoroutine(AnimateCrashStart(__instance));
					break;
				case "skill":
					((MonoBehaviour)__instance).StartCoroutine(AnimateSkill(__instance));
					break;
				case "shoot1":
					((MonoBehaviour)__instance).StartCoroutine(AnimateShoot(__instance));
					break;
				case "shoot2":
					((MonoBehaviour)__instance).StartCoroutine(AnimateShoot(__instance));
					break;
				case "shoot3":
					((MonoBehaviour)__instance).StartCoroutine(AnimateShoot(__instance));
					break;
				case "shoot4":
					((MonoBehaviour)__instance).StartCoroutine(AnimateShoot(__instance));
					break;
				case "spell":
					((MonoBehaviour)__instance).StartCoroutine(AnimateSpell(__instance));
					break;
				case "hit":
				{
					bool flag2 = false;
					List<Sprite> list2 = new List<Sprite>
					{
						YukariYakumoModel.skill1,
						YukariYakumoModel.skill2,
						YukariYakumoModel.skill3,
						YukariYakumoModel.skill4,
						YukariYakumoModel.skill5,
						YukariYakumoModel.skill6,
						YukariYakumoModel.skill7,
						YukariYakumoModel.skill8,
						YukariYakumoModel.skill9
					};
					foreach (Sprite item in list2)
					{
						if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)item)
						{
							flag2 = true;
							break;
						}
					}
					if (flag2)
					{
						break;
					}
					list2 = new List<Sprite>
					{
						YukariYakumoModel.crash1,
						YukariYakumoModel.crash2,
						YukariYakumoModel.crash3,
						YukariYakumoModel.crash4,
						YukariYakumoModel.crash5,
						YukariYakumoModel.crash6
					};
					foreach (Sprite item2 in list2)
					{
						if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)item2)
						{
							((MonoBehaviour)__instance).StartCoroutine(AnimateCrash(__instance));
							flag2 = true;
							break;
						}
					}
					if (!flag2)
					{
						((MonoBehaviour)__instance).StartCoroutine(AnimateHit(__instance));
					}
					break;
				}
				case "graze":
				{
					bool flag = false;
					List<Sprite> list = new List<Sprite>
					{
						YukariYakumoModel.graze1,
						YukariYakumoModel.graze2,
						YukariYakumoModel.graze3,
						YukariYakumoModel.graze4,
						YukariYakumoModel.graze5,
						YukariYakumoModel.graze6,
						YukariYakumoModel.graze7,
						YukariYakumoModel.graze8
					};
					foreach (Sprite item3 in list)
					{
						if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)item3)
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						break;
					}
					list = new List<Sprite>
					{
						YukariYakumoModel.graze9,
						YukariYakumoModel.graze10,
						YukariYakumoModel.graze11
					};
					foreach (Sprite item4 in list)
					{
						if ((Object)(object)__instance.spriteRenderer.sprite == (Object)(object)item4)
						{
							((MonoBehaviour)__instance).StartCoroutine(AnimateGraze(__instance));
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						((MonoBehaviour)__instance).StartCoroutine(AnimateGrazeStart(__instance));
					}
					break;
				}
				}
			}
			return true;
		}

		[IteratorStateMachine(typeof(<AnimateIdle>d__1))]
		private static IEnumerator AnimateIdle(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateIdle>d__1(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateDefend>d__2))]
		private static IEnumerator AnimateDefend(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateDefend>d__2(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateGuard>d__3))]
		private static IEnumerator AnimateGuard(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateGuard>d__3(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateCrashStart>d__4))]
		private static IEnumerator AnimateCrashStart(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateCrashStart>d__4(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateCrash>d__5))]
		private static IEnumerator AnimateCrash(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateCrash>d__5(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateSkill>d__6))]
		private static IEnumerator AnimateSkill(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateSkill>d__6(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateShoot>d__7))]
		private static IEnumerator AnimateShoot(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateShoot>d__7(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateSpell>d__8))]
		private static IEnumerator AnimateSpell(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateSpell>d__8(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateHit>d__9))]
		private static IEnumerator AnimateHit(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateHit>d__9(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateGrazeStart>d__10))]
		private static IEnumerator AnimateGrazeStart(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateGrazeStart>d__10(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateGraze>d__11))]
		private static IEnumerator AnimateGraze(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateGraze>d__11(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<AnimateIntro>d__12))]
		public static IEnumerator AnimateIntro(UnitView __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateIntro>d__12(0)
			{
				__instance = __instance
			};
		}
	}
	[HarmonyPatch(typeof(Aya))]
	internal class AyaBatttleStarted_Patch
	{
		[HarmonyPatch("OnBattleStarted")]
		[HarmonyPostfix]
		private static void Postfix(Aya __instance)
		{
			if (((GameEntity)((GameEntity)__instance).GameRun.Player).Id == "YukariYakumoMod")
			{
				__instance.SpecialReport = typeof(YYAyaNews);
			}
		}
	}
	[HarmonyPatch(typeof(Long))]
	internal class LongBattleStarted_Patch
	{
		[HarmonyPatch("OnBattleStarted")]
		[HarmonyPostfix]
		private static void Postfix(Long __instance)
		{
			if (((GameEntity)((GameEntity)__instance).GameRun.Player).Id == "YukariYakumoMod")
			{
				__instance.SpecialReport = typeof(YYAyaNews);
			}
		}
	}
}
namespace LBoL.Core.Battle.BattleActions
{
	public class VoidCardsAction : EventBattleAction<VoidEventArgs>
	{
		[CompilerGenerated]
		private sealed class <GetPhases>d__4 : IEnumerable<Phase>, IEnumerable, IEnumerator<Phase>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Phase <>2__current;

			private int <>l__initialThreadId;

			public VoidCardsAction <>4__this;

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

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

			[DebuggerHidden]
			public <GetPhases>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;
					<>2__current = ((BattleAction)<>4__this).CreatePhase("Main", (Action)delegate
					{
						<>4__this.ResolvePhase();
					}, 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<Phase> IEnumerable<Phase>.GetEnumerator()
			{
				<GetPhases>d__4 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetPhases>d__4(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

		public List<Card> Cards { get; }

		internal VoidCardsAction(IEnumerable<Card> cards)
		{
			List<Card> list = new List<Card>();
			foreach (Card card in cards)
			{
				list.Add(card);
			}
			base.Args = new VoidEventArgs
			{
				Cards = list.ToArray()
			};
		}

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

		internal void ResolvePhase()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			((BattleAction)this).React(new Reactor((IEnumerable<BattleAction>)base.Args.Cards.Select((Card card) => new VoidCardAction(card))), (GameEntity)null, (ActionCause?)null);
		}
	}
}
namespace YukariYakumoMod
{
	[BepInPlugin("Mizusa.LBoL.Character.YukariYakumo", "Yukari Yakumo", "0.1.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		public static string modUniqueID = "YukariYakumoMod";

		public static string playerName = "YukariYakumo";

		public static bool useInGameModel = false;

		public static string modelName = "Junko";

		public static bool modelIsFlipped = true;

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

		public static ConfigEntry<bool> enableAct1Boss;

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

		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

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

		internal static DirectorySource directorySource = new DirectorySource("Mizusa.LBoL.Character.YukariYakumo", "");

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

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "Mizusa.LBoL.Character.YukariYakumo";

		public const string Name = "Yukari Yakumo";

		public const string version = "0.1.2";

		public static readonly Harmony harmony = new Harmony("Mizusa.LBoL.Character.YukariYakumo");
	}
	public class YukariYakumoLoadouts
	{
		public static string UltimateSkillA = "YukariYakumoUltW";

		public static string UltimateSkillB = "YukariYakumoUltB";

		public static string ExhibitA = "YukariYakumoExhibitA";

		public static string ExhibitB = "YukariYakumoExhibitB";

		public static List<string> DeckA = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YYBasicAttackW", "YYBasicAttackW", "YYBasicBlockB", "YYBasicBlockB", "YYDreamsAndReality", "YYSpacetimeSeam" };

		public static List<string> DeckB = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary", "YYBasicAttackB", "YYBasicAttackB", "YYBasicBlockW", "YYBasicBlockW", "YYBewitchingBait", "YYFleshDismantler" };

		public static PlayerUnitConfig playerUnitConfig;

		static YukariYakumoLoadouts()
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			string modUniqueID = BepinexPlugin.modUniqueID;
			int? num = 0;
			ManaGroup val = default(ManaGroup);
			((ManaGroup)(ref val)).White = 2;
			((ManaGroup)(ref val)).Blue = 0;
			((ManaGroup)(ref val)).Black = 2;
			((ManaGroup)(ref val)).Red = 0;
			((ManaGroup)(ref val)).Green = 0;
			((ManaGroup)(ref val)).Colorless = 0;
			((ManaGroup)(ref val)).Philosophy = 0;
			ManaGroup val2 = val;
			playerUnitConfig = new PlayerUnitConfig(modUniqueID, true, "", 0, 8, num, true, (int?)null, (ManaColor)1, (ManaColor)3, val2, "#C850C8", 100, 0, 0, UltimateSkillA, UltimateSkillB, ExhibitA, ExhibitB, (IReadOnlyList<string>)DeckA, (IReadOnlyList<string>)DeckB, 3, 3);
		}
	}
	public sealed class YukariYakumoModDef : PlayerUnitTemplate
	{
		[EntityLogic(typeof(YukariYakumoModDef))]
		public sealed class YukariYakumoMod : PlayerUnit
		{
			protected override void OnEnterGameRun(GameRunController gameRun)
			{
				((Unit)this).HandleGameRunEvent<StationEventArgs>(((GameEntity)this).GameRun.StationEntered, (GameEventHandler<StationEventArgs>)delegate(StationEventArgs args)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					//IL_000d: Invalid comparison between Unknown and I4
					if ((int)args.Station.Type > 0)
					{
						((MonoBehaviour)GameDirector.Player).StartCoroutine(UnitView_SetTrigger_Patch.AnimateIntro(GameDirector.Player));
					}
				});
			}

			protected override void OnEnterBattle(BattleController battle)
			{
				((Unit)this).HandleBattleEvent<GameEventArgs>(((Unit)this).Battle.BattleStarting, (GameEventHandler<GameEventArgs>)OnBattleStarting, (GameEventPriority)int.MinValue);
				((Unit)this).HandleBattleEvent<StatusEffectEventArgs>(((Unit)((Unit)this).Battle.Player).StatusEffectRemoving, (GameEventHandler<StatusEffectEventArgs>)OnSeRemoving, (GameEventPriority)int.MinValue);
			}

			private void OnBattleStarting(GameEventArgs args)
			{
				((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)new ApplyStatusEffectAction<YYYoukaiOfBoundariesSe>((Unit)(object)((Unit)this).Battle.Player, (int?)0, (int?)0, (int?)0, (int?)0, 0f, true)));
			}

			private void OnSeRemoving(StatusEffectEventArgs args)
			{
				if (args.Effect is YYYoukaiOfBoundariesSe)
				{
					((GameEventArgs)args).CancelBy((GameEntity)(object)this);
				}
			}
		}

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

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

		public override PlayerUnitConfig MakeConfig()
		{
			return YukariYakumoLoadouts.playerUnitConfig;
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace YukariYakumoMod.YukariYakumoUlt
{
	public sealed class YukariYakumoUltBDef : YukariYakumoUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 0;
			defaulUltConfig.PowerCost = 120;
			defaulUltConfig.PowerPerLevel = 120;
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YukariYakumoUltBDef))]
	public sealed class YukariYakumoUltB : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__5 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitSelector selector;

			public UnitSelector <>3__selector;

			public YukariYakumoUltB <>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__5(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_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Owner, "YukariYakumoUltB");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((UltimateSkill)<>4__this).Config.Damage = Math.Abs(<>4__this.CurrentToHalfLife);
					((GameEntity)<>4__this).GameRun.SetHpAndMaxHp((((Unit)((UltimateSkill)<>4__this).Battle.Player).MaxHp + 1) / 2, ((Unit)((UltimateSkill)<>4__this).Battle.Player).MaxHp, true);
					<enemy>5__1 = selector.GetEnemy(((UltimateSkill)<>4__this).Battle);
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)<enemy>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					((UltimateSkill)<>4__this).Config.Damage = 0;
					return false;
				}
			}

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

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

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

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

		public int CurrentToHalfLife
		{
			get
			{
				if (((UltimateSkill)this).Battle != null)
				{
					return (((Unit)((UltimateSkill)this).Battle.Player).MaxHp + 1) / 2 - ((Unit)((UltimateSkill)this).Battle.Player).Hp;
				}
				return 0;
			}
		}

		public int DamageDealt
		{
			get
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				if (((UltimateSkill)this).Battle == null)
				{
					return 0;
				}
				((UltimateSkill)this).Config.Damage = Math.Abs(CurrentToHalfLife);
				return ((UltimateSkill)this).Battle.CalculateDamage((GameEntity)(object)((UltimateSkill)this).Battle.Player, (Unit)(object)((UltimateSkill)this).Battle.Player, (Unit)null, ((UltimateSkill)this).Damage);
			}
		}

		public YukariYakumoUltB()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(4661);
		}

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

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

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

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

		public UltimateSkillConfig GetDefaulUltConfig()
		{
			return YukariYakumoDefaultConfig.DefaultUltConfig();
		}
	}
	public sealed class YukariYakumoUltWDef : YukariYakumoUltTemplate
	{
		public override UltimateSkillConfig MakeConfig()
		{
			UltimateSkillConfig defaulUltConfig = GetDefaulUltConfig();
			defaulUltConfig.Damage = 16;
			defaulUltConfig.Value1 = 16;
			defaulUltConfig.RelativeEffects = new List<string> { "YukariYakumoFantasiaSe" };
			return defaulUltConfig;
		}
	}
	[EntityLogic(typeof(YukariYakumoUltWDef))]
	public sealed class YukariYakumoUltW : UltimateSkill
	{
		[CompilerGenerated]
		private sealed class <Actions>d__3 : 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 YukariYakumoUltW <>4__this;

			private Unit[] <targets>5__1;

			private List<Card> <list>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Expected O, but got Unknown
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)<>4__this).Owner, "YukariYakumoUltW");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<targets>5__1 = selector.GetUnits(((UltimateSkill)<>4__this).Battle);
					<>2__current = (BattleAction)new CastBlockShieldAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (Unit)(object)((UltimateSkill)<>4__this).Owner, <>4__this.Shield, false);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)<>4__this).Owner, (IEnumerable<Unit>)<targets>5__1, ((UltimateSkill)<>4__this).Damage, ((UltimateSkill)<>4__this).GunName, (GunType)0);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<list>5__2 = ((UltimateSkill)<>4__this).Battle.HandZone.Where((Card card) => card.Config.IsUpgradable).ToList();
					<>2__current = (BattleAction)(object)new FantasiaCardsAction(<list>5__2);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

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

		public ShieldInfo Shield => new ShieldInfo(((UltimateSkill)this).Value1, (BlockShieldType)1);

		public YukariYakumoUltW()
		{
			((UltimateSkill)this).TargetType = (TargetType)2;
			((UltimateSkill)this).GunName = GunNameID.GetGunFromId(7321);
		}

		[IteratorStateMachine(typeof(<Actions>d__3))]
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Actions>d__3(-2)
			{
				<>4__this = this,
				<>3__selector = selector
			};
		}
	}
}
namespace YukariYakumoMod.StatusEffects
{
	public sealed class FlatPeachSeDef : YukariYakumoStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(FlatPeachSeDef))]
	public sealed class FlatPeachSe : StatusEffect
	{
	}
	public sealed class YukariYakumoFantasiaSeDef : YukariYakumoStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YukariYakumoFantasiaSeDef))]
	public sealed class YukariYakumoFantasiaSe : StatusEffect
	{
	}
	public sealed class YuyukoDeathSeDef : YukariYakumoStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(YuyukoDeathSeDef))]
	public sealed class YuyukoDeathSe : StatusEffect
	{
	}
	public sealed class EldritchKeywordDef : YukariYakumoStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}
	}
	[EntityLogic(typeof(EldritchKeywordDef))]
	public sealed class EldritchKeyword : StatusEffect
	{
	}
	public sealed class VoidKeywordDef : YukariYakumoStatusEffectTemplate
	{
		public override Sprite LoadSprite()
		{
			return null;
		}

		public override StatusEffectConfig MakeConfig()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			return new StatusEffectConfig(0, "", 10, (StatusEffectType)0, false, true, (int?)null, true, (StackType?)(StackType)0, false, (StackType?)(StackType)0, (DurationDecreaseTiming)0, false, (StackType?)(StackType)3, (StackType?)(StackType)3, false, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (string)null, "Default", "Default", "Default");
		}
	}
	[EntityLogic(typeof(VoidKeywordDef))]
	public sealed class VoidKeyword : StatusEffect
	{
	}
	public class YukariYakumoStatusEffectTemplate : 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(YukariYakumoDefaultConfig.DefaultID((EntityDefinition)(object)this));
		}

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

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

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

		public static StatusEffectConfig GetDefaultStatusEffectConfig()
		{
			return YukariYakumoDefaultConfig.DefaultStatusEffectConfig();
		}
	}
	public sealed class YYAimlessJourneySeDef : YukariYakumoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YukariYakumoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "YukariYakumoFantasiaSe" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YYAimlessJourneySeDef))]
	public sealed class YYAimlessJourneySe : 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 YYAimlessJourneySe <>4__this;

			private List<Card> <list>5__1;

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

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

			[DebuggerHidden]
			public <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()
			{
				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.ExileZone.Where((Card card) => card.Config.IsUpgradable).ToList();
					<>2__current = (BattleAction)(object)new FantasiaCardsAction(<list>5__1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						<>2__current = <>4__this.TakeEffect();
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

		public BattleAction TakeEffect()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<YYNeoSuperExpress>(((StatusEffect)this).Level, false), (AddCardsType)0);
		}
	}
	public sealed class YYBloodfedFlowerbedSeDef : YukariYakumoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YukariYakumoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YYBloodfedFlowerbedSeDef))]
	public sealed class YYBloodfedFlowerbedSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnDamageReceived>d__7 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private DamageEventArgs args;

			public DamageEventArgs <>3__args;

			public YYBloodfedFlowerbedSe <>4__this;

			private IEnumerable<Unit> <AllAliveUnits>5__1;

			private IEnumerator<Unit> <>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 <OnDamageReceived>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Expected O, but got Unknown
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_0104;
					}
					<>1__state = -1;
					if (<>4__this.DamageTaken >= 1 && !((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						<AllAliveUnits>5__1 = ((StatusEffect)<>4__this).Battle.AllAliveUnits;
						<>s__2 = <AllAliveUnits>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_010c;
					}
					goto IL_0132;
					IL_0132:
					return false;
					IL_0104:
					<unit>5__3 = null;
					goto IL_010c;
					IL_010c:
					if (<>s__2.MoveNext())
					{
						<unit>5__3 = <>s__2.Current;
						if (<unit>5__3 != ((StatusEffect)<>4__this).Owner)
						{
							<>2__current = (BattleAction)new DamageAction(((StatusEffect)<>4__this).Owner, <unit>5__3, DamageInfo.HpLose((float)((StatusEffect)<>4__this).Level, false), <>4__this.gunName, (GunType)0);
							<>1__state = 1;
							return true;
						}
						goto IL_0104;
					}
					<>m__Finally1();
					<>s__2 = null;
					<AllAliveUnits>5__1 = null;
					goto IL_0132;
				}
				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()
			{
				<OnDamageReceived>d__7 <OnDamageReceived>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnDamageReceived>d__ = this;
				}
				else
				{
					<OnDamageReceived>d__ = new <OnDamageReceived>d__7(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnDamageReceived>d__.args = <>3__args;
				return <OnDamageReceived>d__;
			}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YYBloodfedFlowerbedSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					<>2__current = (BattleAction)new DamageAction(((StatusEffect)<>4__this).Owner, ((StatusEffect)<>4__this).Owner, DamageInfo.HpLose((float)((StatusEffect)<>4__this).Count, false), <>4__this.gunName, (GunType)0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Owner.IsAlive)
					{
						<>2__current = (BattleAction)new HealAction(((StatusEffect)<>4__this).Owner, ((StatusEffect)<>4__this).Owner, ((StatusEffect)<>4__this).Count, (HealType)0, 0.2f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

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

		private string gunName = "Lily";

		private int DamageTaken { get; set; }

		protected override void OnAdded(Unit unit)
		{
			if (((StatusEffect)this).Count <= 0)
			{
				Debug.LogError((object)(((GameEntity)this).DebugName + "'s count not provided, set to 4 (default)"));
				((StatusEffect)this).Count = 4;
			}
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(unit.DamageTaking, (GameEventHandler<DamageEventArgs>)OnDamageTaking, (GameEventPriority)int.MinValue);
			((StatusEffect)this).ReactOwnerEvent<DamageEventArgs>(unit.DamageReceived, (EventSequencedReactor<DamageEventArgs>)OnDamageReceived);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(unit.TurnEnded, (EventSequencedReactor<UnitEventArgs>)OnTurnEnded);
		}

		private void OnDamageTaking(DamageEventArgs args)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			DamageTaken = MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage);
		}

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

		[IteratorStateMachine(typeof(<OnTurnEnded>d__8))]
		private IEnumerable<BattleAction> OnTurnEnded(UnitEventArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnTurnEnded>d__8(-2)
			{
				<>4__this = this,
				<>3__args = args
			};
		}
	}
	public sealed class YYButterflyLurkingSeDef : YukariYakumoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YukariYakumoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.HasLevel = false;
			defaultStatusEffectConfig.RelativeEffects = new List<string> { "YukariYakumoFantasiaSe" };
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YYButterflyLurkingSeDef))]
	public sealed class YYButterflyLurkingSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnCardsAddedToDrawZone>d__3 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardsAddingToDrawZoneEventArgs args;

			public CardsAddingToDrawZoneEventArgs <>3__args;

			public YYButterflyLurkingSe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = <>4__this.Fantasia(args.Cards);
					<>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()
			{
				<OnCardsAddedToDrawZone>d__3 <OnCardsAddedToDrawZone>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardsAddedToDrawZone>d__ = this;
				}
				else
				{
					<OnCardsAddedToDrawZone>d__ = new <OnCardsAddedToDrawZone>d__3(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardsAddedToDrawZone>d__.args = <>3__args;
				return <OnCardsAddedToDrawZone>d__;
			}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private CardMovingToDrawZoneEventArgs args;

			public CardMovingToDrawZoneEventArgs <>3__args;

			public YYButterflyLurkingSe <>4__this;

			private List<Card> <list>5__1;

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

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

			[DebuggerHidden]
			public <OnCardsMovingToDrawZone>d__2(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()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<list>5__1 = new List<Card> { args.Card };
					<>2__current = <>4__this.Fantasia(<list>5__1);
					<>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()
			{
				<OnCardsMovingToDrawZone>d__2 <OnCardsMovingToDrawZone>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnCardsMovingToDrawZone>d__ = this;
				}
				else
				{
					<OnCardsMovingToDrawZone>d__ = new <OnCardsMovingToDrawZone>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnCardsMovingToDrawZone>d__.args = <>3__args;
				return <OnCardsMovingToDrawZone>d__;
			}

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private GameEventArgs args;

			public GameEventArgs <>3__args;

			public YYButterflyLurkingSe <>4__this;

			private List<Card> <list>5__1;

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

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

			[DebuggerHidden]
			public <Reshuffled>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()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<list>5__1 = ((StatusEffect)<>4__this).Battle.DrawZoneIndexOrder.Where((Card card) => card.Config.IsUpgradable).ToList();
					if (<list>5__1.Count == 0)
					{
						return false;
					}
					<>4__this.<>n__0();
					<>2__current = (BattleAction)(object)new FantasiaCardsAction(<list>5__1);
					<>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()
			{
				<Reshuffled>d__1 <Reshuffled>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Reshuffled>d__ = this;
				}
				else
				{
					<Reshuffled>d__ = new <Reshuffled>d__1(0)
					{
						<>4__this = <>4__this
					};
				}
				<Reshuffled>d__.args = <>3__args;
				return <Reshuffled>d__;
			}

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

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<GameEventArgs>(((StatusEffect)this).Battle.Reshuffled, (EventSequencedReactor<GameEventArgs>)Reshuffled, (GameEventPriority)int.MaxValue);
			((StatusEffect)this).ReactOwnerEvent<CardMovingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardMovingToDrawZone, (EventSequencedReactor<CardMovingToDrawZoneEventArgs>)OnCardsMovingToDrawZone);
			((StatusEffect)this).ReactOwnerEvent<CardsAddingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardsAddedToDrawZone, (EventSequencedReactor<CardsAddingToDrawZoneEventArgs>)OnCardsAddedToDrawZone);
		}

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

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

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

		private BattleAction Fantasia(IEnumerable<Card> cards)
		{
			List<Card> list = cards.Where((Card card) => card.Config.IsUpgradable).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			((StatusEffect)this).NotifyActivating();
			return (BattleAction)(object)new FantasiaCardsAction(list);
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YYCelestialWizardrySeDef : YukariYakumoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YukariYakumoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)0;
			defaultStatusEffectConfig.HasCount = true;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YYCelestialWizardrySeDef))]
	public sealed class YYCelestialWizardrySe : 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 YYCelestialWizardrySe <>4__this;

			private List<Card> <exilePile>5__1;

			private List<Card> <drawPile>5__2;

			private List<Card>.Enumerator <>s__3;

			private Card <card>5__4;

			private List<Card>.Enumerator <>s__5;

			private Card <card2>5__6;

			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()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<exilePile>5__1 = null;
				<drawPile>5__2 = null;
				<>s__3 = default(List<Card>.Enumerator);
				<card>5__4 = null;
				<>s__5 = default(List<Card>.Enumerator);
				<card2>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0232: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Expected O, but got Unknown
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Invalid comparison between Unknown and I4
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Invalid comparison between Unknown and I4
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_0213: Expected O, but got Unknown
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Expected O, but got Unknown
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ae: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
						{
							return false;
						}
						<exilePile>5__1 = ((StatusEffect)<>4__this).Battle.ExileZone.ToList();
						<drawPile>5__2 = ((StatusEffect)<>4__this).Battle.DrawZone.ToList();
						if (<exilePile>5__1.Count > 0 || <drawPile>5__2.Count > 0)
						{
							<>4__this.<>n__0();
						}
						<>s__3 = <exilePile>5__1.GetEnumerator();
						<>1__state = -3;
						goto IL_013a;
					case 1:
						<>1__state = -3;
						goto IL_0132;
					case 2:
						<>1__state = -4;
						goto IL_01c4;
					case 3:
						<>1__state = -1;
						<>2__current = (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)<>4__this, true, 0.1f);
						<>1__state = 4;
						return true;
					case 4:
						{
							<>1__state = -1;
							return false;
						}
						IL_013a:
						if (<>s__3.MoveNext())
						{
							<card>5__4 = <>s__3.Current;
							if ((int)<card>5__4.Zone == 4)
							{
								<>2__current = (BattleAction)new MoveCardToDrawZoneAction(<card>5__4, (DrawZoneTarget)0);
								<>1__state = 1;
								return true;
							}
							goto IL_0132;
						}
						<>m__Finally1();
						<>s__3 = default(List<Card>.Enumerator);
						<>s__5 = <drawPile>5__2.GetEnumerator();
						<>1__state = -4;
						goto IL_01cc;
						IL_0132:
						<card>5__4 = null;
						goto IL_013a;
						IL_01c4:
						<card2>5__6 = null;
						goto IL_01cc;
						IL_01cc:
						if (<>s__5.MoveNext())
						{
							<card2>5__6 = <>s__5.Current;
							if ((int)<card2>5__6.Zone == 1)
							{
								<>2__current = (BattleAction)new MoveCardAction(<card2>5__6, (CardZone)4);
								<>1__state = 2;
								return true;
							}
							goto IL_01c4;
						}
						<>m__Finally2();
						<>s__5 = default(List<Card>.Enumerator);
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new ScryAction(new ScryInfo(((StatusEffect)<>4__this).Level));
						<>1__state = 3;
						return true;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

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

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YYCelestialWizardrySe <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						return false;
					}
					if (((StatusEffect)<>4__this).Count > 0)
					{
						<>4__this.<>n__0();
						<>2__current = (BattleAction)new ScryAction(new ScryInfo(((StatusEffect)<>4__this).Count));
						<>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()
			{
				<OnPlayerTurnStarting>d__2 <OnPlayerTurnStarting>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnStarting>d__ = this;
				}
				else
				{
					<OnPlayerTurnStarting>d__ = new <OnPlayerTurnStarting>d__2(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerTurnStarting>d__.args = <>3__args;
				return <OnPlayerTurnStarting>d__;
			}

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

		protected override string GetBaseDescription()
		{
			if (((StatusEffect)this).Count == 0)
			{
				return ((GameEntity)this).GetBaseDescription();
			}
			return ((StatusEffect)this).ExtraDescription;
		}

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

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

		[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 YYDeusExMachinaSeDef : YukariYakumoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YukariYakumoStatusEffectTemplate.GetDefaultStatusEffectConfig();
			defaultStatusEffectConfig.Type = (StatusEffectType)2;
			defaultStatusEffectConfig.HasLevel = false;
			return defaultStatusEffectConfig;
		}
	}
	[EntityLogic(typeof(YYDeusExMachinaSeDef))]
	public sealed class YYDeusExMachinaSe : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <OnPlayerTurnEnding>d__8 : IEnumerable<BattleAction>, IEnumerable, IEnumerator<BattleAction>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BattleAction <>2__current;

			private int <>l__initialThreadId;

			private UnitEventArgs args;

			public UnitEventArgs <>3__args;

			public YYDeusExMachinaSe <>4__this;

			private List<Card> <list>5__1;

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

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

			[DebuggerHidden]
			public <OnPlayerTurnEnding>d__8(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_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Expected O, but got Unknown
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!<>4__this.Active)
					{
						break;
					}
					<>4__this.<>n__0();
					<list>5__1 = ((StatusEffect)<>4__this).Battle.HandZone.Select((Card card) => card).ToList();
					if (!CollectionsExtensions.Empty<Card>((IReadOnlyCollection<Card>)<list>5__1))
					{
						<>2__current = (BattleAction)new ExileManyCardAction((IEnumerable<Card>)<list>5__1);
						<>1__state = 1;
						return true;
					}
					goto IL_00e6;
				case 1:
					<>1__state = -1;
					goto IL_00e6;
				case 2:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Sfx("ExtraTurnLaunch", 0f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (BattleAction)(object)PerformAction.Animation((Unit)(object)((StatusEffect)<>4__this).Battle.Player, "spell", 1.6f, (string)null, 0f, -1);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					if (!((StatusEffect)<>4__this).Battle.BattleShouldEnd)
					{
						<>2__current = ((StatusEffect)<>4__this).BuffAction<ExtraTurn>(1, 0, 0, 0, 0.2f);
						<>1__state = 5;
						return true;
					}
					goto IL_01c9;
				case 5:
					<>1__state = -1;
					goto IL_01c9;
				case 6:
					{
						<>1__state = -1;
						<list>5__1 = null;
						break;
					}
					IL_00e6:
					<>2__current = (BattleAction)(object)PerformAction.Effect((Unit)(object)((StatusEffect)<>4__this).Battle.Player, "ExtraTime", 0f, (string)null, 0f, (EffectBehavior)0, 0f);
					<>1__state = 2;
					return true;
					IL_01c9:
					<>2__current = (BattleAction)new RequestEndPlayerTurnAction();
					<>1__state = 6;
					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__8 <OnPlayerTurnEnding>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<OnPlayerTurnEnding>d__ = this;
				}
				else
				{
					<OnPlayerTurnEnding>d__ = new <OnPlayerTurnEnding>d__8(0)
					{
						<>4__this = <>4__this
					};
				}
				<OnPlayerTurnEnding>d__.args = <>3__args;
				return <OnPlayerTurnEnding>d__;
			}

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

		public int DrawZoneCount
		{
			get
			{
				if (((StatusEffect)this).Battle == null)
				{
					return 0;
				}
				return ((StatusEffect)this).Battle.DrawZone.Count;
			}
		}

		private bool Active => DrawZoneCount != 0 && DrawZoneCount % 2 == 0;

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<CardEventArgs>(((StatusEffect)this).Battle.CardDrawn, (GameEventHandler<CardEventArgs>)OnCardDrawn);
			((StatusEffect)this).HandleOwnerEvent<CardsAddingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardsAddedToDrawZone, (GameEventHandler<CardsAddingToDrawZoneEventArgs>)OnCardsAddedToDrawZone);
			((StatusEffect)this).HandleOwnerEvent<CardMovingToDrawZoneEventArgs>(((StatusEffect)this).Battle.CardMovedToDrawZone, (GameEventHandler<CardMovingToDrawZoneEventArgs>)OnCardMovedToDrawZone);
			((StatusEffect)this).ReactOwnerEvent<UnitEventArgs>(((Unit)((StatusEffect)this).Battle.Player).TurnEnding, (EventSequencedReactor<UnitEventArgs>)OnPlayerTurnEnding);
		}

		private void OnCardDrawn(CardEventArgs args)
		{
			((StatusEffect)this).Highlight = Active;
		}

		private void OnCardsAddedToDrawZone(CardsAddingToDrawZoneEventArgs args)
		{
			((StatusEffect)this).Highlight = Active;
		}

		private void OnCardMovedToDrawZone(CardMovingToDrawZoneEventArgs args)
		{
			((StatusEffect)this).Highlight = Active;
		}

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

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class YYFantasticBlossomSeDef : YukariYakumoStatusEffectTemplate
	{
		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig defaultStatusEffectConfig = YukariYakumoStatusEffectTemplate.GetDefaultSt