using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using InControl;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("SeparateFloating")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SeparateFloating")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("4bd8ccac-9134-44ed-acd3-4bcfcc8cce8b")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("com.EylonShachmon.SeparateFloating", "Separate Floating", "1.0.4")]
public class SeparateFloatingClass : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <TranspilerDoDoubleJump>d__26 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private CodeInstruction <>2__current;

		private int <>l__initialThreadId;

		private IEnumerable<CodeInstruction> instructions;

		public IEnumerable<CodeInstruction> <>3__instructions;

		private bool <injectedAlready>5__1;

		private IEnumerator<CodeInstruction> <>s__2;

		private CodeInstruction <instr>5__3;

		private MethodInfo <mi>5__4;

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

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

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

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

		private bool MoveNext()
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<injectedAlready>5__1 = false;
					<>s__2 = instructions.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -3;
					<injectedAlready>5__1 = true;
					break;
				case 4:
					<>1__state = -3;
					<mi>5__4 = null;
					<instr>5__3 = null;
					break;
				}
				if (<>s__2.MoveNext())
				{
					<instr>5__3 = <>s__2.Current;
					if (<instr>5__3.opcode == OpCodes.Call)
					{
						object operand = <instr>5__3.operand;
						<mi>5__4 = operand as MethodInfo;
						if ((object)<mi>5__4 != null && <mi>5__4 == canFloatMethod)
						{
							if (!<injectedAlready>5__1)
							{
								<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
								<>1__state = 1;
								return true;
							}
							Debug.LogError((object)"Separate-Float buildtime error: trying to turn off DoDoubleJump float check in 2 places");
						}
					}
					<>2__current = <instr>5__3;
					<>1__state = 4;
					return true;
				}
				<>m__Finally1();
				<>s__2 = null;
				if (!<injectedAlready>5__1)
				{
					Debug.LogError((object)"Separate-Float buildtime error: Line to remove updrift check has not been found (1)");
				}
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

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

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

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

		[DebuggerHidden]
		IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
		{
			<TranspilerDoDoubleJump>d__26 <TranspilerDoDoubleJump>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<TranspilerDoDoubleJump>d__ = this;
			}
			else
			{
				<TranspilerDoDoubleJump>d__ = new <TranspilerDoDoubleJump>d__26(0);
			}
			<TranspilerDoDoubleJump>d__.instructions = <>3__instructions;
			return <TranspilerDoDoubleJump>d__;
		}

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

	[CompilerGenerated]
	private sealed class <TranspilerDoubleJump>d__27 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private CodeInstruction <>2__current;

		private int <>l__initialThreadId;

		private IEnumerable<CodeInstruction> instructions;

		public IEnumerable<CodeInstruction> <>3__instructions;

		private bool <injectedAlready>5__1;

		private IEnumerator<CodeInstruction> <>s__2;

		private CodeInstruction <instr>5__3;

		private MethodInfo <mi>5__4;

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

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

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

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

		private bool MoveNext()
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<injectedAlready>5__1 = false;
					<>s__2 = instructions.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -3;
					<injectedAlready>5__1 = true;
					break;
				case 4:
					<>1__state = -3;
					<mi>5__4 = null;
					<instr>5__3 = null;
					break;
				}
				if (<>s__2.MoveNext())
				{
					<instr>5__3 = <>s__2.Current;
					if (<instr>5__3.opcode == OpCodes.Call)
					{
						object operand = <instr>5__3.operand;
						<mi>5__4 = operand as MethodInfo;
						if ((object)<mi>5__4 != null && <mi>5__4 == canFloatMethod)
						{
							if (!<injectedAlready>5__1)
							{
								<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
								<>1__state = 1;
								return true;
							}
							Debug.LogError((object)"Separate-Float buildtime error: trying to turn off DoubleJump float check in 2 places");
						}
					}
					<>2__current = <instr>5__3;
					<>1__state = 4;
					return true;
				}
				<>m__Finally1();
				<>s__2 = null;
				if (!<injectedAlready>5__1)
				{
					Debug.LogError((object)"Separate-Float buildtime error: Line to remove updrift check has not been found (2)");
				}
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

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

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

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

		[DebuggerHidden]
		IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
		{
			<TranspilerDoubleJump>d__27 <TranspilerDoubleJump>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<TranspilerDoubleJump>d__ = this;
			}
			else
			{
				<TranspilerDoubleJump>d__ = new <TranspilerDoubleJump>d__27(0);
			}
			<TranspilerDoubleJump>d__.instructions = <>3__instructions;
			return <TranspilerDoubleJump>d__;
		}

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

	[CompilerGenerated]
	private sealed class <TranspilerFixedUpdate>d__24 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private CodeInstruction <>2__current;

		private int <>l__initialThreadId;

		private IEnumerable<CodeInstruction> instructions;

		public IEnumerable<CodeInstruction> <>3__instructions;

		private FieldInfo <floatingField>5__1;

		private bool <injectedAlready>5__2;

		private IEnumerator<CodeInstruction> <>s__3;

		private CodeInstruction <instr>5__4;

		private FieldInfo <fi>5__5;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || (uint)(num - 1) <= 2u)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<floatingField>5__1 = null;
			<>s__3 = null;
			<instr>5__4 = null;
			<fi>5__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<floatingField>5__1 = AccessTools.Field(typeof(HeroControllerStates), "floating");
					<injectedAlready>5__2 = false;
					<>s__3 = instructions.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					<injectedAlready>5__2 = true;
					break;
				case 3:
					<>1__state = -3;
					<fi>5__5 = null;
					<instr>5__4 = null;
					break;
				}
				if (<>s__3.MoveNext())
				{
					<instr>5__4 = <>s__3.Current;
					if (<instr>5__4.opcode == OpCodes.Ldfld)
					{
						object operand = <instr>5__4.operand;
						<fi>5__5 = operand as FieldInfo;
						if ((object)<fi>5__5 != null && <fi>5__5 == <floatingField>5__1)
						{
							if (!<injectedAlready>5__2)
							{
								<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
								<>1__state = 1;
								return true;
							}
							Debug.LogError((object)"Separate-Float buildtime error: trying to turn off FixedUpdate float check in 2 places");
						}
					}
					<>2__current = <instr>5__4;
					<>1__state = 3;
					return true;
				}
				<>m__Finally1();
				<>s__3 = null;
				if (!<injectedAlready>5__2)
				{
					Debug.LogError((object)"Separate-Float buildtime error: Line to remove floating check has not been found");
				}
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

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

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

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

		[DebuggerHidden]
		IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
		{
			<TranspilerFixedUpdate>d__24 <TranspilerFixedUpdate>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<TranspilerFixedUpdate>d__ = this;
			}
			else
			{
				<TranspilerFixedUpdate>d__ = new <TranspilerFixedUpdate>d__24(0);
			}
			<TranspilerFixedUpdate>d__.instructions = <>3__instructions;
			return <TranspilerFixedUpdate>d__;
		}

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

	[CompilerGenerated]
	private sealed class <TranspilerLookForInput>d__22 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private CodeInstruction <>2__current;

		private int <>l__initialThreadId;

		private IEnumerable<CodeInstruction> instructions;

		public IEnumerable<CodeInstruction> <>3__instructions;

		private FieldInfo <floatingField>5__1;

		private MethodInfo <filterInputMethod>5__2;

		private bool <injectedAlready>5__3;

		private IEnumerator<CodeInstruction> <>s__4;

		private CodeInstruction <instr>5__5;

		private FieldInfo <fi>5__6;

		private MethodInfo <mi>5__7;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || (uint)(num - 1) <= 4u)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<floatingField>5__1 = null;
			<filterInputMethod>5__2 = null;
			<>s__4 = null;
			<instr>5__5 = null;
			<fi>5__6 = null;
			<mi>5__7 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<floatingField>5__1 = AccessTools.Field(typeof(HeroControllerStates), "floating");
					<filterInputMethod>5__2 = AccessTools.Method(typeof(HeroController), "FilterInput", (Type[])null, (Type[])null);
					<injectedAlready>5__3 = false;
					<>s__4 = instructions.GetEnumerator();
					<>1__state = -3;
					goto IL_0274;
				case 1:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					goto IL_0274;
				case 3:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SeparateFloatingClass), "FloatingCancelButtonChecker", (Type[])null, (Type[])null));
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -3;
					<injectedAlready>5__3 = true;
					goto IL_023f;
				case 5:
					{
						<>1__state = -3;
						<fi>5__6 = null;
						<mi>5__7 = null;
						<instr>5__5 = null;
						goto IL_0274;
					}
					IL_0274:
					if (<>s__4.MoveNext())
					{
						<instr>5__5 = <>s__4.Current;
						if (<instr>5__5.opcode == OpCodes.Stfld)
						{
							object operand = <instr>5__5.operand;
							<fi>5__6 = operand as FieldInfo;
							if ((object)<fi>5__6 != null && <fi>5__6 == <floatingField>5__1)
							{
								<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
								<>1__state = 1;
								return true;
							}
						}
						if (<instr>5__5.opcode == OpCodes.Call)
						{
							object operand = <instr>5__5.operand;
							<mi>5__7 = operand as MethodInfo;
							if ((object)<mi>5__7 != null && <mi>5__7 == <filterInputMethod>5__2)
							{
								if (!<injectedAlready>5__3)
								{
									<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
									<>1__state = 3;
									return true;
								}
								Debug.LogError((object)"Separate-Float buildtime error: Trying to turn off float in 2 places");
							}
						}
						goto IL_023f;
					}
					<>m__Finally1();
					<>s__4 = null;
					if (!<injectedAlready>5__3)
					{
						Debug.LogError((object)"Separate-Float buildtime error: Line to add back floating has not been found");
					}
					return false;
					IL_023f:
					<>2__current = <instr>5__5;
					<>1__state = 5;
					return true;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

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

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

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

		[DebuggerHidden]
		IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
		{
			<TranspilerLookForInput>d__22 <TranspilerLookForInput>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<TranspilerLookForInput>d__ = this;
			}
			else
			{
				<TranspilerLookForInput>d__ = new <TranspilerLookForInput>d__22(0);
			}
			<TranspilerLookForInput>d__.instructions = <>3__instructions;
			return <TranspilerLookForInput>d__;
		}

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

	[CompilerGenerated]
	private sealed class <TranspilerLookForQueueInput>d__23 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private CodeInstruction <>2__current;

		private int <>l__initialThreadId;

		private IEnumerable<CodeInstruction> instructions;

		public IEnumerable<CodeInstruction> <>3__instructions;

		private MethodInfo <canFloatMethod>5__1;

		private FieldInfo <regainControlJumpQueuedField>5__2;

		private FieldInfo <acceptingInputField>5__3;

		private bool <injectedAlready>5__4;

		private IEnumerator<CodeInstruction> <>s__5;

		private CodeInstruction <instr>5__6;

		private MethodInfo <mi>5__7;

		private FieldInfo <fi1>5__8;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || (uint)(num - 1) <= 5u)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<canFloatMethod>5__1 = null;
			<regainControlJumpQueuedField>5__2 = null;
			<acceptingInputField>5__3 = null;
			<>s__5 = null;
			<instr>5__6 = null;
			<mi>5__7 = null;
			<fi1>5__8 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Expected O, but got Unknown
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Expected O, but got Unknown
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<canFloatMethod>5__1 = AccessTools.Method(typeof(HeroController), "CanFloat", (Type[])null, (Type[])null);
					<regainControlJumpQueuedField>5__2 = AccessTools.Field(typeof(HeroController), "regainControlJumpQueued");
					<acceptingInputField>5__3 = AccessTools.Field(typeof(HeroController), "acceptingInput");
					<injectedAlready>5__4 = false;
					<>s__5 = instructions.GetEnumerator();
					<>1__state = -3;
					goto IL_02c3;
				case 1:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -3;
					goto IL_02c3;
				case 4:
					<>1__state = -3;
					<>2__current = new CodeInstruction(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SeparateFloatingClass), "FloatingButtonChecker", (Type[])null, (Type[])null)));
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -3;
					<injectedAlready>5__4 = true;
					goto IL_028e;
				case 6:
					{
						<>1__state = -3;
						<mi>5__7 = null;
						<fi1>5__8 = null;
						<instr>5__6 = null;
						goto IL_02c3;
					}
					IL_02c3:
					if (<>s__5.MoveNext())
					{
						<instr>5__6 = <>s__5.Current;
						if (<instr>5__6.opcode == OpCodes.Call)
						{
							object operand = <instr>5__6.operand;
							<mi>5__7 = operand as MethodInfo;
							if ((object)<mi>5__7 != null && <mi>5__7 == <canFloatMethod>5__1)
							{
								<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
								<>1__state = 1;
								return true;
							}
						}
						if (<instr>5__6.opcode == OpCodes.Stfld)
						{
							object operand = <instr>5__6.operand;
							<fi1>5__8 = operand as FieldInfo;
							if ((object)<fi1>5__8 != null && <fi1>5__8 == <regainControlJumpQueuedField>5__2)
							{
								if (!<injectedAlready>5__4)
								{
									<>2__current = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
									<>1__state = 4;
									return true;
								}
								Debug.LogError((object)"Separate-Float buildtime error: Trying to add StartFloat in 2 places");
							}
						}
						goto IL_028e;
					}
					<>m__Finally1();
					<>s__5 = null;
					if (!<injectedAlready>5__4)
					{
						Debug.LogError((object)"Separate-Float buildtime error: Line to put StartFloat has not been found");
					}
					return false;
					IL_028e:
					<>2__current = <instr>5__6;
					<>1__state = 6;
					return true;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

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

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

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

		[DebuggerHidden]
		IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
		{
			<TranspilerLookForQueueInput>d__23 <TranspilerLookForQueueInput>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<TranspilerLookForQueueInput>d__ = this;
			}
			else
			{
				<TranspilerLookForQueueInput>d__ = new <TranspilerLookForQueueInput>d__23(0);
			}
			<TranspilerLookForQueueInput>d__.instructions = <>3__instructions;
			return <TranspilerLookForQueueInput>d__;
		}

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

	[CompilerGenerated]
	private sealed class <TranspilerRegainControl>d__25 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private CodeInstruction <>2__current;

		private int <>l__initialThreadId;

		private IEnumerable<CodeInstruction> instructions;

		public IEnumerable<CodeInstruction> <>3__instructions;

		private bool <injectedAlready>5__1;

		private IEnumerator<CodeInstruction> <>s__2;

		private CodeInstruction <instr>5__3;

		private MethodInfo <mi>5__4;

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

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

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

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

		private bool MoveNext()
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<injectedAlready>5__1 = false;
					<>s__2 = instructions.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -3;
					<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -3;
					<injectedAlready>5__1 = true;
					break;
				case 4:
					<>1__state = -3;
					<mi>5__4 = null;
					<instr>5__3 = null;
					break;
				}
				if (<>s__2.MoveNext())
				{
					<instr>5__3 = <>s__2.Current;
					if (<instr>5__3.opcode == OpCodes.Call)
					{
						object operand = <instr>5__3.operand;
						<mi>5__4 = operand as MethodInfo;
						if ((object)<mi>5__4 != null && <mi>5__4 == canFloatMethod)
						{
							if (!<injectedAlready>5__1)
							{
								<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
								<>1__state = 1;
								return true;
							}
							Debug.LogError((object)"Separate-Float buildtime error: trying to turn off RegainControl float check in 2 places");
						}
					}
					<>2__current = <instr>5__3;
					<>1__state = 4;
					return true;
				}
				<>m__Finally1();
				<>s__2 = null;
				if (!<injectedAlready>5__1)
				{
					Debug.LogError((object)"Separate-Float buildtime error: Line to remove float check has not been found");
				}
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

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

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

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

		[DebuggerHidden]
		IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
		{
			<TranspilerRegainControl>d__25 <TranspilerRegainControl>d__;
			if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
			{
				<>1__state = 0;
				<TranspilerRegainControl>d__ = this;
			}
			else
			{
				<TranspilerRegainControl>d__ = new <TranspilerRegainControl>d__25(0);
			}
			<TranspilerRegainControl>d__.instructions = <>3__instructions;
			return <TranspilerRegainControl>d__;
		}

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

	private static readonly FieldInfo inputHandlerField = AccessTools.Field(typeof(HeroController), "inputHandler");

	private static readonly MethodInfo startFloatMethod = AccessTools.Method(typeof(HeroController), "StartFloat", (Type[])null, (Type[])null);

	private static readonly MethodInfo canFloatMethod = AccessTools.Method(typeof(HeroController), "CanFloat", (Type[])null, (Type[])null);

	private static readonly FieldInfo wallFloatThingField = AccessTools.Field(typeof(HeroController), "queuedWallJumpInterrupt");

	private static readonly FieldInfo gmJumpToFloatField = AccessTools.Field(typeof(ListenForJump), "gm");

	private static readonly FieldInfo inputJumpToFloatField = AccessTools.Field(typeof(ListenForJump), "inputHandler");

	private static readonly FieldInfo gmHeroControllerField = AccessTools.Field(typeof(HeroController), "gm");

	private static readonly MethodInfo doDoubleJumpMethod = AccessTools.Method(typeof(HeroController), "DoDoubleJump", (Type[])null, (Type[])null);

	private static readonly FieldInfo needleStrikeTimerField = AccessTools.Field(typeof(HeroController), "nailChargeTimer");

	private static readonly PropertyInfo ChargeTimePropery = AccessTools.Property(typeof(HeroController), "CurrentNailChargeTime");

	private static readonly FieldInfo waterHcField = AccessTools.Field(typeof(HeroWaterController), "hc");

	private static int frameCounter = 0;

	private static float Floatingbuffer = 0f;

	private void Awake()
	{
		Harmony.CreateAndPatchAll(typeof(SeparateFloatingClass), (string)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"SeparateFloating plugin loaded");
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "Update")]
	private static void generalUpdater(HeroController __instance)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Expected O, but got Unknown
		frameCounter++;
		if (Floatingbuffer > 0f)
		{
			GameManager val = (GameManager)gmHeroControllerField.GetValue(__instance);
			if ((Object)(object)val != (Object)null && !val.isPaused)
			{
				Floatingbuffer -= Time.unscaledDeltaTime;
			}
			else
			{
				float num = 0f;
				num += Time.unscaledDeltaTime;
			}
		}
		if (Floatingbuffer < 0f)
		{
			Floatingbuffer = 0f;
		}
	}

	public static void CancelFloat(HeroController hc)
	{
		if (hc.cState.floating)
		{
			hc.cState.floating = false;
			Floatingbuffer = 0.25f;
		}
	}

	public static void FloatingButtonChecker(HeroController hc)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		InputHandler val = (InputHandler)inputHandlerField.GetValue(hc);
		bool flag = (bool)wallFloatThingField.GetValue(hc);
		object[] parameters = new object[1] { true };
		if (!hc.acceptingInput || hc.cState.floating || flag || hc.wallLocked || !(Floatingbuffer <= 0f) || hc.cState.jumping || hc.cState.doubleJumping)
		{
			return;
		}
		if (((OneAxisInputControl)val.inputActions.OpenInventoryQuests).WasPressed)
		{
			if ((bool)canFloatMethod.Invoke(hc, parameters))
			{
				startFloatMethod.Invoke(hc, null);
			}
		}
		else if (((OneAxisInputControl)val.inputActions.OpenInventoryQuests).IsPressed && (bool)canFloatMethod.Invoke(hc, new object[1] { true }))
		{
			startFloatMethod.Invoke(hc, null);
		}
	}

	public static void FloatingCancelButtonChecker(HeroController hc)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		InputHandler val = (InputHandler)inputHandlerField.GetValue(hc);
		if (!((OneAxisInputControl)val.inputActions.OpenInventoryQuests).IsPressed)
		{
			CancelFloat(hc);
		}
	}

	[HarmonyPostfix]
	[HarmonyPatch(typeof(HeroController), "StartFloat")]
	private static void FloatStateFlag(HeroController __instance)
	{
		if (__instance.cState.floating)
		{
			Debug.LogError((object)"Separate-Float runtime error: StartFloat while already floating");
		}
		__instance.cState.floating = true;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(ListenForJump), "CheckInput")]
	private static bool FloatReplaceJumpButton(ListenForJump __instance)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Expected O, but got Unknown
		HeroController instance = HeroController.instance;
		if ((Object)(object)instance == (Object)null || (!instance.cState.floating && Floatingbuffer <= 0f))
		{
			return true;
		}
		GameManager val = (GameManager)gmJumpToFloatField.GetValue(__instance);
		if (val.isPaused || (!((NamedVariable)__instance.activeBool).IsNone && !__instance.activeBool.Value))
		{
			return false;
		}
		InputHandler val2 = (InputHandler)inputJumpToFloatField.GetValue(__instance);
		if (((OneAxisInputControl)val2.inputActions.OpenInventoryQuests).WasPressed)
		{
			((FsmStateAction)__instance).Fsm.Event(__instance.wasPressed);
			if (!((NamedVariable)__instance.queueBool).IsNone)
			{
				__instance.queueBool.Value = true;
			}
		}
		if (((OneAxisInputControl)val2.inputActions.OpenInventoryQuests).WasReleased)
		{
			((FsmStateAction)__instance).Fsm.Event(__instance.wasReleased);
			CancelFloat(instance);
		}
		if (((OneAxisInputControl)val2.inputActions.OpenInventoryQuests).IsPressed)
		{
			((FsmStateAction)__instance).Fsm.Event(__instance.isPressed);
		}
		if (!((OneAxisInputControl)val2.inputActions.OpenInventoryQuests).IsPressed)
		{
			((FsmStateAction)__instance).Fsm.Event(__instance.isNotPressed);
			if (!((NamedVariable)__instance.queueBool).IsNone)
			{
				__instance.queueBool.Value = false;
			}
			CancelFloat(instance);
		}
		return false;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "JumpReleased")]
	private static bool JumpReleasedDisable(HeroController __instance)
	{
		if (__instance.cState.floating)
		{
			return false;
		}
		return true;
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(InventoryPaneInput), "GetInventoryInputPressed")]
	private static bool TurnOffQuestsButton(HeroActions ia, ref PaneTypes __result)
	{
		if (((OneAxisInputControl)ia.OpenInventoryQuests).WasPressed || OneAxisInputControl.op_Implicit((OneAxisInputControl)(object)ia.SwipeInventoryQuests))
		{
			__result = (PaneTypes)(-1);
			return false;
		}
		return true;
	}

	[IteratorStateMachine(typeof(<TranspilerLookForInput>d__22))]
	[HarmonyTranspiler]
	[HarmonyPatch(typeof(HeroController), "LookForInput")]
	private static IEnumerable<CodeInstruction> TranspilerLookForInput(IEnumerable<CodeInstruction> instructions)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TranspilerLookForInput>d__22(-2)
		{
			<>3__instructions = instructions
		};
	}

	[IteratorStateMachine(typeof(<TranspilerLookForQueueInput>d__23))]
	[HarmonyTranspiler]
	[HarmonyPatch(typeof(HeroController), "LookForQueueInput")]
	private static IEnumerable<CodeInstruction> TranspilerLookForQueueInput(IEnumerable<CodeInstruction> instructions)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TranspilerLookForQueueInput>d__23(-2)
		{
			<>3__instructions = instructions
		};
	}

	[IteratorStateMachine(typeof(<TranspilerFixedUpdate>d__24))]
	[HarmonyTranspiler]
	[HarmonyPatch(typeof(HeroController), "FixedUpdate")]
	private static IEnumerable<CodeInstruction> TranspilerFixedUpdate(IEnumerable<CodeInstruction> instructions)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TranspilerFixedUpdate>d__24(-2)
		{
			<>3__instructions = instructions
		};
	}

	[IteratorStateMachine(typeof(<TranspilerRegainControl>d__25))]
	[HarmonyTranspiler]
	[HarmonyPatch(typeof(HeroController), "RegainControl", new Type[] { typeof(bool) })]
	private static IEnumerable<CodeInstruction> TranspilerRegainControl(IEnumerable<CodeInstruction> instructions)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TranspilerRegainControl>d__25(-2)
		{
			<>3__instructions = instructions
		};
	}

	[IteratorStateMachine(typeof(<TranspilerDoDoubleJump>d__26))]
	[HarmonyTranspiler]
	[HarmonyPatch(typeof(HeroController), "DoDoubleJump")]
	private static IEnumerable<CodeInstruction> TranspilerDoDoubleJump(IEnumerable<CodeInstruction> instructions)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TranspilerDoDoubleJump>d__26(-2)
		{
			<>3__instructions = instructions
		};
	}

	[IteratorStateMachine(typeof(<TranspilerDoubleJump>d__27))]
	[HarmonyTranspiler]
	[HarmonyPatch(typeof(HeroController), "DoubleJump")]
	private static IEnumerable<CodeInstruction> TranspilerDoubleJump(IEnumerable<CodeInstruction> instructions)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TranspilerDoubleJump>d__27(-2)
		{
			<>3__instructions = instructions
		};
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(ListenForAttack), "OnUpdate")]
	private static void NeedleStrikeFloatCancel(ListenForAttack __instance)
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Expected O, but got Unknown
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Expected O, but got Unknown
		FieldInfo fieldInfo = AccessTools.Field(typeof(ListenForAttack), "gm");
		GameManager val = (GameManager)fieldInfo.GetValue(__instance);
		if (val.isPaused)
		{
			return;
		}
		FieldInfo fieldInfo2 = AccessTools.Field(typeof(ListenForAttack), "timer");
		float num = (float)fieldInfo2.GetValue(__instance);
		if (num > 0f)
		{
			return;
		}
		FieldInfo fieldInfo3 = AccessTools.Field(typeof(ListenForAttack), "inputHandler");
		InputHandler val2 = (InputHandler)fieldInfo3.GetValue(__instance);
		if (((OneAxisInputControl)val2.inputActions.Attack).WasReleased)
		{
			HeroController instance = HeroController.instance;
			float num2 = (float)ChargeTimePropery.GetValue(instance);
			float num3 = (float)needleStrikeTimerField.GetValue(instance);
			if (num3 >= num2)
			{
				CancelFloat(instance);
			}
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "HeroDash")]
	private static void DashFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "DoWallJump")]
	private static void WallJumpFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "HeroJump", new Type[] { typeof(bool) })]
	private static void JumpFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "DoDoubleJump")]
	private static void DoDoubleJumpFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "DoubleJump")]
	private static void DoubleJumpFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "DoAttack")]
	private static void AttackFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "BeginWallSlide")]
	private static void WallSlideFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "IncrementAttackCounter")]
	private static void IncrementAttackCounterFloatCancel(HeroController __instance)
	{
		if (__instance.playerData.silk >= 1)
		{
			CancelFloat(__instance);
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "ResetMotion")]
	private static void ResetMotionFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "BindCompleted")]
	private static void BindFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "ResetUpdraft")]
	private static void ResetUpdraftFloatCancel(HeroController __instance)
	{
		CancelFloat(__instance);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "ExitUpdraft")]
	private static void ExitUpdraftFloatCancel(HeroController __instance)
	{
		FieldInfo fieldInfo = AccessTools.Field(typeof(HeroController), "updraftsEntered");
		int num = (int)fieldInfo.GetValue(__instance);
		if (num <= 1)
		{
			CancelFloat(__instance);
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroController), "ThrowTool")]
	private static void ThrowToolFloatCancel(HeroController __instance, bool isAutoThrow)
	{
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Expected O, but got Unknown
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Expected O, but got Unknown
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		FieldInfo fieldInfo = AccessTools.Field(typeof(HeroController), "canThrowTime");
		FieldInfo fieldInfo2 = AccessTools.Field(typeof(HeroController), "willThrowTool");
		MethodInfo methodInfo = AccessTools.Method(typeof(HeroController), "CanThrowTool", new Type[3]
		{
			typeof(ToolItem),
			typeof(AttackToolBinding),
			typeof(bool)
		}, (Type[])null);
		double num = (double)fieldInfo.GetValue(__instance);
		ToolItem val = (ToolItem)fieldInfo2.GetValue(__instance);
		InputHandler val2 = (InputHandler)inputHandlerField.GetValue(__instance);
		if ((!isAutoThrow && Time.timeAsDouble < num) || !Object.op_Implicit((Object)(object)val))
		{
			return;
		}
		AttackToolBinding? attackToolBinding = ToolItemManager.GetAttackToolBinding(val);
		if (attackToolBinding.HasValue)
		{
			((OneAxisInputControl)val2.inputActions.QuickCast).ClearInputState();
			AttackToolBinding value = attackToolBinding.Value;
			if ((bool)methodInfo.Invoke(__instance, new object[3] { val, value, true }))
			{
				CancelFloat(__instance);
			}
		}
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroWaterController), "EnterWaterRegion")]
	private static void EnterWaterFloatCancel(HeroWaterController __instance)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		HeroController hc = (HeroController)waterHcField.GetValue(__instance);
		CancelFloat(hc);
	}

	[HarmonyPrefix]
	[HarmonyPatch(typeof(HeroWaterController), "ExitWaterRegion", new Type[] { typeof(bool) })]
	private static void ExitWaterFloatCancel(HeroWaterController __instance)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Expected O, but got Unknown
		HeroController hc = (HeroController)waterHcField.GetValue(__instance);
		CancelFloat(hc);
	}
}