using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using AttackOfTheHowards;
using FlatLand;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppRUMBLE.Environment.Howard;
using Il2CppRUMBLE.Interactions.InteractionBase;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.MoveSystem;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using MelonLoader;
using RumbleModUI;
using RumbleModdingAPI;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Main), "AttackOfTheHowards", "1.3.2", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 6, 6, true)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AttackOfTheHowards")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5c12a75eb11084f9f6352b997a4d4de940eabd1f")]
[assembly: AssemblyProduct("AttackOfTheHowards")]
[assembly: AssemblyTitle("AttackOfTheHowards")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AttackOfTheHowards;

[RegisterTypeInIl2Cpp]
public class HowardCombat : MonoBehaviour
{
	private class Attack
	{
		public string name;

		public IEnumerator doMoves;

		public float minDistanceToUse;

		public float maxDistanceToUse;

		public Attack(string name, float minDistance, float maxDistance, IEnumerator moves)
		{
			this.name = name;
			doMoves = moves;
			minDistanceToUse = minDistance;
			maxDistanceToUse = maxDistance;
		}

		public bool IsWithinRange(float distance)
		{
			return minDistanceToUse <= distance && distance <= maxDistanceToUse;
		}
	}

	[CompilerGenerated]
	private sealed class <CastBallStraight>d__29 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[2], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastBallUppercutStraight>d__36 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[2], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.75f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeKickStraightUppercut>d__53 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeKickUppercutStraight>d__50 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeStraight>d__31 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeStraightUppercut>d__34 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeStraightUppercutKick>d__41 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeUppercutKickStraight>d__44 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Expected O, but got Unknown
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeUppercutStraight>d__38 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastCubeUppercutStraightKick>d__47 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[3], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastDisc>d__27 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[0], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastDiscStraight>d__28 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[0], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarKickStraightUppercut>d__54 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarKickUppercutStraight>d__51 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarPillarStraightStraightUppercut>d__55 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Expected O, but got Unknown
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 7;
				return true;
			case 7:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 8;
				return true;
			case 8:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 9;
				return true;
			case 9:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarStraight>d__30 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarStraightUppercut>d__33 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarStraightUppercutKick>d__42 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarUppercutKickStraight>d__45 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Expected O, but got Unknown
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarUppercutStraight>d__37 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.3f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastPillarUppercutStraightKick>d__48 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[1], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallKickStraightUppercut>d__52 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallKickUppercutStraight>d__49 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallStraight>d__32 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallStraightUppercut>d__35 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallStraightUppercutKick>d__40 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallUppercutKickStraight>d__43 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Expected O, but got Unknown
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Kick");
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[7], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.6f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallUppercutStraight>d__39 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.4f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[5], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.attackRunning = false;
				return false;
			}
		}

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

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

	[CompilerGenerated]
	private sealed class <CastWallUppercutStraightKick>d__46 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private WaitForSeconds <>2__current;

		public HowardCombat <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.attackRunning = true;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("SpawnStructure");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[4], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				<>2__current = new WaitForSeconds(0.2f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				try
				{
					<>4__this.thisHowardComponent.Execute(Main.availableStacks[6], (StackConfiguration)null);
				}
				catch
				{
					<>4__this.attackRunning = false;
					return false;
				}
				try
				{
					<>4__this.thisHowardAnimator.SetAnimationTrigger("Straight");
				}
				catch
				{
					<>4__this.attackRunning = false;
					retu