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 Microsoft.CodeAnalysis;
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.1.0", "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+c703538785bb2d41da24cd78e355464c06190655")]
[assembly: AssemblyProduct("AttackOfTheHowards")]
[assembly: AssemblyTitle("AttackOfTheHowards")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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 = (object)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<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HowardCombat <>4__this;

			object IEnumerator<object>.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 t