using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AK.Wwise;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Pigeon;
using Pigeon.Math;
using Pigeon.Movement;
using Unity.Collections;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Playables;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("KatanaTests")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Katana")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Adds a Katana melee primary weapon.")]
[assembly: AssemblyFileVersion("2.1.1.0")]
[assembly: AssemblyInformationalVersion("2.1.1")]
[assembly: AssemblyProduct("Katana")]
[assembly: AssemblyTitle("Katana")]
[assembly: AssemblyVersion("2.1.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace KatanaMod
{
	internal struct KatanaMotionInput
	{
		public float planarSpeed;

		public float yVelocity;

		public bool grounded;

		public bool sprinting;

		public bool sliding;

		public bool crouching;
	}
	internal sealed class KatanaAnimator
	{
		private struct CutKey
		{
			public float t;

			public float th;

			public float roll;

			public Vector3 g;

			public bool stop;

			public float vel;
		}

		private sealed class Cut
		{
			public Vector3 u;

			public Vector3 v;

			public CutKey[] keys;

			public float coilEnd;

			public float holdEnd;

			public float handLead;
		}

		private struct Key
		{
			public float t;

			public Vector3 pos;

			public Vector3 euler;

			public bool idle;

			public bool stop;
		}

		private struct Pose
		{
			public Vector3 pos;

			public Quaternion rot;
		}

		private struct PoseKey
		{
			public float t;

			public Vector3 g;

			public Vector3 blade;

			public Vector3 edge;

			public float roll;

			public bool stop;

			public bool idle;
		}

		private struct DKey
		{
			public float t;

			public Vector3 off;

			public float ang;

			public bool stop;
		}

		private sealed class InspectClip
		{
			public MKey[] keys;

			public SKey[] spin;

			public HKey[] right;

			public HKey[] left;

			public float dur;

			public DKey[] detach;

			public Vector3 axis;

			public float pivot;

			public bool tailDraw;

			public WKey[] saya;

			public MKey sayaPose;
		}

		private struct WKey
		{
			public float t;

			public float w;
		}

		private struct MKey
		{
			public float t;

			public Vector3 g;

			public Quaternion q;

			public bool idle;

			public bool stop;
		}

		private struct SKey
		{
			public float t;

			public float v;

			public bool stop;
		}

		private struct HKey
		{
			public float t;

			public float w;

			public float loose;

			public float z;

			public float roll;

			public bool free;

			public bool vis;

			public Vector3 p;

			public Quaternion q;
		}

		public struct HandCues
		{
			public float rightW;

			public float leftW;

			public float rightLoose;

			public float leftLoose;

			public Vector3 rightPos;

			public Vector3 leftPos;

			public Quaternion rightRot;

			public Quaternion leftRot;
		}

		public const int MoveCount = 4;

		private const float GameSweepStart = 0.14f;

		private const float GameHit = 0.266f;

		private const float AuthSweepStart = 0.12f;

		private const float AuthHit = 0.253f;

		private const float EquipDuration = 0.55f;

		private const float InspectDuration = 1.8f;

		private const float EndSwingFade = 0.16f;

		private const float CancelInspectFade = 0.22f;

		private const float StartInspectFade = 0.2f;

		private const float MaxDt = 0.1f;

		private const float TwoPi = MathF.PI * 2f;

		private const float MomentumTime = 0.045f;

		private static readonly Vector3 DefaultGrip = new Vector3(0.08f, -0.08f, 0.18f);

		private static readonly Vector3 DefaultRest = new Vector3(-40f, 8f, 0f);

		private static readonly Vector3 BoxMin = new Vector3(-0.25f, -0.32f, 0.04f);

		private static readonly Vector3 BoxMax = new Vector3(0.32f, 0.16f, 0.32f);

		private static readonly Vector3 RightShoulder = new Vector3(0.08f, -0.061f, 0.001f);

		private const float ArmReach = 0.235f;

		private const float ReachKnee = 0.20210001f;

		private const float ReachLimit = 0.21149999f;

		private static readonly Vector3 LeftShoulder = new Vector3(-0.08f, -0.061f, 0.001f);

		private const float LeftKnee = 0.21620001f;

		private const float LeftLimit = 0.22795f;

		private static readonly Cut[] Cuts = new Cut[4]
		{
			MakeCut(new Vector3(-0.11f, 0.198f, 0.974f), new Vector3(-0.82f, -0.57f, 0f), 0.135f, 0.58f, 0.25f, C(0f, -88f, 0.075f, -0.06f, 0.15f), C(0.14f, -116f, 0.066f, -0.034f, 0.135f, stop: true), C(0.2f, -80f, 0.06f, -0.05f, 0.158f), C(0.253f, 0f, 0.05f, -0.088f, 0.19f, stop: false, 0f, 1500f), C(0.3f, 46f, 0.022f, -0.104f, 0.176f), C(0.335f, 64f, 0.002f, -0.11f, 0.166f, stop: true, -6f), C(0.4f, 52f, 0.006f, -0.104f, 0.168f, stop: true, -2f), C(0.46f, 57f, 0.003f, -0.107f, 0.167f, stop: true, -4f), C(0.58f, 55f, 0.004f, -0.106f, 0.167f, stop: true, -4f)),
			MakeCut(new Vector3(-0.1f, 0.14f, 0.985f), new Vector3(1f, 0.22f, 0f), 0.13f, 0.58f, 0.2f, C(0f, -78f, 0.01f, -0.092f, 0.14f), C(0.135f, -108f, -0.04f, -0.1f, 0.112f, stop: true, 4f), C(0.2f, -72f, -0.014f, -0.098f, 0.15f, stop: false, 2f), C(0.253f, 0f, 0.05f, -0.09f, 0.188f, stop: false, 0f, 1400f), C(0.3f, 52f, 0.09f, -0.086f, 0.176f), C(0.335f, 68f, 0.112f, -0.083f, 0.16f, stop: true, -4f), C(0.4f, 57f, 0.104f, -0.085f, 0.165f, stop: true, -1f), C(0.46f, 62f, 0.108f, -0.084f, 0.163f, stop: true, -3f), C(0.58f, 60f, 0.107f, -0.085f, 0.164f, stop: true, -3f)),
			MakeCut(new Vector3(-0.088f, 0.181f, 0.98f), new Vector3(0f, -1f, 0f), 0.165f, 0.7f, 0.3f, C(0f, -70f, 0.05f, -0.06f, 0.16f), C(0.165f, -122f, 0.034f, 0.03f, 0.105f, stop: true), C(0.195f, -126f, 0.034f, 0.034f, 0.105f, stop: true), C(0.225f, -84f, 0.038f, -0.016f, 0.146f), C(0.253f, 0f, 0.042f, -0.082f, 0.188f, stop: false, 0f, 1700f), C(0.29f, 40f, 0.042f, -0.104f, 0.182f), C(0.32f, 52f, 0.042f, -0.11f, 0.176f, stop: true), C(0.39f, 36f, 0.042f, -0.102f, 0.18f, stop: true), C(0.46f, 42f, 0.042f, -0.105f, 0.179f, stop: true), C(0.7f, 40f, 0.042f, -0.104f, 0.179f, stop: true)),
			MakeCut(new Vector3(-0.08f, 0.11f, 0.99f), new Vector3(1f, 0.3f, 0f), 0.125f, 0.62f, 0.25f, C(0f, -55f, 0.04f, -0.1f, 0.15f), C(0.125f, -136f, -0.03f, -0.12f, 0.085f, stop: true, 8f), C(0.19f, -82f, -0.012f, -0.108f, 0.136f, stop: false, 4f), C(0.24f, 0f, 0.05f, -0.088f, 0.186f, stop: false, 0f, 1500f), C(0.29f, 58f, 0.092f, -0.076f, 0.168f), C(0.33f, 74f, 0.112f, -0.07f, 0.152f, stop: true, -6f), C(0.4f, 63f, 0.106f, -0.073f, 0.158f, stop: true, -2f), C(0.47f, 68f, 0.109f, -0.072f, 0.156f, stop: true, -4f), C(0.62f, 66f, 0.108f, -0.072f, 0.157f, stop: true, -4f))
		};

		private static readonly Key[] EquipKeys = new Key[5]
		{
			K(0f, -0.03f, -0.2f, 0.08f, 40f, -160f, -40f),
			K(0.3f, -0.01f, -0.13f, 0.15f, 0f, -75f, -75f),
			K(0.6f, 0.09f, -0.05f, 0.15f, -64f, 18f, 35f),
			K(0.8f, 0.08f, -0.07f, 0.17f, -34f, 6f, -12f),
			Idle(1f)
		};

		private static readonly Vector3 SprintPos = new Vector3(0.1f, -0.14f, 0.11f);

		private static readonly Vector3 SprintEuler = new Vector3(32f, 108f, -18f);

		private static readonly Vector3 SlidePos = new Vector3(0.06f, -0.13f, 0.17f);

		private static readonly Vector3 SlideEuler = new Vector3(-10f, -4f, -8f);

		private static readonly Vector3 CrouchOffset = new Vector3(-0.008f, -0.02f, 0f);

		private static readonly Vector3 AirRaise = new Vector3(0f, 0.012f, -0.004f);

		private bool swinging;

		private int swingMove;

		private float swingP;

		private float swingClock;

		private Pose swingFrom;

		private Vector3 fromVel;

		private Vector3 fromAngVel;

		private bool equipping;

		private float equipT;

		private bool inspecting;

		private float inspectT;

		private bool fading;

		private float fadeT;

		private float fadeDur;

		private Pose fadeFrom;

		private Vector3 fadeVel;

		private Vector3 fadeAngVel;

		private Vector3 coilRel;

		private Vector3 returnRel;

		private Vector3 fadeRel;

		private bool coilRelValid;

		private bool returnRelValid;

		private bool fadeRelValid;

		private Pose lastPose;

		private Pose prevPose;

		private float evalDt;

		private float pendingDt;

		private bool havePrev;

		private float sprintW;

		private float sprintWV;

		private float slideW;

		private float slideWV;

		private float crouchW;

		private float crouchWV;

		private float airW;

		private float airWV;

		private float busyW;

		private float busyWV;

		private float bobAmp;

		private float bobAmpV;

		private float bobPhase;

		private float lagY;

		private float lagYV;

		private float lagPitch;

		private float lagPitchV;

		private float landY;

		private float landYV;

		private float breathPhase;

		private float breathPhase2;

		private float kensenPhase;

		private bool hasPrevGrounded;

		private bool prevGrounded;

		private float lastAirYVel;

		private Vector3 swayPos;

		private Vector3 swayPosV;

		private Vector3 swayEuler;

		private Vector3 swayEulerV;

		private const float KashiraModel = 0.182f;

		public const int MotionCount = 8;

		private const float DetachFadeTime = 0.16f;

		private const float PlungeEnterDuration = 0.34f;

		private const float PlungeImpactDuration = 0.62f;

		private const float PlungeHitAt = 0.1f;

		private const float TailDrawDuration = 0.42f;

		private const float SayaFadeTime = 0.2f;

		private float sayaW;

		private float sayaFadeFrom;

		private float sayaFadeT = 0.2f;

		private Vector3 sayaPos;

		private Quaternion sayaRot = Quaternion.identity;

		private const float ArmBlendTime = 0.2f;

		private float armBlend;

		private const float RightGripModel = 0.008f;

		private const float LeftGripModel = -0.172f;

		private const float CueFadeTime = 0.16f;

		private HandCues cues;

		private bool cuesValid;

		private float cueFadeT = 0.16f;

		private HandCues cueFadeFrom;

		private float motionSpin;

		private Vector3 cueRelR;

		private Vector3 cueRelL;

		private bool cueRelRValid;

		private bool cueRelLValid;

		private int cueSegR = -1;

		private int cueSegL = -1;

		private float clampSkip;

		private float clampFadeT = 0.16f;

		private Vector3 fadeRelR;

		private Vector3 fadeRelL;

		private bool fadeRelRValid;

		private bool fadeRelLValid;

		private static readonly Key[] PlungeEnterKeys = BuildKeys(P(0f, 0.06f, -0.05f, 0.14f, 0.05f, 0.92f, 0.38f, 0f, -0.38f, 0.92f), P(0.38f, 0.05f, -0.012f, 0.118f, 0.02f, 0.97f, 0.24f, 0f, -0.24f, 0.97f, stop: true), P(0.7f, 0.04f, -0.03f, 0.15f, 0f, -0.1f, 0.99f, 0f, -0.99f, -0.1f), P(1f, 0.03f, -0.02f, 0.15f, -0.04f, -0.88f, 0.47f, 0f, -0.47f, -0.88f, stop: true));

		private static readonly Key PlungeHoldKey = PlungeEnterKeys[PlungeEnterKeys.Length - 1];

		private static readonly Key[] PlungeImpactKeys = BuildKeys(P(0f, 0.03f, -0.02f, 0.15f, -0.04f, -0.88f, 0.47f, 0f, -0.47f, -0.88f), P(0.1f, 0.03f, -0.085f, 0.18f, -0.04f, -0.9f, 0.43f, 0f, -0.43f, -0.9f, stop: true), P(0.3f, 0.031f, -0.08f, 0.177f, -0.04f, -0.89f, 0.45f, 0f, -0.45f, -0.89f, stop: true), P(0.55f, 0.06f, -0.085f, 0.17f, 0.05f, 0.1f, 0.99f, 0f, -0.99f, 0.1f), PIdle(1f));

		private static readonly InspectClip DefaultClip = BuildDefaultClip();

		private static readonly InspectClip[] Motions = BuildMotions();

		private float inspectDur = 1.8f;

		private float inspectSpeed = 1f;

		private int inspectStyle = -1;

		private InspectClip inspectClip;

		private bool autoSwing;

		private int plungePhase;

		private float plungeT;

		private float plungeStop;

		private float detachFadeT = 0.16f;

		private Vector3 detachFadeOff;

		private Vector3 detachFadeAxis = Vector3.forward;

		private float detachFadeAng;

		private float detachFadePivot;

		private const float GuardEnterFade = 0.085f;

		private const float GuardExitFade = 0.16f;

		private static readonly Vector3 GuardGrip = new Vector3(-0.03f, -0.055f, 0.15f);

		private static readonly Vector3 GuardBlade = new Vector3(0.92f, 0.2f, 0.34f);

		private static readonly Vector3 GuardEdge = new Vector3(0.02f, 0.38f, 1f);

		private bool guardOn;

		private float guardT;

		private float guardFlick;

		private float guardFlickV;

		private float guardFlickStop;

		public bool IsInspecting => inspecting;

		public bool IsEquipping => equipping;

		public float InspectArmBlend => Smoother(armBlend);

		public int InspectStyle
		{
			get
			{
				if (!inspecting)
				{
					return -1;
				}
				return inspectStyle;
			}
		}

		public float InspectProgress
		{
			get
			{
				if (!inspecting)
				{
					return -1f;
				}
				return inspectT / Mathf.Max(0.001f, inspectDur);
			}
		}

		public float TailDrawProgress
		{
			get
			{
				if (!autoSwing || !swinging)
				{
					return -1f;
				}
				return swingP;
			}
		}

		public bool IsPlunging => plungePhase != 0;

		public bool IsPlungeLanding => plungePhase == 2;

		public bool IsGuarding => guardOn;

		private static CutKey C(float t, float th, float gx, float gy, float gz, bool stop = false, float roll = 0f, float vel = float.NaN)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			return new CutKey
			{
				t = t,
				th = th,
				roll = roll,
				g = new Vector3(gx, gy, gz),
				stop = stop,
				vel = vel
			};
		}

		private static Cut MakeCut(Vector3 u, Vector3 v, float coilEnd, float holdEnd, float handLead, params CutKey[] keys)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			u = ((Vector3)(ref u)).normalized;
			Vector3 val = v - Vector3.Dot(v, u) * u;
			v = ((Vector3)(ref val)).normalized;
			return new Cut
			{
				u = u,
				v = v,
				keys = keys,
				coilEnd = coilEnd,
				holdEnd = holdEnd,
				handLead = handLead
			};
		}

		private static Key K(float t, float px, float py, float pz, float ex, float ey, float ez, bool stop = false)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			return new Key
			{
				t = t,
				pos = new Vector3(px, py, pz),
				euler = new Vector3(ex, ey, ez),
				stop = stop
			};
		}

		private static Key Idle(float t, float rollAdd = 0f)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			return new Key
			{
				t = t,
				pos = Vector3.zero,
				euler = new Vector3(0f, 0f, rollAdd),
				idle = true,
				stop = true
			};
		}

		public KatanaAnimator()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			Reset();
		}

		public void TriggerEquip()
		{
			swinging = false;
			inspecting = false;
			fading = false;
			plungePhase = 0;
			autoSwing = false;
			detachFadeT = 0.16f;
			if (!Cfg(KatanaPlugin.EquipAnimation, fallback: true))
			{
				equipping = false;
				lastPose = (prevPose = IdlePose());
			}
			else
			{
				equipping = true;
				equipT = 0f;
			}
		}

		public void TriggerInspect()
		{
			TriggerInspect(-1, 1f);
		}

		public void TriggerInspect(int style, float speed)
		{
			if (Cfg(KatanaPlugin.InspectAnimation, fallback: true) && !swinging && !equipping && plungePhase == 0 && (!inspecting || !(inspectT < inspectDur * 0.85f)))
			{
				CaptureDetachFade();
				StartFade(0.2f);
				SelectInspectClip(style, speed);
				inspecting = true;
				inspectT = 0f;
			}
		}

		public void CancelInspect()
		{
			if (inspecting)
			{
				CaptureDetachFade();
				StartFade(0.22f);
				inspecting = false;
			}
		}

		public void BeginSwing(int move)
		{
			if (move < 0 || move >= 4)
			{
				move = (move % 4 + 4) % 4;
			}
			if (inspecting)
			{
				CaptureDetachFade();
			}
			plungePhase = 0;
			autoSwing = false;
			swingFrom = lastPose;
			PoseVelocity(out fromVel, out fromAngVel);
			swingMove = move;
			swingP = 0f;
			swingClock = 0f;
			coilRelValid = (returnRelValid = false);
			swinging = true;
			inspecting = false;
			equipping = false;
			fading = false;
		}

		public void SetSwingProgress(float p)
		{
			if (!float.IsNaN(p))
			{
				swingP = Mathf.Clamp01(p);
			}
		}

		public void EndSwing()
		{
			if (swinging)
			{
				StartFade(0.16f);
				swinging = false;
			}
		}

		public void Reset()
		{
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			swinging = false;
			swingMove = 0;
			swingP = 0f;
			swingClock = 0f;
			equipping = false;
			equipT = 0f;
			inspecting = false;
			inspectT = 0f;
			plungePhase = 0;
			plungeT = (plungeStop = 0f);
			autoSwing = false;
			detachFadeT = 0.16f;
			armBlend = 0f;
			sayaW = 0f;
			sayaFadeT = 0.2f;
			SelectInspectClip(-1, 1f);
			fading = false;
			fadeT = 0f;
			fadeDur = 0f;
			sprintW = (sprintWV = (slideW = (slideWV = (crouchW = (crouchWV = (airW = (airWV = 0f)))))));
			busyW = (busyWV = (bobAmp = (bobAmpV = (bobPhase = 0f))));
			lagY = (lagYV = (lagPitch = (lagPitchV = (landY = (landYV = 0f)))));
			breathPhase = (breathPhase2 = (kensenPhase = 0f));
			hasPrevGrounded = false;
			prevGrounded = true;
			lastAirYVel = 0f;
			swayPos = (swayPosV = (swayEuler = (swayEulerV = Vector3.zero)));
			lastPose = IdlePose();
			prevPose = lastPose;
			havePrev = false;
			evalDt = (pendingDt = 0f);
			fromVel = (fromAngVel = (fadeVel = (fadeAngVel = Vector3.zero)));
			swingFrom = lastPose;
			fadeFrom = lastPose;
		}

		private void StartFade(float duration)
		{
			fadeFrom = lastPose;
			PoseVelocity(out fadeVel, out fadeAngVel);
			fadeT = 0f;
			fadeRelValid = false;
			fadeDur = Mathf.Max(0.01f, duration);
			fading = true;
		}

		private void PoseVelocity(out Vector3 vel, out Vector3 angVel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			vel = Vector3.zero;
			angVel = Vector3.zero;
			if (havePrev && evalDt > 0.0001f)
			{
				vel = Vector3.ClampMagnitude((lastPose.pos - prevPose.pos) / evalDt, 2.5f);
				angVel = Vector3.ClampMagnitude(QToRotVec(QMul(lastPose.rot, QInv(prevPose.rot))) / evalDt, 25f);
				if (!Finite(vel))
				{
					vel = Vector3.zero;
				}
				if (!Finite(angVel))
				{
					angVel = Vector3.zero;
				}
			}
		}

		private static Pose Drift(Pose p, Vector3 vel, Vector3 angVel, float t)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (vel == Vector3.zero && angVel == Vector3.zero)
			{
				return p;
			}
			float num = 0.045f * (1f - Mathf.Exp((0f - Mathf.Max(0f, t)) / 0.045f));
			ref Vector3 pos = ref p.pos;
			pos += Vector3.ClampMagnitude(vel * num, 0.04f);
			p.rot = QMul(QFromRotVec(Vector3.ClampMagnitude(angVel * num, 0.43633232f)), p.rot);
			return p;
		}

		public void Update(float dt, KatanaMotionInput input)
		{
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0534: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			//IL_07eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0809: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_074b: Unknown result type (might be due to invalid IL or missing references)
			//IL_075b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0760: Unknown result type (might be due to invalid IL or missing references)
			//IL_0765: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07dd: Unknown result type (might be due to invalid IL or missing references)
			if (!(dt > 0f))
			{
				dt = 0f;
			}
			if (dt > 0.1f)
			{
				dt = 0.1f;
			}
			pendingDt += dt;
			if (swinging)
			{
				swingClock += dt;
			}
			if (equipping)
			{
				equipT += dt;
				if (equipT >= 0.55f)
				{
					equipping = false;
					StartFade(0.1f);
				}
			}
			if (inspecting)
			{
				inspectT += dt * inspectSpeed;
				if (inspectT >= inspectDur)
				{
					inspecting = false;
					EndInspectClip();
				}
			}
			armBlend = Mathf.MoveTowards(armBlend, inspecting ? 1f : 0f, dt / 0.2f);
			TickAdditions(dt);
			TickGuard(dt);
			if (fading)
			{
				fadeT += dt;
				if (fadeT >= fadeDur)
				{
					fading = false;
				}
			}
			float num = Cfg(KatanaPlugin.MovementSway, 1f);
			if (float.IsNaN(num))
			{
				num = 1f;
			}
			num = Mathf.Clamp(num, 0f, 3f);
			float num2 = Mathf.Clamp01(num);
			float num3 = (float.IsNaN(input.planarSpeed) ? 0f : Mathf.Max(0f, input.planarSpeed));
			float num4 = (float.IsNaN(input.yVelocity) ? 0f : Mathf.Clamp(input.yVelocity, -60f, 60f));
			bool flag = swinging || inspecting || equipping || plungePhase != 0 || guardOn;
			float target = ((input.sprinting && !flag && !input.sliding) ? num2 : 0f);
			float target2 = ((input.sliding && !flag) ? num2 : 0f);
			float target3 = ((input.crouching && !input.sliding) ? num2 : 0f);
			float target4 = (input.grounded ? 0f : 1f);
			Spring(ref sprintW, ref sprintWV, target, 14f, dt);
			Spring(ref slideW, ref slideWV, target2, 18f, dt);
			Spring(ref crouchW, ref crouchWV, target3, 12f, dt);
			Spring(ref airW, ref airWV, target4, 10f, dt);
			Spring(ref busyW, ref busyWV, flag ? 1f : 0f, 20f, dt);
			float num5 = ((input.grounded && !input.sliding) ? Mathf.Clamp01(num3 / 7f) : 0f);
			Spring(ref bobAmp, ref bobAmpV, num5, 7f, dt);
			if (bobAmp > 0.001f || num5 > 0f)
			{
				float num6 = Mathf.Clamp(0.8f + num3 * 0.065f, 0.8f, 1.6f);
				bobPhase += MathF.PI * 2f * num6 * dt;
				if (bobPhase > MathF.PI * 2f)
				{
					bobPhase -= MathF.PI * 2f;
				}
			}
			float target5 = (input.grounded ? 0f : Mathf.Clamp((0f - num4) * 0.0025f, -0.025f, 0.025f));
			float target6 = (input.grounded ? 0f : Mathf.Clamp(num4 * 0.55f, -7f, 7f));
			Spring(ref lagY, ref lagYV, target5, 9f, dt);
			Spring(ref lagPitch, ref lagPitchV, target6, 9f, dt);
			if (hasPrevGrounded && !prevGrounded && input.grounded)
			{
				float num7 = Mathf.Clamp(0f - lastAirYVel, 0f, 20f);
				float num8 = Mathf.Min(0.25f + num7 * 0.06f, 1.4f);
				landYV -= num8;
			}
			if (!input.grounded)
			{
				lastAirYVel = num4;
			}
			prevGrounded = input.grounded;
			hasPrevGrounded = true;
			StepUnderdamped(ref landY, ref landYV, 12f, 0.42f, dt);
			landY = Mathf.Clamp(landY, -0.05f, 0.03f);
			breathPhase += dt * 1.45f;
			if (breathPhase > MathF.PI * 2f)
			{
				breathPhase -= MathF.PI * 2f;
			}
			breathPhase2 += dt * 0.55f;
			if (breathPhase2 > MathF.PI * 2f)
			{
				breathPhase2 -= MathF.PI * 2f;
			}
			kensenPhase += dt * 0.9f;
			if (kensenPhase > MathF.PI * 2f)
			{
				kensenPhase -= MathF.PI * 2f;
			}
			Vector3 val = Vector3.zero;
			Vector3 val2 = Vector3.zero;
			float num9 = num * (1f - 0.7f * Mathf.Clamp01(busyW));
			if (num9 > 0.0001f)
			{
				float num10 = Mathf.Clamp01(sprintW);
				float num11 = bobAmp;
				float num12 = Mathf.Sin(bobPhase);
				float num13 = Mathf.Sin(2f * bobPhase);
				float num14 = 0.008f * (1f + 0.8f * num10);
				float num15 = 0.007f * (1f + 1f * num10);
				val.x += num12 * num14 * num11;
				val.y += (num13 - 0.35f) * num15 * num11;
				val2.z += num12 * 2f * (1f + 1.5f * num10) * num11;
				val2.y += num12 * 1.3f * num11;
				val2.x += (num13 + 0.3f) * 1.2f * (1f + num10) * num11;
				float num16 = 1f - 0.75f * Mathf.Clamp01(bobAmp);
				float num17 = Mathf.Sin(breathPhase);
				val.y += num17 * 0.0028f * num16;
				val.z += num17 * 0.001f * num16;
				val.x += Mathf.Sin(breathPhase2) * 0.0014f * num16;
				val2.x += (0f - Mathf.Sin(breathPhase + 0.7f)) * 0.45f * num16;
				val2.z += Mathf.Sin(breathPhase2 + 1.3f) * 0.6f * num16;
				val2.x += Mathf.Sin(kensenPhase) * 0.25f * num16;
				val2.y += Mathf.Cos(kensenPhase) * 0.35f * num16;
				val += AirRaise * Mathf.Clamp01(airW);
				val.y += lagY;
				val2.x += lagPitch;
				val.y += landY;
				val.z += landY * 0.2f;
				val2.x += (0f - landY) * 110f;
				val *= num9;
				val2 *= num9;
			}
			StepSpring(ref swayPos, ref swayPosV, val, 17f, 0.55f, dt);
			StepSpring(ref swayEuler, ref swayEulerV, val2, 15f, 0.5f, dt);
		}

		public void Evaluate(out Vector3 gripPosition, out Quaternion rotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			Vector3 grip = GetGrip();
			Vector3 rest = GetRest();
			Vector3 val = grip - DefaultGrip;
			Pose pose = default(Pose);
			pose.pos = grip;
			pose.rot = QEuler(rest);
			if (sprintW > 0.0001f)
			{
				Pose b = default(Pose);
				b.pos = SprintPos + val;
				b.rot = QEuler(SprintEuler);
				pose = Blend(pose, b, Mathf.Clamp01(sprintW));
			}
			if (slideW > 0.0001f)
			{
				Pose b2 = default(Pose);
				b2.pos = SlidePos + val;
				b2.rot = QEuler(SlideEuler);
				pose = Blend(pose, b2, Mathf.Clamp01(slideW));
			}
			ref Vector3 pos = ref pose.pos;
			pos += CrouchOffset * crouchW;
			Pose pose2 = pose;
			motionSpin = 0f;
			if (swinging)
			{
				pose2 = SwingPose(pose, val);
			}
			else if (guardOn)
			{
				pose2 = GuardPose(val);
			}
			else if (equipping)
			{
				SampleKeys(EquipKeys, equipT / 0.55f, grip, rest, val, out var pos2, out var euler);
				pose2.pos = pos2;
				pose2.rot = QEuler(euler);
			}
			else if (inspecting)
			{
				MotionPose(grip, rest, val, out pose2.pos, out pose2.rot);
			}
			else if (plungePhase != 0)
			{
				PlungePose(grip, rest, val, out var p, out var e);
				pose2.pos = p;
				pose2.rot = QEuler(e);
			}
			if (fading)
			{
				Pose a = Drift(fadeFrom, fadeVel, fadeAngVel, fadeT);
				float num = Smoother(fadeT / fadeDur);
				pose2 = Blend2(a, pose2, num, num, ref fadeRel, ref fadeRelValid);
			}
			if (!Valid(pose2))
			{
				pose2 = IdlePose();
			}
			prevPose = lastPose;
			lastPose = pose2;
			havePrev = true;
			evalDt = pendingDt;
			pendingDt = 0f;
			Vector3 val2 = pose2.pos + swayPos;
			Quaternion val3 = QMul(QEuler(swayEuler), pose2.rot);
			Vector3 val4 = Vector3.Min(BoxMin, grip);
			Vector3 val5 = Vector3.Max(BoxMax, grip);
			val2.x = Mathf.Clamp(val2.x, val4.x, val5.x);
			val2.y = Mathf.Clamp(val2.y, val4.y, val5.y);
			val2.z = Mathf.Clamp(val2.z, val4.z, val5.z);
			if (!Finite(val2))
			{
				val2 = grip;
			}
			if (float.IsNaN(val3.x) || float.IsNaN(val3.y) || float.IsNaN(val3.z) || float.IsNaN(val3.w))
			{
				val3 = QEuler(rest);
			}
			val3 = QNorm(val3);
			float num2 = LeftClampSkip();
			val2 = ((num2 > 0f) ? Vector3.LerpUnclamped(SoftReachLeft(val2, val3), val2, num2) : SoftReachLeft(val2, val3));
			val2 = SoftReach(val2);
			ComputeHandCues(val2, val3);
			ComputeSaya();
			gripPosition = val2;
			rotation = val3;
		}

		private Pose SwingPose(Pose basePose, Vector3 delta)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Cut cut = Cuts[swingMove];
			float num = Warp(swingP);
			Pose pose = CutPose(cut, num, delta);
			if (num < cut.coilEnd)
			{
				float num2 = num / cut.coilEnd;
				pose = Blend2(Drift(swingFrom, fromVel, fromAngVel, swingClock), pose, Smoother(num2 / (1f - cut.handLead)), Smoother(num2), ref coilRel, ref coilRelValid);
			}
			else if (num > cut.holdEnd)
			{
				float num3 = (num - cut.holdEnd) / Mathf.Max(0.0001f, 1f - cut.holdEnd);
				pose = Blend2(pose, basePose, Smoother(num3 / (1f - 0.5f * cut.handLead)), Smoother(num3), ref returnRel, ref returnRelValid);
			}
			return pose;
		}

		private static float Warp(float p)
		{
			p = Mathf.Clamp01(p);
			if (Mathf.Abs(0.020000003f) < 1E-05f && Mathf.Abs(0.013000011f) < 1E-05f)
			{
				return p;
			}
			float num = 0.8571428f;
			float num2 = 1.0555555f;
			float num3 = 1.0177112f;
			float num4 = ((num * num2 > 0f) ? (2f / (1f / num + 1f / num2)) : 0f);
			float num5 = ((num2 * num3 > 0f) ? (2f / (1f / num2 + 1f / num3)) : 0f);
			if (p < 0.14f)
			{
				return Herm(p, 0f, 0.14f, 0f, 0.12f, num, num4);
			}
			if (p < 0.266f)
			{
				return Herm(p, 0.14f, 0.266f, 0.12f, 0.253f, num4, num5);
			}
			return Herm(p, 0.266f, 1f, 0.253f, 1f, num5, num3);
		}

		private static float Herm(float x, float xa, float xb, float ya, float yb, float ma, float mb)
		{
			float num = xb - xa;
			if (num <= 1E-06f)
			{
				return yb;
			}
			float num2 = (x - xa) / num;
			float num3 = num2 * num2;
			float num4 = num3 * num2;
			return (2f * num4 - 3f * num3 + 1f) * ya + (num4 - 2f * num3 + num2) * num * ma + (-2f * num4 + 3f * num3) * yb + (num4 - num3) * num * mb;
		}

		private static Pose CutPose(Cut cut, float t, Vector3 delta)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			CutKey[] keys = cut.keys;
			int num = keys.Length;
			float num2;
			float deg;
			Vector3 val;
			if (t <= keys[0].t)
			{
				num2 = keys[0].th;
				deg = keys[0].roll;
				val = keys[0].g;
			}
			else if (t >= keys[num - 1].t)
			{
				num2 = keys[num - 1].th;
				deg = keys[num - 1].roll;
				val = keys[num - 1].g;
			}
			else
			{
				int i;
				for (i = 0; i < num - 2 && t > keys[i + 1].t; i++)
				{
				}
				float num3 = keys[i + 1].t - keys[i].t;
				float num4 = ((num3 > 1E-06f) ? ((t - keys[i].t) / num3) : 1f);
				float num5 = num4 * num4;
				float num6 = num5 * num4;
				float num7 = 2f * num6 - 3f * num5 + 1f;
				float num8 = (num6 - 2f * num5 + num4) * num3;
				float num9 = -2f * num6 + 3f * num5;
				float num10 = (num6 - num5) * num3;
				CutTangent(keys, i, out var mt, out var mr, out var mg);
				CutTangent(keys, i + 1, out var mt2, out var mr2, out var mg2);
				num2 = num7 * keys[i].th + num8 * mt + num9 * keys[i + 1].th + num10 * mt2;
				deg = num7 * keys[i].roll + num8 * mr + num9 * keys[i + 1].roll + num10 * mr2;
				val = num7 * keys[i].g + num8 * mg + num9 * keys[i + 1].g + num10 * mg2;
			}
			float num11 = num2 * (MathF.PI / 180f);
			float num12 = Mathf.Cos(num11);
			float num13 = Mathf.Sin(num11);
			Vector3 fwd = num12 * cut.u + num13 * cut.v;
			Vector3 val2 = (0f - num13) * cut.u + num12 * cut.v;
			Pose result = default(Pose);
			result.pos = val + delta;
			result.rot = QMul(QLook(fwd, -val2), QAxis(Vector3.forward, deg));
			return result;
		}

		private static void CutTangent(CutKey[] k, int i, out float mt, out float mr, out Vector3 mg)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			int num = k.Length;
			if (i <= 0 || i >= num - 1 || k[i].stop)
			{
				mt = 0f;
				mr = 0f;
				mg = Vector3.zero;
			}
			else
			{
				float num2 = k[i + 1].t - k[i - 1].t;
				float num3 = ((num2 > 1E-06f) ? (1f / num2) : 0f);
				mt = (float.IsNaN(k[i].vel) ? ((k[i + 1].th - k[i - 1].th) * num3) : k[i].vel);
				mr = (k[i + 1].roll - k[i - 1].roll) * num3;
				mg = (k[i + 1].g - k[i - 1].g) * num3;
			}
		}

		private static void SampleKeys(Key[] keys, float t, Vector3 grip, Vector3 rest, Vector3 delta, out Vector3 pos, out Vector3 euler)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			int num = keys.Length;
			if (num == 0)
			{
				pos = grip;
				euler = rest;
				return;
			}
			if (float.IsNaN(t))
			{
				t = 0f;
			}
			if (num == 1 || t <= keys[0].t)
			{
				Resolve(in keys[0], grip, rest, delta, out pos, out euler);
				return;
			}
			if (t >= keys[num - 1].t)
			{
				Resolve(in keys[num - 1], grip, rest, delta, out pos, out euler);
				return;
			}
			int i;
			for (i = 0; i < num - 2 && t > keys[i + 1].t; i++)
			{
			}
			Resolve(in keys[i], grip, rest, delta, out var pos2, out var euler2);
			Resolve(in keys[i + 1], grip, rest, delta, out var pos3, out var euler3);
			Tangent(keys, i, grip, rest, delta, out var mp, out var me);
			Tangent(keys, i + 1, grip, rest, delta, out var mp2, out var me2);
			float num2 = keys[i + 1].t - keys[i].t;
			if (num2 <= 1E-06f)
			{
				pos = pos3;
				euler = euler3;
				return;
			}
			float num3 = (t - keys[i].t) / num2;
			float num4 = num3 * num3;
			float num5 = num4 * num3;
			float num6 = 2f * num5 - 3f * num4 + 1f;
			float num7 = (num5 - 2f * num4 + num3) * num2;
			float num8 = -2f * num5 + 3f * num4;
			float num9 = (num5 - num4) * num2;
			pos = num6 * pos2 + num7 * mp + num8 * pos3 + num9 * mp2;
			euler = num6 * euler2 + num7 * me + num8 * euler3 + num9 * me2;
		}

		private static void Tangent(Key[] keys, int i, Vector3 grip, Vector3 rest, Vector3 delta, out Vector3 mp, out Vector3 me)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			int num = keys.Length;
			if (i <= 0 || i >= num - 1 || keys[i].stop)
			{
				mp = Vector3.zero;
				me = Vector3.zero;
				return;
			}
			Resolve(in keys[i - 1], grip, rest, delta, out var pos, out var euler);
			Resolve(in keys[i + 1], grip, rest, delta, out var pos2, out var euler2);
			float num2 = keys[i + 1].t - keys[i - 1].t;
			if (num2 <= 1E-06f)
			{
				mp = Vector3.zero;
				me = Vector3.zero;
			}
			else
			{
				float num3 = 1f / num2;
				mp = (pos2 - pos) * num3;
				me = (euler2 - euler) * num3;
			}
		}

		private static void Resolve(in Key k, Vector3 grip, Vector3 rest, Vector3 delta, out Vector3 pos, out Vector3 euler)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (k.idle)
			{
				pos = grip + k.pos;
				euler = rest + k.euler;
			}
			else
			{
				pos = k.pos + delta;
				euler = k.euler;
			}
		}

		private static Pose Blend(Pose a, Pose b, float w)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (w <= 0f)
			{
				return a;
			}
			if (w >= 1f)
			{
				return b;
			}
			Pose result = default(Pose);
			result.pos = Vector3.LerpUnclamped(a.pos, b.pos, w);
			result.rot = QSlerp(a.rot, b.rot, w);
			return result;
		}

		private static Pose Blend2(Pose a, Pose b, float wPos, float wRot, ref Vector3 lastRel, ref bool lastValid)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			Pose result = default(Pose);
			result.pos = Vector3.LerpUnclamped(a.pos, b.pos, Mathf.Clamp01(wPos));
			Vector3 val = QToRotVec(QMul(b.rot, QInv(a.rot)));
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (lastValid && magnitude > 0.0001f)
			{
				Vector3 val2 = val * (1f - MathF.PI * 2f / magnitude);
				Vector3 val3 = val2 - lastRel;
				float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
				val3 = val - lastRel;
				if (sqrMagnitude < ((Vector3)(ref val3)).sqrMagnitude)
				{
					val = val2;
				}
			}
			if (Finite(val))
			{
				lastRel = val;
				lastValid = true;
			}
			else
			{
				val = Vector3.zero;
			}
			float num = Mathf.Clamp01(wRot);
			result.rot = ((num >= 1f) ? b.rot : QNorm(QMul(QFromRotVec(val * num), a.rot)));
			return result;
		}

		private static float Smoother(float t)
		{
			t = Mathf.Clamp01(t);
			return t * t * t * (t * (t * 6f - 15f) + 10f);
		}

		private static void Spring(ref float x, ref float v, float target, float omega, float dt)
		{
			if (!(dt <= 0f))
			{
				float num = v - (x - target) * (omega * omega * dt);
				float num2 = 1f + omega * dt;
				v = num / (num2 * num2);
				x += v * dt;
				if (float.IsNaN(x) || float.IsNaN(v))
				{
					x = target;
					v = 0f;
				}
			}
		}

		private static void StepUnderdamped(ref float x, ref float v, float omega, float zeta, float dt)
		{
			if (!(dt <= 0f))
			{
				int num = Mathf.Clamp(Mathf.CeilToInt(dt / (1f / 120f)), 1, 16);
				float num2 = dt / (float)num;
				for (int i = 0; i < num; i++)
				{
					float num3 = (0f - omega) * omega * x - 2f * zeta * omega * v;
					v += num3 * num2;
					x += v * num2;
				}
				if (float.IsNaN(x) || float.IsNaN(v))
				{
					x = 0f;
					v = 0f;
				}
			}
		}

		private static void StepSpring(ref Vector3 x, ref Vector3 v, Vector3 target, float omega, float zeta, float dt)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (!(dt <= 0f))
			{
				int num = Mathf.Clamp(Mathf.CeilToInt(dt / (1f / 120f)), 1, 16);
				float num2 = dt / (float)num;
				for (int i = 0; i < num; i++)
				{
					Vector3 val = (target - x) * (omega * omega) - v * (2f * zeta * omega);
					v += val * num2;
					x += v * num2;
				}
				if (!Finite(x) || !Finite(v))
				{
					x = target;
					v = Vector3.zero;
				}
			}
		}

		private static Vector3 SoftReach(Vector3 p)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = p - RightShoulder;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (!(magnitude > 0.20210001f))
			{
				return p;
			}
			float num = 0.20210001f + 0.00939998f * (float)Math.Tanh((magnitude - 0.20210001f) / 0.00939998f);
			return RightShoulder + val * (num / magnitude);
		}

		private static Vector3 SoftReachLeft(Vector3 grip, Quaternion rot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = grip - QRotate(rot, new Vector3(0f, 0f, LeftHandDistance())) - LeftShoulder;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (!(magnitude > 0.21620001f))
			{
				return grip;
			}
			float num = 0.21620001f + 0.011749998f * (float)Math.Tanh((magnitude - 0.21620001f) / 0.011749998f);
			Vector3 val2 = grip + val * (num / magnitude - 1f);
			if (!Finite(val2))
			{
				return grip;
			}
			return val2;
		}

		private static float LeftHandDistance()
		{
			float num = ((KatanaPlugin.LeftHandOffset != null) ? KatanaPlugin.LeftHandOffset.Value : 0.12f);
			if (!(num > 0.182f))
			{
				num = 0.182f;
			}
			float num2 = ((KatanaPlugin.ModelScale != null) ? KatanaPlugin.ModelScale.Value : 1f);
			float num3 = ((KatanaPlugin.FirstPersonScale != null) ? KatanaPlugin.FirstPersonScale.Value : 0.55f);
			float num4 = num * num2 * Mathf.Clamp(num3, 0.05f, 5f);
			if (float.IsNaN(num4) || float.IsInfinity(num4))
			{
				num4 = 0.1001f;
			}
			return Mathf.Clamp(num4, 0f, 0.25f);
		}

		private static Pose IdlePose()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Pose result = default(Pose);
			result.pos = GetGrip();
			result.rot = QEuler(GetRest());
			return result;
		}

		private static bool Valid(Pose p)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (Finite(p.pos))
			{
				if (!float.IsNaN(p.rot.x) && !float.IsNaN(p.rot.y) && !float.IsNaN(p.rot.z) && !float.IsNaN(p.rot.w))
				{
					if (p.rot.x == 0f && p.rot.y == 0f && p.rot.z == 0f)
					{
						return p.rot.w != 0f;
					}
					return true;
				}
				return false;
			}
			return false;
		}

		private static bool Finite(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!float.IsNaN(v.x) && !float.IsNaN(v.y) && !float.IsNaN(v.z) && !float.IsInfinity(v.x) && !float.IsInfinity(v.y))
			{
				return !float.IsInfinity(v.z);
			}
			return false;
		}

		private static Quaternion QAxis(Vector3 axis, float deg)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			float num = deg * 0.5f * (MathF.PI / 180f);
			float num2 = Mathf.Sin(num);
			return new Quaternion(axis.x * num2, axis.y * num2, axis.z * num2, Mathf.Cos(num));
		}

		private static Quaternion QEuler(Vector3 e)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			return QMul(QAxis(Vector3.up, e.y), QMul(QAxis(Vector3.right, e.x), QAxis(Vector3.forward, e.z)));
		}

		private static Quaternion QMul(Quaternion a, Quaternion b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y, a.w * b.y + a.y * b.w + a.z * b.x - a.x * b.z, a.w * b.z + a.z * b.w + a.x * b.y - a.y * b.x, a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z);
		}

		private static Quaternion QInv(Quaternion q)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(0f - q.x, 0f - q.y, 0f - q.z, q.w);
		}

		private static Vector3 QRotate(Quaternion q, Vector3 v)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(q.x, q.y, q.z);
			Vector3 val2 = 2f * Vector3.Cross(val, v);
			return v + q.w * val2 + Vector3.Cross(val, val2);
		}

		private static Quaternion QNorm(Quaternion q)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
			if (num < 1E-06f || float.IsNaN(num))
			{
				return new Quaternion(0f, 0f, 0f, 1f);
			}
			float num2 = 1f / num;
			return new Quaternion(q.x * num2, q.y * num2, q.z * num2, q.w * num2);
		}

		private static Quaternion QSlerp(Quaternion a, Quaternion b, float t)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			float num = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
			if (num < 0f)
			{
				num = 0f - num;
				((Quaternion)(ref b))..ctor(0f - b.x, 0f - b.y, 0f - b.z, 0f - b.w);
			}
			float num2;
			float num3;
			if (num > 0.9995f)
			{
				num2 = 1f - t;
				num3 = t;
			}
			else
			{
				float num4 = Mathf.Acos(Mathf.Clamp(num, -1f, 1f));
				float num5 = Mathf.Sin(num4);
				num2 = Mathf.Sin((1f - t) * num4) / num5;
				num3 = Mathf.Sin(t * num4) / num5;
			}
			return QNorm(new Quaternion(num2 * a.x + num3 * b.x, num2 * a.y + num3 * b.y, num2 * a.z + num3 * b.z, num2 * a.w + num3 * b.w));
		}

		private static Quaternion QLook(Vector3 fwd, Vector3 up)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Vector3 normalized = ((Vector3)(ref fwd)).normalized;
			Vector3 val = Vector3.Cross(up, normalized);
			if (((Vector3)(ref val)).sqrMagnitude < 1E-10f)
			{
				val = Vector3.Cross((Mathf.Abs(normalized.y) < 0.9f) ? Vector3.up : Vector3.right, normalized);
			}
			((Vector3)(ref val)).Normalize();
			Vector3 val2 = Vector3.Cross(normalized, val);
			float x = val.x;
			float x2 = val2.x;
			float x3 = normalized.x;
			float y = val.y;
			float y2 = val2.y;
			float y3 = normalized.y;
			float z = val.z;
			float z2 = val2.z;
			float z3 = normalized.z;
			float num = x + y2 + z3;
			Quaternion q = default(Quaternion);
			if (num > 0f)
			{
				float num2 = Mathf.Sqrt(num + 1f) * 2f;
				((Quaternion)(ref q))..ctor((z2 - y3) / num2, (x3 - z) / num2, (y - x2) / num2, 0.25f * num2);
			}
			else if (x > y2 && x > z3)
			{
				float num3 = Mathf.Sqrt(1f + x - y2 - z3) * 2f;
				((Quaternion)(ref q))..ctor(0.25f * num3, (x2 + y) / num3, (x3 + z) / num3, (z2 - y3) / num3);
			}
			else if (y2 > z3)
			{
				float num4 = Mathf.Sqrt(1f + y2 - x - z3) * 2f;
				((Quaternion)(ref q))..ctor((x2 + y) / num4, 0.25f * num4, (y3 + z2) / num4, (x3 - z) / num4);
			}
			else
			{
				float num5 = Mathf.Sqrt(1f + z3 - x - y2) * 2f;
				((Quaternion)(ref q))..ctor((x3 + z) / num5, (y3 + z2) / num5, 0.25f * num5, (y - x2) / num5);
			}
			return QNorm(q);
		}

		private static Vector3 QToRotVec(Quaternion q)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (q.w < 0f)
			{
				((Quaternion)(ref q))..ctor(0f - q.x, 0f - q.y, 0f - q.z, 0f - q.w);
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(q.x, q.y, q.z);
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 1E-07f)
			{
				return val * 2f;
			}
			float num = 2f * Mathf.Atan2(magnitude, q.w);
			return val * (num / magnitude);
		}

		private static Quaternion QFromRotVec(Vector3 r)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			float magnitude = ((Vector3)(ref r)).magnitude;
			if (magnitude < 1E-07f)
			{
				return QNorm(new Quaternion(r.x * 0.5f, r.y * 0.5f, r.z * 0.5f, 1f));
			}
			return QAxis(r / magnitude, magnitude * 57.29578f);
		}

		private static PoseKey P(float t, float gx, float gy, float gz, float bx, float by, float bz, float ex, float ey, float ez, bool stop = false, float roll = 0f)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			return new PoseKey
			{
				t = t,
				g = new Vector3(gx, gy, gz),
				blade = new Vector3(bx, by, bz),
				edge = new Vector3(ex, ey, ez),
				stop = stop,
				roll = roll
			};
		}

		private static PoseKey PIdle(float t, float roll = 0f)
		{
			return new PoseKey
			{
				t = t,
				idle = true,
				stop = true,
				roll = roll
			};
		}

		private static Vector3 EulerOf(Vector3 blade, Vector3 edge)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 normalized = ((Vector3)(ref blade)).normalized;
			Vector3 val = -(edge - Vector3.Dot(edge, normalized) * normalized);
			if (((Vector3)(ref val)).sqrMagnitude < 1E-08f)
			{
				val = Vector3.Cross(normalized, Vector3.right);
			}
			((Vector3)(ref val)).Normalize();
			float num = Mathf.Asin(Mathf.Clamp(0f - normalized.y, -1f, 1f));
			float num2 = Mathf.Atan2(normalized.x, normalized.z);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(Mathf.Cos(num2), 0f, 0f - Mathf.Sin(num2));
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(Mathf.Sin(num) * Mathf.Sin(num2), Mathf.Cos(num), Mathf.Sin(num) * Mathf.Cos(num2));
			float num3 = Mathf.Atan2(0f - Vector3.Dot(val, val2), Vector3.Dot(val, val3));
			return new Vector3(num, num2, num3) * 57.29578f;
		}

		private static float Near(float a, float reference)
		{
			return reference + Mathf.DeltaAngle(reference, a);
		}

		private static Key[] BuildKeys(params PoseKey[] ks)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			Key[] array = new Key[ks.Length];
			Vector3 val = DefaultRest;
			for (int i = 0; i < ks.Length; i++)
			{
				PoseKey poseKey = ks[i];
				if (poseKey.idle)
				{
					float num = Near(DefaultRest.z, val.z) - DefaultRest.z;
					array[i] = Idle(poseKey.t, num + poseKey.roll);
					val = DefaultRest + new Vector3(0f, 0f, num);
				}
				else
				{
					Vector3 val2 = EulerOf(poseKey.blade, poseKey.edge);
					((Vector3)(ref val2))..ctor(Near(val2.x, val.x), Near(val2.y, val.y), Near(val2.z, val.z));
					val = val2;
					val2.z += poseKey.roll;
					array[i] = K(poseKey.t, poseKey.g.x, poseKey.g.y, poseKey.g.z, val2.x, val2.y, val2.z, poseKey.stop);
				}
			}
			return array;
		}

		private static DKey D(float t, float ox, float oy, float oz, float ang, bool stop = false)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return new DKey
			{
				t = t,
				off = new Vector3(ox, oy, oz),
				ang = ang,
				stop = stop
			};
		}

		private static WKey W(float t, float w)
		{
			return new WKey
			{
				t = t,
				w = w
			};
		}

		private static float SampleW(WKey[] k, float t)
		{
			int num = ((k != null) ? k.Length : 0);
			if (num == 0 || float.IsNaN(t))
			{
				return 0f;
			}
			if (t <= k[0].t)
			{
				return k[0].w;
			}
			if (t >= k[num - 1].t)
			{
				ret