NobetaSource/Interop/Assembly-CSharp/RootMotion/FinalIK/IKSolverVR.cs

using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using UnityEngine;
using UnityEngine.Events;

namespace RootMotion.FinalIK
{
	// Token: 0x02000451 RID: 1105
	[Serializable]
	public class IKSolverVR : IKSolver
	{
		// Token: 0x06008363 RID: 33635 RVA: 0x00219BF0 File Offset: 0x00217DF0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618878, RefRangeEnd = 618879, XrefRangeStart = 618846, XrefRangeEnd = 618878, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetToReferences(VRIK.References references)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(references);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_SetToReferences_Public_Void_References_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008364 RID: 33636 RVA: 0x00219C4C File Offset: 0x00217E4C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 618894, RefRangeEnd = 618896, XrefRangeStart = 618879, XrefRangeEnd = 618894, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void GuessHandOrientations(VRIK.References references, bool onlyIfZero)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(references);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref onlyIfZero;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GuessHandOrientations_Public_Void_References_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008365 RID: 33637 RVA: 0x00219CB8 File Offset: 0x00217EB8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618911, RefRangeEnd = 618912, XrefRangeStart = 618896, XrefRangeEnd = 618911, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void DefaultAnimationCurves()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_DefaultAnimationCurves_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008366 RID: 33638 RVA: 0x00219CFC File Offset: 0x00217EFC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618912, RefRangeEnd = 618913, XrefRangeStart = 618912, XrefRangeEnd = 618912, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void AddPositionOffset(IKSolverVR.PositionOffset positionOffset, Vector3 value)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref positionOffset;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_AddPositionOffset_Public_Void_PositionOffset_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008367 RID: 33639 RVA: 0x00219D64 File Offset: 0x00217F64
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618913, XrefRangeEnd = 618915, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void AddRotationOffset(IKSolverVR.RotationOffset rotationOffset, Vector3 value)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref rotationOffset;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008368 RID: 33640 RVA: 0x00219DCC File Offset: 0x00217FCC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618916, RefRangeEnd = 618917, XrefRangeStart = 618915, XrefRangeEnd = 618916, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void AddRotationOffset(IKSolverVR.RotationOffset rotationOffset, Quaternion value)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref rotationOffset;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008369 RID: 33641 RVA: 0x00219E34 File Offset: 0x00218034
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 618920, RefRangeEnd = 618921, XrefRangeStart = 618917, XrefRangeEnd = 618920, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void AddPlatformMotion(Vector3 deltaPosition, Quaternion deltaRotation, Vector3 platformPivot)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref deltaPosition;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref deltaRotation;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref platformPivot;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_AddPlatformMotion_Public_Void_Vector3_Quaternion_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600836A RID: 33642 RVA: 0x00219EB0 File Offset: 0x002180B0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618921, XrefRangeEnd = 618927, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Reset()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_Reset_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600836B RID: 33643 RVA: 0x00219EF4 File Offset: 0x002180F4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618927, XrefRangeEnd = 618934, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void StoreDefaultLocalState()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600836C RID: 33644 RVA: 0x00219F44 File Offset: 0x00218144
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618934, XrefRangeEnd = 618941, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void FixTransforms()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.NativeMethodInfoPtr_FixTransforms_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600836D RID: 33645 RVA: 0x00219F94 File Offset: 0x00218194
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618941, XrefRangeEnd = 618947, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override Il2CppReferenceArray<IKSolver.Point> GetPoints()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.NativeMethodInfoPtr_GetPoints_Public_Virtual_Il2CppReferenceArray_1_Point_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new Il2CppReferenceArray<IKSolver.Point>(intPtr3) : null;
		}

		// Token: 0x0600836E RID: 33646 RVA: 0x00219FF8 File Offset: 0x002181F8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618947, XrefRangeEnd = 618953, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override IKSolver.Point GetPoint(Transform transform)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(transform);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.NativeMethodInfoPtr_GetPoint_Public_Virtual_Point_Transform_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new IKSolver.Point(intPtr3) : null;
			}
		}

		// Token: 0x0600836F RID: 33647 RVA: 0x0021A070 File Offset: 0x00218270
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618953, XrefRangeEnd = 618970, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override bool IsValid(ref string message)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				ref IntPtr ptr2 = ref *ptr;
				IntPtr intPtr = IL2CPP.ManagedStringToIl2Cpp(message);
				ptr2 = &intPtr;
				IntPtr intPtr3;
				IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.NativeMethodInfoPtr_IsValid_Public_Virtual_Boolean_byref_String_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr3);
				Il2CppException.RaiseExceptionIfNecessary(intPtr3);
				message = IL2CPP.Il2CppStringToManaged(intPtr);
				return *IL2CPP.il2cpp_object_unbox(intPtr2);
			}
		}

		// Token: 0x06008370 RID: 33648 RVA: 0x0021A0FC File Offset: 0x002182FC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618970, XrefRangeEnd = 618979, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GetNormal(Il2CppReferenceArray<Transform> transforms)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(transforms);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GetNormal_Private_Vector3_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06008371 RID: 33649 RVA: 0x0021A164 File Offset: 0x00218364
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 618985, RefRangeEnd = 618987, XrefRangeStart = 618979, XrefRangeEnd = 618985, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GuessWristToPalmAxis(Transform hand, Transform forearm)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(hand);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(forearm);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GuessWristToPalmAxis_Private_Vector3_Transform_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06008372 RID: 33650 RVA: 0x0021A1E4 File Offset: 0x002183E4
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 619009, RefRangeEnd = 619011, XrefRangeStart = 618987, XrefRangeEnd = 619009, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GuessPalmToThumbAxis(Transform hand, Transform forearm)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(hand);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(forearm);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GuessPalmToThumbAxis_Private_Vector3_Transform_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06008373 RID: 33651 RVA: 0x0021A264 File Offset: 0x00218464
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 619020, RefRangeEnd = 619022, XrefRangeStart = 619011, XrefRangeEnd = 619020, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Il2CppStructArray<Keyframe> GetSineKeyframes(float mag)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref mag;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GetSineKeyframes_Private_Static_Il2CppStructArray_1_Keyframe_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Il2CppStructArray<Keyframe>(intPtr3) : null;
			}
		}

		// Token: 0x06008374 RID: 33652 RVA: 0x0021A2C0 File Offset: 0x002184C0
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 619029, RefRangeEnd = 619032, XrefRangeStart = 619022, XrefRangeEnd = 619029, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void UpdateSolverTransforms()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_UpdateSolverTransforms_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008375 RID: 33653 RVA: 0x0021A304 File Offset: 0x00218504
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619032, XrefRangeEnd = 619034, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void OnInitiate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.NativeMethodInfoPtr_OnInitiate_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008376 RID: 33654 RVA: 0x0021A354 File Offset: 0x00218554
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 619034, XrefRangeEnd = 619039, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void OnUpdate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.NativeMethodInfoPtr_OnUpdate_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008377 RID: 33655 RVA: 0x0021A3A4 File Offset: 0x002185A4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 619051, RefRangeEnd = 619052, XrefRangeStart = 619039, XrefRangeEnd = 619051, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void WriteTransforms()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_WriteTransforms_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008378 RID: 33656 RVA: 0x0021A3E8 File Offset: 0x002185E8
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 619085, RefRangeEnd = 619088, XrefRangeStart = 619052, XrefRangeEnd = 619085, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Read(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations, bool hasChest, bool hasNeck, bool hasShoulders, bool hasToes)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasChest;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasNeck;
			ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasShoulders;
			ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasToes;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_Read_Private_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008379 RID: 33657 RVA: 0x0021A4A8 File Offset: 0x002186A8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 619156, RefRangeEnd = 619157, XrefRangeStart = 619088, XrefRangeEnd = 619156, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Solve()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_Solve_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600837A RID: 33658 RVA: 0x0021A4EC File Offset: 0x002186EC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 619163, RefRangeEnd = 619164, XrefRangeStart = 619157, XrefRangeEnd = 619163, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GetPosition(int index)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GetPosition_Private_Vector3_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x0600837B RID: 33659 RVA: 0x0021A550 File Offset: 0x00218750
		[CallerCount(0)]
		public unsafe Quaternion GetRotation(int index)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GetRotation_Private_Quaternion_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x17002CCC RID: 11468
		// (get) Token: 0x0600837C RID: 33660 RVA: 0x0021A5B4 File Offset: 0x002187B4
		// (set) Token: 0x0600837D RID: 33661 RVA: 0x0021A60C File Offset: 0x0021880C
		public unsafe IKSolverVR.VirtualBone rootBone
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_get_rootBone_Public_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
			}
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_set_rootBone_Private_set_Void_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x0600837E RID: 33662 RVA: 0x0021A668 File Offset: 0x00218868
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 619166, RefRangeEnd = 619168, XrefRangeStart = 619164, XrefRangeEnd = 619166, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Write()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_Write_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600837F RID: 33663 RVA: 0x0021A6AC File Offset: 0x002188AC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 619203, RefRangeEnd = 619204, XrefRangeStart = 619168, XrefRangeEnd = 619203, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GetPelvisOffset()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr_GetPelvisOffset_Private_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06008380 RID: 33664 RVA: 0x0021A6FC File Offset: 0x002188FC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 619263, RefRangeEnd = 619264, XrefRangeStart = 619204, XrefRangeEnd = 619263, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe IKSolverVR()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008381 RID: 33665 RVA: 0x0021A748 File Offset: 0x00218948
		// Note: this type is marked as 'beforefieldinit'.
		static IKSolverVR()
		{
			Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "IKSolverVR");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr);
			IKSolverVR.NativeFieldInfoPtr_solverTransforms = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "solverTransforms");
			IKSolverVR.NativeFieldInfoPtr_hasChest = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "hasChest");
			IKSolverVR.NativeFieldInfoPtr_hasNeck = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "hasNeck");
			IKSolverVR.NativeFieldInfoPtr_hasShoulders = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "hasShoulders");
			IKSolverVR.NativeFieldInfoPtr_hasToes = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "hasToes");
			IKSolverVR.NativeFieldInfoPtr_readPositions = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "readPositions");
			IKSolverVR.NativeFieldInfoPtr_readRotations = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "readRotations");
			IKSolverVR.NativeFieldInfoPtr_solvedPositions = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "solvedPositions");
			IKSolverVR.NativeFieldInfoPtr_solvedRotations = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "solvedRotations");
			IKSolverVR.NativeFieldInfoPtr_defaultPelvisLocalPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "defaultPelvisLocalPosition");
			IKSolverVR.NativeFieldInfoPtr_defaultLocalRotations = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "defaultLocalRotations");
			IKSolverVR.NativeFieldInfoPtr_rootV = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "rootV");
			IKSolverVR.NativeFieldInfoPtr_rootVelocity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "rootVelocity");
			IKSolverVR.NativeFieldInfoPtr_bodyOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "bodyOffset");
			IKSolverVR.NativeFieldInfoPtr_supportLegIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "supportLegIndex");
			IKSolverVR.NativeFieldInfoPtr_plantFeet = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "plantFeet");
			IKSolverVR.NativeFieldInfoPtr__rootBone_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "<rootBone>k__BackingField");
			IKSolverVR.NativeFieldInfoPtr_spine = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "spine");
			IKSolverVR.NativeFieldInfoPtr_leftArm = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "leftArm");
			IKSolverVR.NativeFieldInfoPtr_rightArm = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "rightArm");
			IKSolverVR.NativeFieldInfoPtr_leftLeg = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "leftLeg");
			IKSolverVR.NativeFieldInfoPtr_rightLeg = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "rightLeg");
			IKSolverVR.NativeFieldInfoPtr_locomotion = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "locomotion");
			IKSolverVR.NativeFieldInfoPtr_legs = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "legs");
			IKSolverVR.NativeFieldInfoPtr_arms = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "arms");
			IKSolverVR.NativeFieldInfoPtr_headPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "headPosition");
			IKSolverVR.NativeFieldInfoPtr_headDeltaPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "headDeltaPosition");
			IKSolverVR.NativeFieldInfoPtr_raycastOriginPelvis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "raycastOriginPelvis");
			IKSolverVR.NativeFieldInfoPtr_lastOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "lastOffset");
			IKSolverVR.NativeFieldInfoPtr_debugPos1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "debugPos1");
			IKSolverVR.NativeFieldInfoPtr_debugPos2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "debugPos2");
			IKSolverVR.NativeFieldInfoPtr_debugPos3 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "debugPos3");
			IKSolverVR.NativeFieldInfoPtr_debugPos4 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "debugPos4");
			IKSolverVR.NativeMethodInfoPtr_SetToReferences_Public_Void_References_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673297);
			IKSolverVR.NativeMethodInfoPtr_GuessHandOrientations_Public_Void_References_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673298);
			IKSolverVR.NativeMethodInfoPtr_DefaultAnimationCurves_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673299);
			IKSolverVR.NativeMethodInfoPtr_AddPositionOffset_Public_Void_PositionOffset_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673300);
			IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673301);
			IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673302);
			IKSolverVR.NativeMethodInfoPtr_AddPlatformMotion_Public_Void_Vector3_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673303);
			IKSolverVR.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673304);
			IKSolverVR.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673305);
			IKSolverVR.NativeMethodInfoPtr_FixTransforms_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673306);
			IKSolverVR.NativeMethodInfoPtr_GetPoints_Public_Virtual_Il2CppReferenceArray_1_Point_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673307);
			IKSolverVR.NativeMethodInfoPtr_GetPoint_Public_Virtual_Point_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673308);
			IKSolverVR.NativeMethodInfoPtr_IsValid_Public_Virtual_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673309);
			IKSolverVR.NativeMethodInfoPtr_GetNormal_Private_Vector3_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673310);
			IKSolverVR.NativeMethodInfoPtr_GuessWristToPalmAxis_Private_Vector3_Transform_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673311);
			IKSolverVR.NativeMethodInfoPtr_GuessPalmToThumbAxis_Private_Vector3_Transform_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673312);
			IKSolverVR.NativeMethodInfoPtr_GetSineKeyframes_Private_Static_Il2CppStructArray_1_Keyframe_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673313);
			IKSolverVR.NativeMethodInfoPtr_UpdateSolverTransforms_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673314);
			IKSolverVR.NativeMethodInfoPtr_OnInitiate_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673315);
			IKSolverVR.NativeMethodInfoPtr_OnUpdate_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673316);
			IKSolverVR.NativeMethodInfoPtr_WriteTransforms_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673317);
			IKSolverVR.NativeMethodInfoPtr_Read_Private_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673318);
			IKSolverVR.NativeMethodInfoPtr_Solve_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673319);
			IKSolverVR.NativeMethodInfoPtr_GetPosition_Private_Vector3_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673320);
			IKSolverVR.NativeMethodInfoPtr_GetRotation_Private_Quaternion_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673321);
			IKSolverVR.NativeMethodInfoPtr_get_rootBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673322);
			IKSolverVR.NativeMethodInfoPtr_set_rootBone_Private_set_Void_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673323);
			IKSolverVR.NativeMethodInfoPtr_Write_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673324);
			IKSolverVR.NativeMethodInfoPtr_GetPelvisOffset_Private_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673325);
			IKSolverVR.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673326);
		}

		// Token: 0x06008382 RID: 33666 RVA: 0x00212CC8 File Offset: 0x00210EC8
		public IKSolverVR(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002CAB RID: 11435
		// (get) Token: 0x06008383 RID: 33667 RVA: 0x0021AC64 File Offset: 0x00218E64
		// (set) Token: 0x06008384 RID: 33668 RVA: 0x0021AC98 File Offset: 0x00218E98
		public unsafe Il2CppReferenceArray<Transform> solverTransforms
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_solverTransforms);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<Transform>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_solverTransforms), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CAC RID: 11436
		// (get) Token: 0x06008385 RID: 33669 RVA: 0x0021ACC0 File Offset: 0x00218EC0
		// (set) Token: 0x06008386 RID: 33670 RVA: 0x0021ACE8 File Offset: 0x00218EE8
		public unsafe bool hasChest
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasChest);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasChest)) = value;
			}
		}

		// Token: 0x17002CAD RID: 11437
		// (get) Token: 0x06008387 RID: 33671 RVA: 0x0021AD0C File Offset: 0x00218F0C
		// (set) Token: 0x06008388 RID: 33672 RVA: 0x0021AD34 File Offset: 0x00218F34
		public unsafe bool hasNeck
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasNeck);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasNeck)) = value;
			}
		}

		// Token: 0x17002CAE RID: 11438
		// (get) Token: 0x06008389 RID: 33673 RVA: 0x0021AD58 File Offset: 0x00218F58
		// (set) Token: 0x0600838A RID: 33674 RVA: 0x0021AD80 File Offset: 0x00218F80
		public unsafe bool hasShoulders
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasShoulders);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasShoulders)) = value;
			}
		}

		// Token: 0x17002CAF RID: 11439
		// (get) Token: 0x0600838B RID: 33675 RVA: 0x0021ADA4 File Offset: 0x00218FA4
		// (set) Token: 0x0600838C RID: 33676 RVA: 0x0021ADCC File Offset: 0x00218FCC
		public unsafe bool hasToes
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasToes);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_hasToes)) = value;
			}
		}

		// Token: 0x17002CB0 RID: 11440
		// (get) Token: 0x0600838D RID: 33677 RVA: 0x0021ADF0 File Offset: 0x00218FF0
		// (set) Token: 0x0600838E RID: 33678 RVA: 0x0021AE24 File Offset: 0x00219024
		public unsafe Il2CppStructArray<Vector3> readPositions
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_readPositions);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Vector3>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_readPositions), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CB1 RID: 11441
		// (get) Token: 0x0600838F RID: 33679 RVA: 0x0021AE4C File Offset: 0x0021904C
		// (set) Token: 0x06008390 RID: 33680 RVA: 0x0021AE80 File Offset: 0x00219080
		public unsafe Il2CppStructArray<Quaternion> readRotations
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_readRotations);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Quaternion>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_readRotations), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CB2 RID: 11442
		// (get) Token: 0x06008391 RID: 33681 RVA: 0x0021AEA8 File Offset: 0x002190A8
		// (set) Token: 0x06008392 RID: 33682 RVA: 0x0021AEDC File Offset: 0x002190DC
		public unsafe Il2CppStructArray<Vector3> solvedPositions
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_solvedPositions);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Vector3>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_solvedPositions), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CB3 RID: 11443
		// (get) Token: 0x06008393 RID: 33683 RVA: 0x0021AF04 File Offset: 0x00219104
		// (set) Token: 0x06008394 RID: 33684 RVA: 0x0021AF38 File Offset: 0x00219138
		public unsafe Il2CppStructArray<Quaternion> solvedRotations
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_solvedRotations);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Quaternion>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_solvedRotations), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CB4 RID: 11444
		// (get) Token: 0x06008395 RID: 33685 RVA: 0x0021AF60 File Offset: 0x00219160
		// (set) Token: 0x06008396 RID: 33686 RVA: 0x0021AF88 File Offset: 0x00219188
		public unsafe Vector3 defaultPelvisLocalPosition
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_defaultPelvisLocalPosition);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_defaultPelvisLocalPosition)) = value;
			}
		}

		// Token: 0x17002CB5 RID: 11445
		// (get) Token: 0x06008397 RID: 33687 RVA: 0x0021AFAC File Offset: 0x002191AC
		// (set) Token: 0x06008398 RID: 33688 RVA: 0x0021AFE0 File Offset: 0x002191E0
		public unsafe Il2CppStructArray<Quaternion> defaultLocalRotations
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_defaultLocalRotations);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Quaternion>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_defaultLocalRotations), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CB6 RID: 11446
		// (get) Token: 0x06008399 RID: 33689 RVA: 0x0021B008 File Offset: 0x00219208
		// (set) Token: 0x0600839A RID: 33690 RVA: 0x0021B030 File Offset: 0x00219230
		public unsafe Vector3 rootV
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rootV);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rootV)) = value;
			}
		}

		// Token: 0x17002CB7 RID: 11447
		// (get) Token: 0x0600839B RID: 33691 RVA: 0x0021B054 File Offset: 0x00219254
		// (set) Token: 0x0600839C RID: 33692 RVA: 0x0021B07C File Offset: 0x0021927C
		public unsafe Vector3 rootVelocity
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rootVelocity);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rootVelocity)) = value;
			}
		}

		// Token: 0x17002CB8 RID: 11448
		// (get) Token: 0x0600839D RID: 33693 RVA: 0x0021B0A0 File Offset: 0x002192A0
		// (set) Token: 0x0600839E RID: 33694 RVA: 0x0021B0C8 File Offset: 0x002192C8
		public unsafe Vector3 bodyOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_bodyOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_bodyOffset)) = value;
			}
		}

		// Token: 0x17002CB9 RID: 11449
		// (get) Token: 0x0600839F RID: 33695 RVA: 0x0021B0EC File Offset: 0x002192EC
		// (set) Token: 0x060083A0 RID: 33696 RVA: 0x0021B114 File Offset: 0x00219314
		public unsafe int supportLegIndex
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_supportLegIndex);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_supportLegIndex)) = value;
			}
		}

		// Token: 0x17002CBA RID: 11450
		// (get) Token: 0x060083A1 RID: 33697 RVA: 0x0021B138 File Offset: 0x00219338
		// (set) Token: 0x060083A2 RID: 33698 RVA: 0x0021B160 File Offset: 0x00219360
		public unsafe bool plantFeet
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_plantFeet);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_plantFeet)) = value;
			}
		}

		// Token: 0x17002CBB RID: 11451
		// (get) Token: 0x060083A3 RID: 33699 RVA: 0x0021B184 File Offset: 0x00219384
		// (set) Token: 0x060083A4 RID: 33700 RVA: 0x0021B1B8 File Offset: 0x002193B8
		public unsafe IKSolverVR.VirtualBone _rootBone_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr__rootBone_k__BackingField);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolverVR.VirtualBone(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr__rootBone_k__BackingField), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CBC RID: 11452
		// (get) Token: 0x060083A5 RID: 33701 RVA: 0x0021B1E0 File Offset: 0x002193E0
		// (set) Token: 0x060083A6 RID: 33702 RVA: 0x0021B214 File Offset: 0x00219414
		public unsafe IKSolverVR.Spine spine
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_spine);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolverVR.Spine(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_spine), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CBD RID: 11453
		// (get) Token: 0x060083A7 RID: 33703 RVA: 0x0021B23C File Offset: 0x0021943C
		// (set) Token: 0x060083A8 RID: 33704 RVA: 0x0021B270 File Offset: 0x00219470
		public unsafe IKSolverVR.Arm leftArm
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_leftArm);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolverVR.Arm(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_leftArm), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CBE RID: 11454
		// (get) Token: 0x060083A9 RID: 33705 RVA: 0x0021B298 File Offset: 0x00219498
		// (set) Token: 0x060083AA RID: 33706 RVA: 0x0021B2CC File Offset: 0x002194CC
		public unsafe IKSolverVR.Arm rightArm
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rightArm);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolverVR.Arm(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rightArm), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CBF RID: 11455
		// (get) Token: 0x060083AB RID: 33707 RVA: 0x0021B2F4 File Offset: 0x002194F4
		// (set) Token: 0x060083AC RID: 33708 RVA: 0x0021B328 File Offset: 0x00219528
		public unsafe IKSolverVR.Leg leftLeg
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_leftLeg);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolverVR.Leg(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_leftLeg), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CC0 RID: 11456
		// (get) Token: 0x060083AD RID: 33709 RVA: 0x0021B350 File Offset: 0x00219550
		// (set) Token: 0x060083AE RID: 33710 RVA: 0x0021B384 File Offset: 0x00219584
		public unsafe IKSolverVR.Leg rightLeg
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rightLeg);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolverVR.Leg(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_rightLeg), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CC1 RID: 11457
		// (get) Token: 0x060083AF RID: 33711 RVA: 0x0021B3AC File Offset: 0x002195AC
		// (set) Token: 0x060083B0 RID: 33712 RVA: 0x0021B3E0 File Offset: 0x002195E0
		public unsafe IKSolverVR.Locomotion locomotion
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_locomotion);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolverVR.Locomotion(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_locomotion), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CC2 RID: 11458
		// (get) Token: 0x060083B1 RID: 33713 RVA: 0x0021B408 File Offset: 0x00219608
		// (set) Token: 0x060083B2 RID: 33714 RVA: 0x0021B43C File Offset: 0x0021963C
		public unsafe Il2CppReferenceArray<IKSolverVR.Leg> legs
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_legs);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<IKSolverVR.Leg>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_legs), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CC3 RID: 11459
		// (get) Token: 0x060083B3 RID: 33715 RVA: 0x0021B464 File Offset: 0x00219664
		// (set) Token: 0x060083B4 RID: 33716 RVA: 0x0021B498 File Offset: 0x00219698
		public unsafe Il2CppReferenceArray<IKSolverVR.Arm> arms
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_arms);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<IKSolverVR.Arm>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_arms), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002CC4 RID: 11460
		// (get) Token: 0x060083B5 RID: 33717 RVA: 0x0021B4C0 File Offset: 0x002196C0
		// (set) Token: 0x060083B6 RID: 33718 RVA: 0x0021B4E8 File Offset: 0x002196E8
		public unsafe Vector3 headPosition
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_headPosition);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_headPosition)) = value;
			}
		}

		// Token: 0x17002CC5 RID: 11461
		// (get) Token: 0x060083B7 RID: 33719 RVA: 0x0021B50C File Offset: 0x0021970C
		// (set) Token: 0x060083B8 RID: 33720 RVA: 0x0021B534 File Offset: 0x00219734
		public unsafe Vector3 headDeltaPosition
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_headDeltaPosition);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_headDeltaPosition)) = value;
			}
		}

		// Token: 0x17002CC6 RID: 11462
		// (get) Token: 0x060083B9 RID: 33721 RVA: 0x0021B558 File Offset: 0x00219758
		// (set) Token: 0x060083BA RID: 33722 RVA: 0x0021B580 File Offset: 0x00219780
		public unsafe Vector3 raycastOriginPelvis
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_raycastOriginPelvis);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_raycastOriginPelvis)) = value;
			}
		}

		// Token: 0x17002CC7 RID: 11463
		// (get) Token: 0x060083BB RID: 33723 RVA: 0x0021B5A4 File Offset: 0x002197A4
		// (set) Token: 0x060083BC RID: 33724 RVA: 0x0021B5CC File Offset: 0x002197CC
		public unsafe Vector3 lastOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_lastOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_lastOffset)) = value;
			}
		}

		// Token: 0x17002CC8 RID: 11464
		// (get) Token: 0x060083BD RID: 33725 RVA: 0x0021B5F0 File Offset: 0x002197F0
		// (set) Token: 0x060083BE RID: 33726 RVA: 0x0021B618 File Offset: 0x00219818
		public unsafe Vector3 debugPos1
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos1);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos1)) = value;
			}
		}

		// Token: 0x17002CC9 RID: 11465
		// (get) Token: 0x060083BF RID: 33727 RVA: 0x0021B63C File Offset: 0x0021983C
		// (set) Token: 0x060083C0 RID: 33728 RVA: 0x0021B664 File Offset: 0x00219864
		public unsafe Vector3 debugPos2
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos2);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos2)) = value;
			}
		}

		// Token: 0x17002CCA RID: 11466
		// (get) Token: 0x060083C1 RID: 33729 RVA: 0x0021B688 File Offset: 0x00219888
		// (set) Token: 0x060083C2 RID: 33730 RVA: 0x0021B6B0 File Offset: 0x002198B0
		public unsafe Vector3 debugPos3
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos3);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos3)) = value;
			}
		}

		// Token: 0x17002CCB RID: 11467
		// (get) Token: 0x060083C3 RID: 33731 RVA: 0x0021B6D4 File Offset: 0x002198D4
		// (set) Token: 0x060083C4 RID: 33732 RVA: 0x0021B6FC File Offset: 0x002198FC
		public unsafe Vector3 debugPos4
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos4);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.NativeFieldInfoPtr_debugPos4)) = value;
			}
		}

		// Token: 0x040057CF RID: 22479
		private static readonly IntPtr NativeFieldInfoPtr_solverTransforms;

		// Token: 0x040057D0 RID: 22480
		private static readonly IntPtr NativeFieldInfoPtr_hasChest;

		// Token: 0x040057D1 RID: 22481
		private static readonly IntPtr NativeFieldInfoPtr_hasNeck;

		// Token: 0x040057D2 RID: 22482
		private static readonly IntPtr NativeFieldInfoPtr_hasShoulders;

		// Token: 0x040057D3 RID: 22483
		private static readonly IntPtr NativeFieldInfoPtr_hasToes;

		// Token: 0x040057D4 RID: 22484
		private static readonly IntPtr NativeFieldInfoPtr_readPositions;

		// Token: 0x040057D5 RID: 22485
		private static readonly IntPtr NativeFieldInfoPtr_readRotations;

		// Token: 0x040057D6 RID: 22486
		private static readonly IntPtr NativeFieldInfoPtr_solvedPositions;

		// Token: 0x040057D7 RID: 22487
		private static readonly IntPtr NativeFieldInfoPtr_solvedRotations;

		// Token: 0x040057D8 RID: 22488
		private static readonly IntPtr NativeFieldInfoPtr_defaultPelvisLocalPosition;

		// Token: 0x040057D9 RID: 22489
		private static readonly IntPtr NativeFieldInfoPtr_defaultLocalRotations;

		// Token: 0x040057DA RID: 22490
		private static readonly IntPtr NativeFieldInfoPtr_rootV;

		// Token: 0x040057DB RID: 22491
		private static readonly IntPtr NativeFieldInfoPtr_rootVelocity;

		// Token: 0x040057DC RID: 22492
		private static readonly IntPtr NativeFieldInfoPtr_bodyOffset;

		// Token: 0x040057DD RID: 22493
		private static readonly IntPtr NativeFieldInfoPtr_supportLegIndex;

		// Token: 0x040057DE RID: 22494
		private static readonly IntPtr NativeFieldInfoPtr_plantFeet;

		// Token: 0x040057DF RID: 22495
		private static readonly IntPtr NativeFieldInfoPtr__rootBone_k__BackingField;

		// Token: 0x040057E0 RID: 22496
		private static readonly IntPtr NativeFieldInfoPtr_spine;

		// Token: 0x040057E1 RID: 22497
		private static readonly IntPtr NativeFieldInfoPtr_leftArm;

		// Token: 0x040057E2 RID: 22498
		private static readonly IntPtr NativeFieldInfoPtr_rightArm;

		// Token: 0x040057E3 RID: 22499
		private static readonly IntPtr NativeFieldInfoPtr_leftLeg;

		// Token: 0x040057E4 RID: 22500
		private static readonly IntPtr NativeFieldInfoPtr_rightLeg;

		// Token: 0x040057E5 RID: 22501
		private static readonly IntPtr NativeFieldInfoPtr_locomotion;

		// Token: 0x040057E6 RID: 22502
		private static readonly IntPtr NativeFieldInfoPtr_legs;

		// Token: 0x040057E7 RID: 22503
		private static readonly IntPtr NativeFieldInfoPtr_arms;

		// Token: 0x040057E8 RID: 22504
		private static readonly IntPtr NativeFieldInfoPtr_headPosition;

		// Token: 0x040057E9 RID: 22505
		private static readonly IntPtr NativeFieldInfoPtr_headDeltaPosition;

		// Token: 0x040057EA RID: 22506
		private static readonly IntPtr NativeFieldInfoPtr_raycastOriginPelvis;

		// Token: 0x040057EB RID: 22507
		private static readonly IntPtr NativeFieldInfoPtr_lastOffset;

		// Token: 0x040057EC RID: 22508
		private static readonly IntPtr NativeFieldInfoPtr_debugPos1;

		// Token: 0x040057ED RID: 22509
		private static readonly IntPtr NativeFieldInfoPtr_debugPos2;

		// Token: 0x040057EE RID: 22510
		private static readonly IntPtr NativeFieldInfoPtr_debugPos3;

		// Token: 0x040057EF RID: 22511
		private static readonly IntPtr NativeFieldInfoPtr_debugPos4;

		// Token: 0x040057F0 RID: 22512
		private static readonly IntPtr NativeMethodInfoPtr_SetToReferences_Public_Void_References_0;

		// Token: 0x040057F1 RID: 22513
		private static readonly IntPtr NativeMethodInfoPtr_GuessHandOrientations_Public_Void_References_Boolean_0;

		// Token: 0x040057F2 RID: 22514
		private static readonly IntPtr NativeMethodInfoPtr_DefaultAnimationCurves_Public_Void_0;

		// Token: 0x040057F3 RID: 22515
		private static readonly IntPtr NativeMethodInfoPtr_AddPositionOffset_Public_Void_PositionOffset_Vector3_0;

		// Token: 0x040057F4 RID: 22516
		private static readonly IntPtr NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Vector3_0;

		// Token: 0x040057F5 RID: 22517
		private static readonly IntPtr NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Quaternion_0;

		// Token: 0x040057F6 RID: 22518
		private static readonly IntPtr NativeMethodInfoPtr_AddPlatformMotion_Public_Void_Vector3_Quaternion_Vector3_0;

		// Token: 0x040057F7 RID: 22519
		private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

		// Token: 0x040057F8 RID: 22520
		private static readonly IntPtr NativeMethodInfoPtr_StoreDefaultLocalState_Public_Virtual_Void_0;

		// Token: 0x040057F9 RID: 22521
		private static readonly IntPtr NativeMethodInfoPtr_FixTransforms_Public_Virtual_Void_0;

		// Token: 0x040057FA RID: 22522
		private static readonly IntPtr NativeMethodInfoPtr_GetPoints_Public_Virtual_Il2CppReferenceArray_1_Point_0;

		// Token: 0x040057FB RID: 22523
		private static readonly IntPtr NativeMethodInfoPtr_GetPoint_Public_Virtual_Point_Transform_0;

		// Token: 0x040057FC RID: 22524
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Virtual_Boolean_byref_String_0;

		// Token: 0x040057FD RID: 22525
		private static readonly IntPtr NativeMethodInfoPtr_GetNormal_Private_Vector3_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x040057FE RID: 22526
		private static readonly IntPtr NativeMethodInfoPtr_GuessWristToPalmAxis_Private_Vector3_Transform_Transform_0;

		// Token: 0x040057FF RID: 22527
		private static readonly IntPtr NativeMethodInfoPtr_GuessPalmToThumbAxis_Private_Vector3_Transform_Transform_0;

		// Token: 0x04005800 RID: 22528
		private static readonly IntPtr NativeMethodInfoPtr_GetSineKeyframes_Private_Static_Il2CppStructArray_1_Keyframe_Single_0;

		// Token: 0x04005801 RID: 22529
		private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverTransforms_Private_Void_0;

		// Token: 0x04005802 RID: 22530
		private static readonly IntPtr NativeMethodInfoPtr_OnInitiate_Protected_Virtual_Void_0;

		// Token: 0x04005803 RID: 22531
		private static readonly IntPtr NativeMethodInfoPtr_OnUpdate_Protected_Virtual_Void_0;

		// Token: 0x04005804 RID: 22532
		private static readonly IntPtr NativeMethodInfoPtr_WriteTransforms_Private_Void_0;

		// Token: 0x04005805 RID: 22533
		private static readonly IntPtr NativeMethodInfoPtr_Read_Private_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_0;

		// Token: 0x04005806 RID: 22534
		private static readonly IntPtr NativeMethodInfoPtr_Solve_Private_Void_0;

		// Token: 0x04005807 RID: 22535
		private static readonly IntPtr NativeMethodInfoPtr_GetPosition_Private_Vector3_Int32_0;

		// Token: 0x04005808 RID: 22536
		private static readonly IntPtr NativeMethodInfoPtr_GetRotation_Private_Quaternion_Int32_0;

		// Token: 0x04005809 RID: 22537
		private static readonly IntPtr NativeMethodInfoPtr_get_rootBone_Public_get_VirtualBone_0;

		// Token: 0x0400580A RID: 22538
		private static readonly IntPtr NativeMethodInfoPtr_set_rootBone_Private_set_Void_VirtualBone_0;

		// Token: 0x0400580B RID: 22539
		private static readonly IntPtr NativeMethodInfoPtr_Write_Private_Void_0;

		// Token: 0x0400580C RID: 22540
		private static readonly IntPtr NativeMethodInfoPtr_GetPelvisOffset_Private_Vector3_0;

		// Token: 0x0400580D RID: 22541
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000452 RID: 1106
		[Serializable]
		public class Arm : IKSolverVR.BodyPart
		{
			// Token: 0x17002CE6 RID: 11494
			// (get) Token: 0x060083C5 RID: 33733 RVA: 0x0021B720 File Offset: 0x00219920
			// (set) Token: 0x060083C6 RID: 33734 RVA: 0x0021B770 File Offset: 0x00219970
			public unsafe Vector3 position
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_get_position_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002CE7 RID: 11495
			// (get) Token: 0x060083C7 RID: 33735 RVA: 0x0021B7C4 File Offset: 0x002199C4
			// (set) Token: 0x060083C8 RID: 33736 RVA: 0x0021B814 File Offset: 0x00219A14
			public unsafe Quaternion rotation
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002CE8 RID: 11496
			// (get) Token: 0x060083C9 RID: 33737 RVA: 0x0021B868 File Offset: 0x00219A68
			public unsafe IKSolverVR.VirtualBone shoulder
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_get_shoulder_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002CE9 RID: 11497
			// (get) Token: 0x060083CA RID: 33738 RVA: 0x0021B8C0 File Offset: 0x00219AC0
			public unsafe IKSolverVR.VirtualBone upperArm
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_get_upperArm_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002CEA RID: 11498
			// (get) Token: 0x060083CB RID: 33739 RVA: 0x0021B918 File Offset: 0x00219B18
			public unsafe IKSolverVR.VirtualBone forearm
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_get_forearm_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002CEB RID: 11499
			// (get) Token: 0x060083CC RID: 33740 RVA: 0x0021B970 File Offset: 0x00219B70
			public unsafe IKSolverVR.VirtualBone hand
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_get_hand_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x060083CD RID: 33741 RVA: 0x0021B9C8 File Offset: 0x00219BC8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 617911, XrefRangeEnd = 617959, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void OnRead(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations, bool hasChest, bool hasNeck, bool hasShoulders, bool hasToes, int rootIndex, int index)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasChest;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasNeck;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasShoulders;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasToes;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootIndex;
				ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Arm.NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060083CE RID: 33742 RVA: 0x0021BAB8 File Offset: 0x00219CB8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 617959, XrefRangeEnd = 617970, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void PreSolve()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Arm.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060083CF RID: 33743 RVA: 0x0021BB08 File Offset: 0x00219D08
			[CallerCount(0)]
			public unsafe override void ApplyOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Arm.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060083D0 RID: 33744 RVA: 0x0021BB58 File Offset: 0x00219D58
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618065, RefRangeEnd = 618066, XrefRangeStart = 617970, XrefRangeEnd = 618065, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Solve(bool isLeft)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref isLeft;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_Solve_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x060083D1 RID: 33745 RVA: 0x0021BBAC File Offset: 0x00219DAC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618066, XrefRangeEnd = 618067, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void ResetOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Arm.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060083D2 RID: 33746 RVA: 0x0021BBFC File Offset: 0x00219DFC
			[CallerCount(0)]
			public unsafe override void Write(ref Il2CppStructArray<Vector3> solvedPositions, ref Il2CppStructArray<Quaternion> solvedRotations)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedPositions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedRotations);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Arm.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060083D3 RID: 33747 RVA: 0x0021BC7C File Offset: 0x00219E7C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618067, XrefRangeEnd = 618070, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe float DamperValue(float value, float min, float max, float weight = 1f)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref value;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref min;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref max;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_DamperValue_Private_Single_Single_Single_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x060083D4 RID: 33748 RVA: 0x0021BD18 File Offset: 0x00219F18
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 618099, RefRangeEnd = 618102, XrefRangeStart = 618070, XrefRangeEnd = 618099, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Vector3 GetBendNormal(Vector3 dir)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref dir;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_GetBendNormal_Private_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x060083D5 RID: 33749 RVA: 0x0021BD7C File Offset: 0x00219F7C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618102, XrefRangeEnd = 618107, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Visualize(IKSolverVR.VirtualBone bone1, IKSolverVR.VirtualBone bone2, IKSolverVR.VirtualBone bone3, Color color)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bone1);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(bone2);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(bone3);
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref color;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr_Visualize_Private_Void_VirtualBone_VirtualBone_VirtualBone_Color_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060083D6 RID: 33750 RVA: 0x0021BE18 File Offset: 0x0021A018
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618119, RefRangeEnd = 618121, XrefRangeStart = 618107, XrefRangeEnd = 618119, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Arm()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Arm.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060083D7 RID: 33751 RVA: 0x0021BE64 File Offset: 0x0021A064
			// Note: this type is marked as 'beforefieldinit'.
			static Arm()
			{
				Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "Arm");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr);
				IKSolverVR.Arm.NativeFieldInfoPtr_target = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "target");
				IKSolverVR.Arm.NativeFieldInfoPtr_bendGoal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "bendGoal");
				IKSolverVR.Arm.NativeFieldInfoPtr_positionWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "positionWeight");
				IKSolverVR.Arm.NativeFieldInfoPtr_rotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "rotationWeight");
				IKSolverVR.Arm.NativeFieldInfoPtr_shoulderRotationMode = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "shoulderRotationMode");
				IKSolverVR.Arm.NativeFieldInfoPtr_shoulderRotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "shoulderRotationWeight");
				IKSolverVR.Arm.NativeFieldInfoPtr_bendGoalWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "bendGoalWeight");
				IKSolverVR.Arm.NativeFieldInfoPtr_swivelOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "swivelOffset");
				IKSolverVR.Arm.NativeFieldInfoPtr_wristToPalmAxis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "wristToPalmAxis");
				IKSolverVR.Arm.NativeFieldInfoPtr_palmToThumbAxis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "palmToThumbAxis");
				IKSolverVR.Arm.NativeFieldInfoPtr_IKPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "IKPosition");
				IKSolverVR.Arm.NativeFieldInfoPtr_IKRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "IKRotation");
				IKSolverVR.Arm.NativeFieldInfoPtr_bendDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "bendDirection");
				IKSolverVR.Arm.NativeFieldInfoPtr_handPositionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "handPositionOffset");
				IKSolverVR.Arm.NativeFieldInfoPtr__position_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "<position>k__BackingField");
				IKSolverVR.Arm.NativeFieldInfoPtr__rotation_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "<rotation>k__BackingField");
				IKSolverVR.Arm.NativeFieldInfoPtr_hasShoulder = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "hasShoulder");
				IKSolverVR.Arm.NativeFieldInfoPtr_chestForwardAxis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "chestForwardAxis");
				IKSolverVR.Arm.NativeFieldInfoPtr_chestUpAxis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "chestUpAxis");
				IKSolverVR.Arm.NativeFieldInfoPtr_chestRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "chestRotation");
				IKSolverVR.Arm.NativeFieldInfoPtr_chestForward = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "chestForward");
				IKSolverVR.Arm.NativeFieldInfoPtr_chestUp = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "chestUp");
				IKSolverVR.Arm.NativeFieldInfoPtr_forearmRelToUpperArm = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "forearmRelToUpperArm");
				IKSolverVR.Arm.NativeFieldInfoPtr_yawOffsetAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "yawOffsetAngle");
				IKSolverVR.Arm.NativeFieldInfoPtr_pitchOffsetAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, "pitchOffsetAngle");
				IKSolverVR.Arm.NativeMethodInfoPtr_get_position_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673327);
				IKSolverVR.Arm.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673328);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673329);
				IKSolverVR.Arm.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673330);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_shoulder_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673331);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_upperArm_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673332);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_forearm_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673333);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_hand_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673334);
				IKSolverVR.Arm.NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673335);
				IKSolverVR.Arm.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673336);
				IKSolverVR.Arm.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673337);
				IKSolverVR.Arm.NativeMethodInfoPtr_Solve_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673338);
				IKSolverVR.Arm.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673339);
				IKSolverVR.Arm.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673340);
				IKSolverVR.Arm.NativeMethodInfoPtr_DamperValue_Private_Single_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673341);
				IKSolverVR.Arm.NativeMethodInfoPtr_GetBendNormal_Private_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673342);
				IKSolverVR.Arm.NativeMethodInfoPtr_Visualize_Private_Void_VirtualBone_VirtualBone_VirtualBone_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673343);
				IKSolverVR.Arm.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673344);
			}

			// Token: 0x060083D8 RID: 33752 RVA: 0x0021C1EB File Offset: 0x0021A3EB
			public Arm(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002CCD RID: 11469
			// (get) Token: 0x060083D9 RID: 33753 RVA: 0x0021C1F4 File Offset: 0x0021A3F4
			// (set) Token: 0x060083DA RID: 33754 RVA: 0x0021C228 File Offset: 0x0021A428
			public unsafe Transform target
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_target);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_target), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002CCE RID: 11470
			// (get) Token: 0x060083DB RID: 33755 RVA: 0x0021C250 File Offset: 0x0021A450
			// (set) Token: 0x060083DC RID: 33756 RVA: 0x0021C284 File Offset: 0x0021A484
			public unsafe Transform bendGoal
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_bendGoal);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_bendGoal), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002CCF RID: 11471
			// (get) Token: 0x060083DD RID: 33757 RVA: 0x0021C2AC File Offset: 0x0021A4AC
			// (set) Token: 0x060083DE RID: 33758 RVA: 0x0021C2D4 File Offset: 0x0021A4D4
			public unsafe float positionWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_positionWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_positionWeight)) = value;
				}
			}

			// Token: 0x17002CD0 RID: 11472
			// (get) Token: 0x060083DF RID: 33759 RVA: 0x0021C2F8 File Offset: 0x0021A4F8
			// (set) Token: 0x060083E0 RID: 33760 RVA: 0x0021C320 File Offset: 0x0021A520
			public unsafe float rotationWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_rotationWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_rotationWeight)) = value;
				}
			}

			// Token: 0x17002CD1 RID: 11473
			// (get) Token: 0x060083E1 RID: 33761 RVA: 0x0021C344 File Offset: 0x0021A544
			// (set) Token: 0x060083E2 RID: 33762 RVA: 0x0021C36C File Offset: 0x0021A56C
			public unsafe IKSolverVR.Arm.ShoulderRotationMode shoulderRotationMode
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_shoulderRotationMode);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_shoulderRotationMode)) = value;
				}
			}

			// Token: 0x17002CD2 RID: 11474
			// (get) Token: 0x060083E3 RID: 33763 RVA: 0x0021C390 File Offset: 0x0021A590
			// (set) Token: 0x060083E4 RID: 33764 RVA: 0x0021C3B8 File Offset: 0x0021A5B8
			public unsafe float shoulderRotationWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_shoulderRotationWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_shoulderRotationWeight)) = value;
				}
			}

			// Token: 0x17002CD3 RID: 11475
			// (get) Token: 0x060083E5 RID: 33765 RVA: 0x0021C3DC File Offset: 0x0021A5DC
			// (set) Token: 0x060083E6 RID: 33766 RVA: 0x0021C404 File Offset: 0x0021A604
			public unsafe float bendGoalWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_bendGoalWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_bendGoalWeight)) = value;
				}
			}

			// Token: 0x17002CD4 RID: 11476
			// (get) Token: 0x060083E7 RID: 33767 RVA: 0x0021C428 File Offset: 0x0021A628
			// (set) Token: 0x060083E8 RID: 33768 RVA: 0x0021C450 File Offset: 0x0021A650
			public unsafe float swivelOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_swivelOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_swivelOffset)) = value;
				}
			}

			// Token: 0x17002CD5 RID: 11477
			// (get) Token: 0x060083E9 RID: 33769 RVA: 0x0021C474 File Offset: 0x0021A674
			// (set) Token: 0x060083EA RID: 33770 RVA: 0x0021C49C File Offset: 0x0021A69C
			public unsafe Vector3 wristToPalmAxis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_wristToPalmAxis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_wristToPalmAxis)) = value;
				}
			}

			// Token: 0x17002CD6 RID: 11478
			// (get) Token: 0x060083EB RID: 33771 RVA: 0x0021C4C0 File Offset: 0x0021A6C0
			// (set) Token: 0x060083EC RID: 33772 RVA: 0x0021C4E8 File Offset: 0x0021A6E8
			public unsafe Vector3 palmToThumbAxis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_palmToThumbAxis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_palmToThumbAxis)) = value;
				}
			}

			// Token: 0x17002CD7 RID: 11479
			// (get) Token: 0x060083ED RID: 33773 RVA: 0x0021C50C File Offset: 0x0021A70C
			// (set) Token: 0x060083EE RID: 33774 RVA: 0x0021C534 File Offset: 0x0021A734
			public unsafe Vector3 IKPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_IKPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_IKPosition)) = value;
				}
			}

			// Token: 0x17002CD8 RID: 11480
			// (get) Token: 0x060083EF RID: 33775 RVA: 0x0021C558 File Offset: 0x0021A758
			// (set) Token: 0x060083F0 RID: 33776 RVA: 0x0021C580 File Offset: 0x0021A780
			public unsafe Quaternion IKRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_IKRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_IKRotation)) = value;
				}
			}

			// Token: 0x17002CD9 RID: 11481
			// (get) Token: 0x060083F1 RID: 33777 RVA: 0x0021C5A4 File Offset: 0x0021A7A4
			// (set) Token: 0x060083F2 RID: 33778 RVA: 0x0021C5CC File Offset: 0x0021A7CC
			public unsafe Vector3 bendDirection
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_bendDirection);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_bendDirection)) = value;
				}
			}

			// Token: 0x17002CDA RID: 11482
			// (get) Token: 0x060083F3 RID: 33779 RVA: 0x0021C5F0 File Offset: 0x0021A7F0
			// (set) Token: 0x060083F4 RID: 33780 RVA: 0x0021C618 File Offset: 0x0021A818
			public unsafe Vector3 handPositionOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_handPositionOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_handPositionOffset)) = value;
				}
			}

			// Token: 0x17002CDB RID: 11483
			// (get) Token: 0x060083F5 RID: 33781 RVA: 0x0021C63C File Offset: 0x0021A83C
			// (set) Token: 0x060083F6 RID: 33782 RVA: 0x0021C664 File Offset: 0x0021A864
			public unsafe Vector3 _position_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr__position_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr__position_k__BackingField)) = value;
				}
			}

			// Token: 0x17002CDC RID: 11484
			// (get) Token: 0x060083F7 RID: 33783 RVA: 0x0021C688 File Offset: 0x0021A888
			// (set) Token: 0x060083F8 RID: 33784 RVA: 0x0021C6B0 File Offset: 0x0021A8B0
			public unsafe Quaternion _rotation_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr__rotation_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr__rotation_k__BackingField)) = value;
				}
			}

			// Token: 0x17002CDD RID: 11485
			// (get) Token: 0x060083F9 RID: 33785 RVA: 0x0021C6D4 File Offset: 0x0021A8D4
			// (set) Token: 0x060083FA RID: 33786 RVA: 0x0021C6FC File Offset: 0x0021A8FC
			public unsafe bool hasShoulder
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_hasShoulder);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_hasShoulder)) = value;
				}
			}

			// Token: 0x17002CDE RID: 11486
			// (get) Token: 0x060083FB RID: 33787 RVA: 0x0021C720 File Offset: 0x0021A920
			// (set) Token: 0x060083FC RID: 33788 RVA: 0x0021C748 File Offset: 0x0021A948
			public unsafe Vector3 chestForwardAxis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestForwardAxis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestForwardAxis)) = value;
				}
			}

			// Token: 0x17002CDF RID: 11487
			// (get) Token: 0x060083FD RID: 33789 RVA: 0x0021C76C File Offset: 0x0021A96C
			// (set) Token: 0x060083FE RID: 33790 RVA: 0x0021C794 File Offset: 0x0021A994
			public unsafe Vector3 chestUpAxis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestUpAxis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestUpAxis)) = value;
				}
			}

			// Token: 0x17002CE0 RID: 11488
			// (get) Token: 0x060083FF RID: 33791 RVA: 0x0021C7B8 File Offset: 0x0021A9B8
			// (set) Token: 0x06008400 RID: 33792 RVA: 0x0021C7E0 File Offset: 0x0021A9E0
			public unsafe Quaternion chestRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestRotation)) = value;
				}
			}

			// Token: 0x17002CE1 RID: 11489
			// (get) Token: 0x06008401 RID: 33793 RVA: 0x0021C804 File Offset: 0x0021AA04
			// (set) Token: 0x06008402 RID: 33794 RVA: 0x0021C82C File Offset: 0x0021AA2C
			public unsafe Vector3 chestForward
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestForward);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestForward)) = value;
				}
			}

			// Token: 0x17002CE2 RID: 11490
			// (get) Token: 0x06008403 RID: 33795 RVA: 0x0021C850 File Offset: 0x0021AA50
			// (set) Token: 0x06008404 RID: 33796 RVA: 0x0021C878 File Offset: 0x0021AA78
			public unsafe Vector3 chestUp
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestUp);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_chestUp)) = value;
				}
			}

			// Token: 0x17002CE3 RID: 11491
			// (get) Token: 0x06008405 RID: 33797 RVA: 0x0021C89C File Offset: 0x0021AA9C
			// (set) Token: 0x06008406 RID: 33798 RVA: 0x0021C8C4 File Offset: 0x0021AAC4
			public unsafe Quaternion forearmRelToUpperArm
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_forearmRelToUpperArm);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Arm.NativeFieldInfoPtr_forearmRelToUpperArm)) = value;
				}
			}

			// Token: 0x17002CE4 RID: 11492
			// (get) Token: 0x06008407 RID: 33799 RVA: 0x0021C8E8 File Offset: 0x0021AAE8
			// (set) Token: 0x06008408 RID: 33800 RVA: 0x0021C906 File Offset: 0x0021AB06
			public unsafe static float yawOffsetAngle
			{
				get
				{
					float num;
					IL2CPP.il2cpp_field_static_get_value(IKSolverVR.Arm.NativeFieldInfoPtr_yawOffsetAngle, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(IKSolverVR.Arm.NativeFieldInfoPtr_yawOffsetAngle, (void*)(&value));
				}
			}

			// Token: 0x17002CE5 RID: 11493
			// (get) Token: 0x06008409 RID: 33801 RVA: 0x0021C918 File Offset: 0x0021AB18
			// (set) Token: 0x0600840A RID: 33802 RVA: 0x0021C936 File Offset: 0x0021AB36
			public unsafe static float pitchOffsetAngle
			{
				get
				{
					float num;
					IL2CPP.il2cpp_field_static_get_value(IKSolverVR.Arm.NativeFieldInfoPtr_pitchOffsetAngle, (void*)(&num));
					return num;
				}
				set
				{
					IL2CPP.il2cpp_field_static_set_value(IKSolverVR.Arm.NativeFieldInfoPtr_pitchOffsetAngle, (void*)(&value));
				}
			}

			// Token: 0x0400580E RID: 22542
			private static readonly IntPtr NativeFieldInfoPtr_target;

			// Token: 0x0400580F RID: 22543
			private static readonly IntPtr NativeFieldInfoPtr_bendGoal;

			// Token: 0x04005810 RID: 22544
			private static readonly IntPtr NativeFieldInfoPtr_positionWeight;

			// Token: 0x04005811 RID: 22545
			private static readonly IntPtr NativeFieldInfoPtr_rotationWeight;

			// Token: 0x04005812 RID: 22546
			private static readonly IntPtr NativeFieldInfoPtr_shoulderRotationMode;

			// Token: 0x04005813 RID: 22547
			private static readonly IntPtr NativeFieldInfoPtr_shoulderRotationWeight;

			// Token: 0x04005814 RID: 22548
			private static readonly IntPtr NativeFieldInfoPtr_bendGoalWeight;

			// Token: 0x04005815 RID: 22549
			private static readonly IntPtr NativeFieldInfoPtr_swivelOffset;

			// Token: 0x04005816 RID: 22550
			private static readonly IntPtr NativeFieldInfoPtr_wristToPalmAxis;

			// Token: 0x04005817 RID: 22551
			private static readonly IntPtr NativeFieldInfoPtr_palmToThumbAxis;

			// Token: 0x04005818 RID: 22552
			private static readonly IntPtr NativeFieldInfoPtr_IKPosition;

			// Token: 0x04005819 RID: 22553
			private static readonly IntPtr NativeFieldInfoPtr_IKRotation;

			// Token: 0x0400581A RID: 22554
			private static readonly IntPtr NativeFieldInfoPtr_bendDirection;

			// Token: 0x0400581B RID: 22555
			private static readonly IntPtr NativeFieldInfoPtr_handPositionOffset;

			// Token: 0x0400581C RID: 22556
			private static readonly IntPtr NativeFieldInfoPtr__position_k__BackingField;

			// Token: 0x0400581D RID: 22557
			private static readonly IntPtr NativeFieldInfoPtr__rotation_k__BackingField;

			// Token: 0x0400581E RID: 22558
			private static readonly IntPtr NativeFieldInfoPtr_hasShoulder;

			// Token: 0x0400581F RID: 22559
			private static readonly IntPtr NativeFieldInfoPtr_chestForwardAxis;

			// Token: 0x04005820 RID: 22560
			private static readonly IntPtr NativeFieldInfoPtr_chestUpAxis;

			// Token: 0x04005821 RID: 22561
			private static readonly IntPtr NativeFieldInfoPtr_chestRotation;

			// Token: 0x04005822 RID: 22562
			private static readonly IntPtr NativeFieldInfoPtr_chestForward;

			// Token: 0x04005823 RID: 22563
			private static readonly IntPtr NativeFieldInfoPtr_chestUp;

			// Token: 0x04005824 RID: 22564
			private static readonly IntPtr NativeFieldInfoPtr_forearmRelToUpperArm;

			// Token: 0x04005825 RID: 22565
			private static readonly IntPtr NativeFieldInfoPtr_yawOffsetAngle;

			// Token: 0x04005826 RID: 22566
			private static readonly IntPtr NativeFieldInfoPtr_pitchOffsetAngle;

			// Token: 0x04005827 RID: 22567
			private static readonly IntPtr NativeMethodInfoPtr_get_position_Public_get_Vector3_0;

			// Token: 0x04005828 RID: 22568
			private static readonly IntPtr NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0;

			// Token: 0x04005829 RID: 22569
			private static readonly IntPtr NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0;

			// Token: 0x0400582A RID: 22570
			private static readonly IntPtr NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0;

			// Token: 0x0400582B RID: 22571
			private static readonly IntPtr NativeMethodInfoPtr_get_shoulder_Private_get_VirtualBone_0;

			// Token: 0x0400582C RID: 22572
			private static readonly IntPtr NativeMethodInfoPtr_get_upperArm_Private_get_VirtualBone_0;

			// Token: 0x0400582D RID: 22573
			private static readonly IntPtr NativeMethodInfoPtr_get_forearm_Private_get_VirtualBone_0;

			// Token: 0x0400582E RID: 22574
			private static readonly IntPtr NativeMethodInfoPtr_get_hand_Private_get_VirtualBone_0;

			// Token: 0x0400582F RID: 22575
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x04005830 RID: 22576
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0;

			// Token: 0x04005831 RID: 22577
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0;

			// Token: 0x04005832 RID: 22578
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_Boolean_0;

			// Token: 0x04005833 RID: 22579
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0;

			// Token: 0x04005834 RID: 22580
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005835 RID: 22581
			private static readonly IntPtr NativeMethodInfoPtr_DamperValue_Private_Single_Single_Single_Single_Single_0;

			// Token: 0x04005836 RID: 22582
			private static readonly IntPtr NativeMethodInfoPtr_GetBendNormal_Private_Vector3_Vector3_0;

			// Token: 0x04005837 RID: 22583
			private static readonly IntPtr NativeMethodInfoPtr_Visualize_Private_Void_VirtualBone_VirtualBone_VirtualBone_Color_0;

			// Token: 0x04005838 RID: 22584
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x02000453 RID: 1107
			[Serializable]
			public enum ShoulderRotationMode
			{
				// Token: 0x0400583A RID: 22586
				YawPitch,
				// Token: 0x0400583B RID: 22587
				FromTo
			}
		}

		// Token: 0x02000454 RID: 1108
		[Serializable]
		public class BodyPart : Il2CppSystem.Object
		{
			// Token: 0x0600840B RID: 33803 RVA: 0x0021C948 File Offset: 0x0021AB48
			[CallerCount(0)]
			public unsafe virtual void OnRead(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations, bool hasChest, bool hasNeck, bool hasShoulders, bool hasToes, int rootIndex, int index)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasChest;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasNeck;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasShoulders;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasToes;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootIndex;
				ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.BodyPart.NativeMethodInfoPtr_OnRead_Protected_Abstract_Virtual_New_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600840C RID: 33804 RVA: 0x0021CA38 File Offset: 0x0021AC38
			[CallerCount(0)]
			public unsafe virtual void PreSolve()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.BodyPart.NativeMethodInfoPtr_PreSolve_Public_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600840D RID: 33805 RVA: 0x0021CA88 File Offset: 0x0021AC88
			[CallerCount(0)]
			public unsafe virtual void Write(ref Il2CppStructArray<Vector3> solvedPositions, ref Il2CppStructArray<Quaternion> solvedRotations)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedPositions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedRotations);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.BodyPart.NativeMethodInfoPtr_Write_Public_Abstract_Virtual_New_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600840E RID: 33806 RVA: 0x0021CB08 File Offset: 0x0021AD08
			[CallerCount(0)]
			public unsafe virtual void ApplyOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.BodyPart.NativeMethodInfoPtr_ApplyOffsets_Public_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600840F RID: 33807 RVA: 0x0021CB58 File Offset: 0x0021AD58
			[CallerCount(0)]
			public unsafe virtual void ResetOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.BodyPart.NativeMethodInfoPtr_ResetOffsets_Public_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x17002CF3 RID: 11507
			// (get) Token: 0x06008410 RID: 33808 RVA: 0x0021CBA8 File Offset: 0x0021ADA8
			// (set) Token: 0x06008411 RID: 33809 RVA: 0x0021CBF8 File Offset: 0x0021ADF8
			public unsafe float sqrMag
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_get_sqrMag_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_set_sqrMag_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002CF4 RID: 11508
			// (get) Token: 0x06008412 RID: 33810 RVA: 0x0021CC4C File Offset: 0x0021AE4C
			// (set) Token: 0x06008413 RID: 33811 RVA: 0x0021CC9C File Offset: 0x0021AE9C
			public unsafe float mag
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_get_mag_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_set_mag_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008414 RID: 33812 RVA: 0x0021CCF0 File Offset: 0x0021AEF0
			[CallerCount(6)]
			[CachedScanResults(RefRangeStart = 618122, RefRangeEnd = 618128, XrefRangeStart = 618121, XrefRangeEnd = 618122, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Read(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations, bool hasChest, bool hasNeck, bool hasShoulders, bool hasToes, int rootIndex, int index)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasChest;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasNeck;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasShoulders;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasToes;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootIndex;
				ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_Read_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008415 RID: 33813 RVA: 0x0021CDD4 File Offset: 0x0021AFD4
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 618129, RefRangeEnd = 618132, XrefRangeStart = 618128, XrefRangeEnd = 618129, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void MovePosition(Vector3 position)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref position;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_MovePosition_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06008416 RID: 33814 RVA: 0x0021CE28 File Offset: 0x0021B028
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618132, XrefRangeEnd = 618134, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void MoveRotation(Quaternion rotation)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref rotation;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_MoveRotation_Public_Void_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06008417 RID: 33815 RVA: 0x0021CE7C File Offset: 0x0021B07C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618134, XrefRangeEnd = 618137, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Translate(Vector3 position, Quaternion rotation)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref position;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_Translate_Public_Void_Vector3_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008418 RID: 33816 RVA: 0x0021CEE4 File Offset: 0x0021B0E4
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 618140, RefRangeEnd = 618143, XrefRangeStart = 618137, XrefRangeEnd = 618140, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void TranslateRoot(Vector3 newRootPos, Quaternion newRootRot)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref newRootPos;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref newRootRot;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_TranslateRoot_Public_Void_Vector3_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008419 RID: 33817 RVA: 0x0021CF4C File Offset: 0x0021B14C
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 618148, RefRangeEnd = 618151, XrefRangeStart = 618143, XrefRangeEnd = 618148, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void RotateTo(IKSolverVR.VirtualBone bone, Quaternion rotation, float weight = 1f)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bone);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_RotateTo_Public_Void_VirtualBone_Quaternion_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600841A RID: 33818 RVA: 0x0021CFCC File Offset: 0x0021B1CC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618151, XrefRangeEnd = 618156, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Visualize(Color color)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref color;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_Color_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x0600841B RID: 33819 RVA: 0x0021D020 File Offset: 0x0021B220
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618156, XrefRangeEnd = 618162, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Visualize()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600841C RID: 33820 RVA: 0x0021D064 File Offset: 0x0021B264
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618162, XrefRangeEnd = 618168, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe BodyPart()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.BodyPart.NativeMethodInfoPtr__ctor_Protected_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600841D RID: 33821 RVA: 0x0021D0B0 File Offset: 0x0021B2B0
			// Note: this type is marked as 'beforefieldinit'.
			static BodyPart()
			{
				Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "BodyPart");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr);
				IKSolverVR.BodyPart.NativeFieldInfoPtr__sqrMag_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, "<sqrMag>k__BackingField");
				IKSolverVR.BodyPart.NativeFieldInfoPtr__mag_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, "<mag>k__BackingField");
				IKSolverVR.BodyPart.NativeFieldInfoPtr_bones = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, "bones");
				IKSolverVR.BodyPart.NativeFieldInfoPtr_initiated = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, "initiated");
				IKSolverVR.BodyPart.NativeFieldInfoPtr_rootPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, "rootPosition");
				IKSolverVR.BodyPart.NativeFieldInfoPtr_rootRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, "rootRotation");
				IKSolverVR.BodyPart.NativeFieldInfoPtr_index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, "index");
				IKSolverVR.BodyPart.NativeMethodInfoPtr_OnRead_Protected_Abstract_Virtual_New_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673345);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_PreSolve_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673346);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Write_Public_Abstract_Virtual_New_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673347);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_ApplyOffsets_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673348);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_ResetOffsets_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673349);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_get_sqrMag_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673350);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_set_sqrMag_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673351);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_get_mag_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673352);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_set_mag_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673353);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Read_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673354);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_MovePosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673355);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_MoveRotation_Public_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673356);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Translate_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673357);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_TranslateRoot_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673358);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_RotateTo_Public_Void_VirtualBone_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673359);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673360);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673361);
				IKSolverVR.BodyPart.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673362);
			}

			// Token: 0x0600841E RID: 33822 RVA: 0x0000A74C File Offset: 0x0000894C
			public BodyPart(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002CEC RID: 11500
			// (get) Token: 0x0600841F RID: 33823 RVA: 0x0021D2D0 File Offset: 0x0021B4D0
			// (set) Token: 0x06008420 RID: 33824 RVA: 0x0021D2F8 File Offset: 0x0021B4F8
			public unsafe float _sqrMag_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr__sqrMag_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr__sqrMag_k__BackingField)) = value;
				}
			}

			// Token: 0x17002CED RID: 11501
			// (get) Token: 0x06008421 RID: 33825 RVA: 0x0021D31C File Offset: 0x0021B51C
			// (set) Token: 0x06008422 RID: 33826 RVA: 0x0021D344 File Offset: 0x0021B544
			public unsafe float _mag_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr__mag_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr__mag_k__BackingField)) = value;
				}
			}

			// Token: 0x17002CEE RID: 11502
			// (get) Token: 0x06008423 RID: 33827 RVA: 0x0021D368 File Offset: 0x0021B568
			// (set) Token: 0x06008424 RID: 33828 RVA: 0x0021D39C File Offset: 0x0021B59C
			public unsafe Il2CppReferenceArray<IKSolverVR.VirtualBone> bones
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_bones);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppReferenceArray<IKSolverVR.VirtualBone>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_bones), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002CEF RID: 11503
			// (get) Token: 0x06008425 RID: 33829 RVA: 0x0021D3C4 File Offset: 0x0021B5C4
			// (set) Token: 0x06008426 RID: 33830 RVA: 0x0021D3EC File Offset: 0x0021B5EC
			public unsafe bool initiated
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_initiated);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_initiated)) = value;
				}
			}

			// Token: 0x17002CF0 RID: 11504
			// (get) Token: 0x06008427 RID: 33831 RVA: 0x0021D410 File Offset: 0x0021B610
			// (set) Token: 0x06008428 RID: 33832 RVA: 0x0021D438 File Offset: 0x0021B638
			public unsafe Vector3 rootPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_rootPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_rootPosition)) = value;
				}
			}

			// Token: 0x17002CF1 RID: 11505
			// (get) Token: 0x06008429 RID: 33833 RVA: 0x0021D45C File Offset: 0x0021B65C
			// (set) Token: 0x0600842A RID: 33834 RVA: 0x0021D484 File Offset: 0x0021B684
			public unsafe Quaternion rootRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_rootRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_rootRotation)) = value;
				}
			}

			// Token: 0x17002CF2 RID: 11506
			// (get) Token: 0x0600842B RID: 33835 RVA: 0x0021D4A8 File Offset: 0x0021B6A8
			// (set) Token: 0x0600842C RID: 33836 RVA: 0x0021D4D0 File Offset: 0x0021B6D0
			public unsafe int index
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_index);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.BodyPart.NativeFieldInfoPtr_index)) = value;
				}
			}

			// Token: 0x0400583C RID: 22588
			private static readonly IntPtr NativeFieldInfoPtr__sqrMag_k__BackingField;

			// Token: 0x0400583D RID: 22589
			private static readonly IntPtr NativeFieldInfoPtr__mag_k__BackingField;

			// Token: 0x0400583E RID: 22590
			private static readonly IntPtr NativeFieldInfoPtr_bones;

			// Token: 0x0400583F RID: 22591
			private static readonly IntPtr NativeFieldInfoPtr_initiated;

			// Token: 0x04005840 RID: 22592
			private static readonly IntPtr NativeFieldInfoPtr_rootPosition;

			// Token: 0x04005841 RID: 22593
			private static readonly IntPtr NativeFieldInfoPtr_rootRotation;

			// Token: 0x04005842 RID: 22594
			private static readonly IntPtr NativeFieldInfoPtr_index;

			// Token: 0x04005843 RID: 22595
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Abstract_Virtual_New_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x04005844 RID: 22596
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Abstract_Virtual_New_Void_0;

			// Token: 0x04005845 RID: 22597
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Abstract_Virtual_New_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005846 RID: 22598
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Abstract_Virtual_New_Void_0;

			// Token: 0x04005847 RID: 22599
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Abstract_Virtual_New_Void_0;

			// Token: 0x04005848 RID: 22600
			private static readonly IntPtr NativeMethodInfoPtr_get_sqrMag_Public_get_Single_0;

			// Token: 0x04005849 RID: 22601
			private static readonly IntPtr NativeMethodInfoPtr_set_sqrMag_Private_set_Void_Single_0;

			// Token: 0x0400584A RID: 22602
			private static readonly IntPtr NativeMethodInfoPtr_get_mag_Public_get_Single_0;

			// Token: 0x0400584B RID: 22603
			private static readonly IntPtr NativeMethodInfoPtr_set_mag_Private_set_Void_Single_0;

			// Token: 0x0400584C RID: 22604
			private static readonly IntPtr NativeMethodInfoPtr_Read_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x0400584D RID: 22605
			private static readonly IntPtr NativeMethodInfoPtr_MovePosition_Public_Void_Vector3_0;

			// Token: 0x0400584E RID: 22606
			private static readonly IntPtr NativeMethodInfoPtr_MoveRotation_Public_Void_Quaternion_0;

			// Token: 0x0400584F RID: 22607
			private static readonly IntPtr NativeMethodInfoPtr_Translate_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005850 RID: 22608
			private static readonly IntPtr NativeMethodInfoPtr_TranslateRoot_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005851 RID: 22609
			private static readonly IntPtr NativeMethodInfoPtr_RotateTo_Public_Void_VirtualBone_Quaternion_Single_0;

			// Token: 0x04005852 RID: 22610
			private static readonly IntPtr NativeMethodInfoPtr_Visualize_Public_Void_Color_0;

			// Token: 0x04005853 RID: 22611
			private static readonly IntPtr NativeMethodInfoPtr_Visualize_Public_Void_0;

			// Token: 0x04005854 RID: 22612
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x02000455 RID: 1109
		[Serializable]
		public class Footstep : Il2CppSystem.Object
		{
			// Token: 0x17002D03 RID: 11523
			// (get) Token: 0x0600842D RID: 33837 RVA: 0x0021D4F4 File Offset: 0x0021B6F4
			public unsafe bool isStepping
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_get_isStepping_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x17002D04 RID: 11524
			// (get) Token: 0x0600842E RID: 33838 RVA: 0x0021D544 File Offset: 0x0021B744
			// (set) Token: 0x0600842F RID: 33839 RVA: 0x0021D594 File Offset: 0x0021B794
			public unsafe float stepProgress
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_get_stepProgress_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 223890, RefRangeEnd = 223892, XrefRangeStart = 223890, XrefRangeEnd = 223892, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_set_stepProgress_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008430 RID: 33840 RVA: 0x0021D5E8 File Offset: 0x0021B7E8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618168, XrefRangeEnd = 618176, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Footstep(Quaternion rootRotation, Vector3 footPosition, Quaternion footRotation, Vector3 characterSpaceOffset)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref rootRotation;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref footPosition;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref footRotation;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref characterSpaceOffset;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr__ctor_Public_Void_Quaternion_Vector3_Quaternion_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008431 RID: 33841 RVA: 0x0021D680 File Offset: 0x0021B880
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618176, XrefRangeEnd = 618178, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Reset(Quaternion rootRotation, Vector3 footPosition, Quaternion footRotation)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref rootRotation;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref footPosition;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref footRotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_Reset_Public_Void_Quaternion_Vector3_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008432 RID: 33842 RVA: 0x0021D6FC File Offset: 0x0021B8FC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618178, XrefRangeEnd = 618179, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void StepTo(Vector3 p, Quaternion rootRotation)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref p;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootRotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_StepTo_Public_Void_Vector3_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008433 RID: 33843 RVA: 0x0021D764 File Offset: 0x0021B964
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618186, RefRangeEnd = 618187, XrefRangeStart = 618179, XrefRangeEnd = 618186, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void UpdateStepping(Vector3 p, Quaternion rootRotation, float speed)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref p;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootRotation;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref speed;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStepping_Public_Void_Vector3_Quaternion_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008434 RID: 33844 RVA: 0x0021D7E0 File Offset: 0x0021B9E0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618195, RefRangeEnd = 618196, XrefRangeStart = 618187, XrefRangeEnd = 618195, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void UpdateStanding(Quaternion rootRotation, float minAngle, float speed)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref rootRotation;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref minAngle;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref speed;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStanding_Public_Void_Quaternion_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008435 RID: 33845 RVA: 0x0021D85C File Offset: 0x0021BA5C
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618204, RefRangeEnd = 618206, XrefRangeStart = 618196, XrefRangeEnd = 618204, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Update(InterpolationMode interpolation, UnityEvent onStep)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref interpolation;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(onStep);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Footstep.NativeMethodInfoPtr_Update_Public_Void_InterpolationMode_UnityEvent_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008436 RID: 33846 RVA: 0x0021D8C8 File Offset: 0x0021BAC8
			// Note: this type is marked as 'beforefieldinit'.
			static Footstep()
			{
				Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "Footstep");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr);
				IKSolverVR.Footstep.NativeFieldInfoPtr_stepSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "stepSpeed");
				IKSolverVR.Footstep.NativeFieldInfoPtr_characterSpaceOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "characterSpaceOffset");
				IKSolverVR.Footstep.NativeFieldInfoPtr_position = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "position");
				IKSolverVR.Footstep.NativeFieldInfoPtr_rotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "rotation");
				IKSolverVR.Footstep.NativeFieldInfoPtr_stepToRootRot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "stepToRootRot");
				IKSolverVR.Footstep.NativeFieldInfoPtr_isSupportLeg = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "isSupportLeg");
				IKSolverVR.Footstep.NativeFieldInfoPtr__stepProgress_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "<stepProgress>k__BackingField");
				IKSolverVR.Footstep.NativeFieldInfoPtr_stepFrom = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "stepFrom");
				IKSolverVR.Footstep.NativeFieldInfoPtr_stepTo = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "stepTo");
				IKSolverVR.Footstep.NativeFieldInfoPtr_stepFromRot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "stepFromRot");
				IKSolverVR.Footstep.NativeFieldInfoPtr_stepToRot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "stepToRot");
				IKSolverVR.Footstep.NativeFieldInfoPtr_footRelativeToRoot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "footRelativeToRoot");
				IKSolverVR.Footstep.NativeFieldInfoPtr_supportLegW = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "supportLegW");
				IKSolverVR.Footstep.NativeFieldInfoPtr_supportLegWV = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, "supportLegWV");
				IKSolverVR.Footstep.NativeMethodInfoPtr_get_isStepping_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673363);
				IKSolverVR.Footstep.NativeMethodInfoPtr_get_stepProgress_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673364);
				IKSolverVR.Footstep.NativeMethodInfoPtr_set_stepProgress_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673365);
				IKSolverVR.Footstep.NativeMethodInfoPtr__ctor_Public_Void_Quaternion_Vector3_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673366);
				IKSolverVR.Footstep.NativeMethodInfoPtr_Reset_Public_Void_Quaternion_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673367);
				IKSolverVR.Footstep.NativeMethodInfoPtr_StepTo_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673368);
				IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStepping_Public_Void_Vector3_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673369);
				IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStanding_Public_Void_Quaternion_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673370);
				IKSolverVR.Footstep.NativeMethodInfoPtr_Update_Public_Void_InterpolationMode_UnityEvent_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673371);
			}

			// Token: 0x06008437 RID: 33847 RVA: 0x0000A74C File Offset: 0x0000894C
			public Footstep(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002CF5 RID: 11509
			// (get) Token: 0x06008438 RID: 33848 RVA: 0x0021DAC0 File Offset: 0x0021BCC0
			// (set) Token: 0x06008439 RID: 33849 RVA: 0x0021DAE8 File Offset: 0x0021BCE8
			public unsafe float stepSpeed
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepSpeed);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepSpeed)) = value;
				}
			}

			// Token: 0x17002CF6 RID: 11510
			// (get) Token: 0x0600843A RID: 33850 RVA: 0x0021DB0C File Offset: 0x0021BD0C
			// (set) Token: 0x0600843B RID: 33851 RVA: 0x0021DB34 File Offset: 0x0021BD34
			public unsafe Vector3 characterSpaceOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_characterSpaceOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_characterSpaceOffset)) = value;
				}
			}

			// Token: 0x17002CF7 RID: 11511
			// (get) Token: 0x0600843C RID: 33852 RVA: 0x0021DB58 File Offset: 0x0021BD58
			// (set) Token: 0x0600843D RID: 33853 RVA: 0x0021DB80 File Offset: 0x0021BD80
			public unsafe Vector3 position
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_position);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_position)) = value;
				}
			}

			// Token: 0x17002CF8 RID: 11512
			// (get) Token: 0x0600843E RID: 33854 RVA: 0x0021DBA4 File Offset: 0x0021BDA4
			// (set) Token: 0x0600843F RID: 33855 RVA: 0x0021DBCC File Offset: 0x0021BDCC
			public unsafe Quaternion rotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_rotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_rotation)) = value;
				}
			}

			// Token: 0x17002CF9 RID: 11513
			// (get) Token: 0x06008440 RID: 33856 RVA: 0x0021DBF0 File Offset: 0x0021BDF0
			// (set) Token: 0x06008441 RID: 33857 RVA: 0x0021DC18 File Offset: 0x0021BE18
			public unsafe Quaternion stepToRootRot
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepToRootRot);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepToRootRot)) = value;
				}
			}

			// Token: 0x17002CFA RID: 11514
			// (get) Token: 0x06008442 RID: 33858 RVA: 0x0021DC3C File Offset: 0x0021BE3C
			// (set) Token: 0x06008443 RID: 33859 RVA: 0x0021DC64 File Offset: 0x0021BE64
			public unsafe bool isSupportLeg
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_isSupportLeg);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_isSupportLeg)) = value;
				}
			}

			// Token: 0x17002CFB RID: 11515
			// (get) Token: 0x06008444 RID: 33860 RVA: 0x0021DC88 File Offset: 0x0021BE88
			// (set) Token: 0x06008445 RID: 33861 RVA: 0x0021DCB0 File Offset: 0x0021BEB0
			public unsafe float _stepProgress_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr__stepProgress_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr__stepProgress_k__BackingField)) = value;
				}
			}

			// Token: 0x17002CFC RID: 11516
			// (get) Token: 0x06008446 RID: 33862 RVA: 0x0021DCD4 File Offset: 0x0021BED4
			// (set) Token: 0x06008447 RID: 33863 RVA: 0x0021DCFC File Offset: 0x0021BEFC
			public unsafe Vector3 stepFrom
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepFrom);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepFrom)) = value;
				}
			}

			// Token: 0x17002CFD RID: 11517
			// (get) Token: 0x06008448 RID: 33864 RVA: 0x0021DD20 File Offset: 0x0021BF20
			// (set) Token: 0x06008449 RID: 33865 RVA: 0x0021DD48 File Offset: 0x0021BF48
			public unsafe Vector3 stepTo
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepTo);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepTo)) = value;
				}
			}

			// Token: 0x17002CFE RID: 11518
			// (get) Token: 0x0600844A RID: 33866 RVA: 0x0021DD6C File Offset: 0x0021BF6C
			// (set) Token: 0x0600844B RID: 33867 RVA: 0x0021DD94 File Offset: 0x0021BF94
			public unsafe Quaternion stepFromRot
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepFromRot);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepFromRot)) = value;
				}
			}

			// Token: 0x17002CFF RID: 11519
			// (get) Token: 0x0600844C RID: 33868 RVA: 0x0021DDB8 File Offset: 0x0021BFB8
			// (set) Token: 0x0600844D RID: 33869 RVA: 0x0021DDE0 File Offset: 0x0021BFE0
			public unsafe Quaternion stepToRot
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepToRot);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_stepToRot)) = value;
				}
			}

			// Token: 0x17002D00 RID: 11520
			// (get) Token: 0x0600844E RID: 33870 RVA: 0x0021DE04 File Offset: 0x0021C004
			// (set) Token: 0x0600844F RID: 33871 RVA: 0x0021DE2C File Offset: 0x0021C02C
			public unsafe Quaternion footRelativeToRoot
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_footRelativeToRoot);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_footRelativeToRoot)) = value;
				}
			}

			// Token: 0x17002D01 RID: 11521
			// (get) Token: 0x06008450 RID: 33872 RVA: 0x0021DE50 File Offset: 0x0021C050
			// (set) Token: 0x06008451 RID: 33873 RVA: 0x0021DE78 File Offset: 0x0021C078
			public unsafe float supportLegW
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_supportLegW);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_supportLegW)) = value;
				}
			}

			// Token: 0x17002D02 RID: 11522
			// (get) Token: 0x06008452 RID: 33874 RVA: 0x0021DE9C File Offset: 0x0021C09C
			// (set) Token: 0x06008453 RID: 33875 RVA: 0x0021DEC4 File Offset: 0x0021C0C4
			public unsafe float supportLegWV
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_supportLegWV);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Footstep.NativeFieldInfoPtr_supportLegWV)) = value;
				}
			}

			// Token: 0x04005855 RID: 22613
			private static readonly IntPtr NativeFieldInfoPtr_stepSpeed;

			// Token: 0x04005856 RID: 22614
			private static readonly IntPtr NativeFieldInfoPtr_characterSpaceOffset;

			// Token: 0x04005857 RID: 22615
			private static readonly IntPtr NativeFieldInfoPtr_position;

			// Token: 0x04005858 RID: 22616
			private static readonly IntPtr NativeFieldInfoPtr_rotation;

			// Token: 0x04005859 RID: 22617
			private static readonly IntPtr NativeFieldInfoPtr_stepToRootRot;

			// Token: 0x0400585A RID: 22618
			private static readonly IntPtr NativeFieldInfoPtr_isSupportLeg;

			// Token: 0x0400585B RID: 22619
			private static readonly IntPtr NativeFieldInfoPtr__stepProgress_k__BackingField;

			// Token: 0x0400585C RID: 22620
			private static readonly IntPtr NativeFieldInfoPtr_stepFrom;

			// Token: 0x0400585D RID: 22621
			private static readonly IntPtr NativeFieldInfoPtr_stepTo;

			// Token: 0x0400585E RID: 22622
			private static readonly IntPtr NativeFieldInfoPtr_stepFromRot;

			// Token: 0x0400585F RID: 22623
			private static readonly IntPtr NativeFieldInfoPtr_stepToRot;

			// Token: 0x04005860 RID: 22624
			private static readonly IntPtr NativeFieldInfoPtr_footRelativeToRoot;

			// Token: 0x04005861 RID: 22625
			private static readonly IntPtr NativeFieldInfoPtr_supportLegW;

			// Token: 0x04005862 RID: 22626
			private static readonly IntPtr NativeFieldInfoPtr_supportLegWV;

			// Token: 0x04005863 RID: 22627
			private static readonly IntPtr NativeMethodInfoPtr_get_isStepping_Public_get_Boolean_0;

			// Token: 0x04005864 RID: 22628
			private static readonly IntPtr NativeMethodInfoPtr_get_stepProgress_Public_get_Single_0;

			// Token: 0x04005865 RID: 22629
			private static readonly IntPtr NativeMethodInfoPtr_set_stepProgress_Private_set_Void_Single_0;

			// Token: 0x04005866 RID: 22630
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Quaternion_Vector3_Quaternion_Vector3_0;

			// Token: 0x04005867 RID: 22631
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_Quaternion_Vector3_Quaternion_0;

			// Token: 0x04005868 RID: 22632
			private static readonly IntPtr NativeMethodInfoPtr_StepTo_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005869 RID: 22633
			private static readonly IntPtr NativeMethodInfoPtr_UpdateStepping_Public_Void_Vector3_Quaternion_Single_0;

			// Token: 0x0400586A RID: 22634
			private static readonly IntPtr NativeMethodInfoPtr_UpdateStanding_Public_Void_Quaternion_Single_Single_0;

			// Token: 0x0400586B RID: 22635
			private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_InterpolationMode_UnityEvent_0;
		}

		// Token: 0x02000456 RID: 1110
		[Serializable]
		public class Leg : IKSolverVR.BodyPart
		{
			// Token: 0x17002D19 RID: 11545
			// (get) Token: 0x06008454 RID: 33876 RVA: 0x0021DEE8 File Offset: 0x0021C0E8
			// (set) Token: 0x06008455 RID: 33877 RVA: 0x0021DF38 File Offset: 0x0021C138
			public unsafe Vector3 position
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_position_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002D1A RID: 11546
			// (get) Token: 0x06008456 RID: 33878 RVA: 0x0021DF8C File Offset: 0x0021C18C
			// (set) Token: 0x06008457 RID: 33879 RVA: 0x0021DFDC File Offset: 0x0021C1DC
			public unsafe Quaternion rotation
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002D1B RID: 11547
			// (get) Token: 0x06008458 RID: 33880 RVA: 0x0021E030 File Offset: 0x0021C230
			// (set) Token: 0x06008459 RID: 33881 RVA: 0x0021E080 File Offset: 0x0021C280
			public unsafe bool hasToes
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_hasToes_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_set_hasToes_Private_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002D1C RID: 11548
			// (get) Token: 0x0600845A RID: 33882 RVA: 0x0021E0D4 File Offset: 0x0021C2D4
			public unsafe IKSolverVR.VirtualBone thigh
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_thigh_Public_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D1D RID: 11549
			// (get) Token: 0x0600845B RID: 33883 RVA: 0x0021E12C File Offset: 0x0021C32C
			public unsafe IKSolverVR.VirtualBone calf
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_calf_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D1E RID: 11550
			// (get) Token: 0x0600845C RID: 33884 RVA: 0x0021E184 File Offset: 0x0021C384
			public unsafe IKSolverVR.VirtualBone foot
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_foot_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D1F RID: 11551
			// (get) Token: 0x0600845D RID: 33885 RVA: 0x0021E1DC File Offset: 0x0021C3DC
			public unsafe IKSolverVR.VirtualBone toes
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_toes_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D20 RID: 11552
			// (get) Token: 0x0600845E RID: 33886 RVA: 0x0021E234 File Offset: 0x0021C434
			public unsafe IKSolverVR.VirtualBone lastBone
			{
				[CallerCount(5)]
				[CachedScanResults(RefRangeStart = 618206, RefRangeEnd = 618211, XrefRangeStart = 618206, XrefRangeEnd = 618206, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_lastBone_Public_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D21 RID: 11553
			// (get) Token: 0x0600845F RID: 33887 RVA: 0x0021E28C File Offset: 0x0021C48C
			// (set) Token: 0x06008460 RID: 33888 RVA: 0x0021E2DC File Offset: 0x0021C4DC
			public unsafe Vector3 thighRelativeToPelvis
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_get_thighRelativeToPelvis_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_set_thighRelativeToPelvis_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008461 RID: 33889 RVA: 0x0021E330 File Offset: 0x0021C530
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618211, XrefRangeEnd = 618249, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void OnRead(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations, bool hasChest, bool hasNeck, bool hasShoulders, bool hasToes, int rootIndex, int index)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasChest;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasNeck;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasShoulders;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasToes;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootIndex;
				ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Leg.NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008462 RID: 33890 RVA: 0x0021E420 File Offset: 0x0021C620
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618249, XrefRangeEnd = 618263, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void PreSolve()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Leg.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008463 RID: 33891 RVA: 0x0021E470 File Offset: 0x0021C670
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618263, XrefRangeEnd = 618283, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void ApplyOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Leg.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008464 RID: 33892 RVA: 0x0021E4C0 File Offset: 0x0021C6C0
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618283, RefRangeEnd = 618285, XrefRangeStart = 618283, XrefRangeEnd = 618283, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void ApplyPositionOffset(Vector3 offset, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref offset;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_ApplyPositionOffset_Private_Void_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008465 RID: 33893 RVA: 0x0021E528 File Offset: 0x0021C728
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618291, RefRangeEnd = 618293, XrefRangeStart = 618285, XrefRangeEnd = 618291, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void ApplyRotationOffset(Quaternion offset, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref offset;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_ApplyRotationOffset_Private_Void_Quaternion_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008466 RID: 33894 RVA: 0x0021E590 File Offset: 0x0021C790
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 618302, RefRangeEnd = 618306, XrefRangeStart = 618293, XrefRangeEnd = 618302, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Solve()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr_Solve_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008467 RID: 33895 RVA: 0x0021E5D4 File Offset: 0x0021C7D4
			[CallerCount(0)]
			public unsafe override void Write(ref Il2CppStructArray<Vector3> solvedPositions, ref Il2CppStructArray<Quaternion> solvedRotations)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedPositions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedRotations);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Leg.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008468 RID: 33896 RVA: 0x0021E654 File Offset: 0x0021C854
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618306, XrefRangeEnd = 618309, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void ResetOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Leg.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008469 RID: 33897 RVA: 0x0021E6A4 File Offset: 0x0021C8A4
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 618319, RefRangeEnd = 618322, XrefRangeStart = 618309, XrefRangeEnd = 618319, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Leg()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Leg.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600846A RID: 33898 RVA: 0x0021E6F0 File Offset: 0x0021C8F0
			// Note: this type is marked as 'beforefieldinit'.
			static Leg()
			{
				Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "Leg");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr);
				IKSolverVR.Leg.NativeFieldInfoPtr_target = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "target");
				IKSolverVR.Leg.NativeFieldInfoPtr_bendGoal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "bendGoal");
				IKSolverVR.Leg.NativeFieldInfoPtr_positionWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "positionWeight");
				IKSolverVR.Leg.NativeFieldInfoPtr_rotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "rotationWeight");
				IKSolverVR.Leg.NativeFieldInfoPtr_bendGoalWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "bendGoalWeight");
				IKSolverVR.Leg.NativeFieldInfoPtr_swivelOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "swivelOffset");
				IKSolverVR.Leg.NativeFieldInfoPtr_IKPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "IKPosition");
				IKSolverVR.Leg.NativeFieldInfoPtr_IKRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "IKRotation");
				IKSolverVR.Leg.NativeFieldInfoPtr_footPositionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "footPositionOffset");
				IKSolverVR.Leg.NativeFieldInfoPtr_heelPositionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "heelPositionOffset");
				IKSolverVR.Leg.NativeFieldInfoPtr_footRotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "footRotationOffset");
				IKSolverVR.Leg.NativeFieldInfoPtr_currentMag = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "currentMag");
				IKSolverVR.Leg.NativeFieldInfoPtr__position_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "<position>k__BackingField");
				IKSolverVR.Leg.NativeFieldInfoPtr__rotation_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "<rotation>k__BackingField");
				IKSolverVR.Leg.NativeFieldInfoPtr__hasToes_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "<hasToes>k__BackingField");
				IKSolverVR.Leg.NativeFieldInfoPtr__thighRelativeToPelvis_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "<thighRelativeToPelvis>k__BackingField");
				IKSolverVR.Leg.NativeFieldInfoPtr_footPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "footPosition");
				IKSolverVR.Leg.NativeFieldInfoPtr_footRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "footRotation");
				IKSolverVR.Leg.NativeFieldInfoPtr_bendNormal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "bendNormal");
				IKSolverVR.Leg.NativeFieldInfoPtr_calfRelToThigh = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, "calfRelToThigh");
				IKSolverVR.Leg.NativeMethodInfoPtr_get_position_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673372);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673373);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673374);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673375);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_hasToes_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673376);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_hasToes_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673377);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_thigh_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673378);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_calf_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673379);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_foot_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673380);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_toes_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673381);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_lastBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673382);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_thighRelativeToPelvis_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673383);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_thighRelativeToPelvis_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673384);
				IKSolverVR.Leg.NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673385);
				IKSolverVR.Leg.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673386);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673387);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyPositionOffset_Private_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673388);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyRotationOffset_Private_Void_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673389);
				IKSolverVR.Leg.NativeMethodInfoPtr_Solve_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673390);
				IKSolverVR.Leg.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673391);
				IKSolverVR.Leg.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673392);
				IKSolverVR.Leg.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673393);
			}

			// Token: 0x0600846B RID: 33899 RVA: 0x0021C1EB File Offset: 0x0021A3EB
			public Leg(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D05 RID: 11525
			// (get) Token: 0x0600846C RID: 33900 RVA: 0x0021EA64 File Offset: 0x0021CC64
			// (set) Token: 0x0600846D RID: 33901 RVA: 0x0021EA98 File Offset: 0x0021CC98
			public unsafe Transform target
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_target);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_target), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D06 RID: 11526
			// (get) Token: 0x0600846E RID: 33902 RVA: 0x0021EAC0 File Offset: 0x0021CCC0
			// (set) Token: 0x0600846F RID: 33903 RVA: 0x0021EAF4 File Offset: 0x0021CCF4
			public unsafe Transform bendGoal
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_bendGoal);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_bendGoal), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D07 RID: 11527
			// (get) Token: 0x06008470 RID: 33904 RVA: 0x0021EB1C File Offset: 0x0021CD1C
			// (set) Token: 0x06008471 RID: 33905 RVA: 0x0021EB44 File Offset: 0x0021CD44
			public unsafe float positionWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_positionWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_positionWeight)) = value;
				}
			}

			// Token: 0x17002D08 RID: 11528
			// (get) Token: 0x06008472 RID: 33906 RVA: 0x0021EB68 File Offset: 0x0021CD68
			// (set) Token: 0x06008473 RID: 33907 RVA: 0x0021EB90 File Offset: 0x0021CD90
			public unsafe float rotationWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_rotationWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_rotationWeight)) = value;
				}
			}

			// Token: 0x17002D09 RID: 11529
			// (get) Token: 0x06008474 RID: 33908 RVA: 0x0021EBB4 File Offset: 0x0021CDB4
			// (set) Token: 0x06008475 RID: 33909 RVA: 0x0021EBDC File Offset: 0x0021CDDC
			public unsafe float bendGoalWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_bendGoalWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_bendGoalWeight)) = value;
				}
			}

			// Token: 0x17002D0A RID: 11530
			// (get) Token: 0x06008476 RID: 33910 RVA: 0x0021EC00 File Offset: 0x0021CE00
			// (set) Token: 0x06008477 RID: 33911 RVA: 0x0021EC28 File Offset: 0x0021CE28
			public unsafe float swivelOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_swivelOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_swivelOffset)) = value;
				}
			}

			// Token: 0x17002D0B RID: 11531
			// (get) Token: 0x06008478 RID: 33912 RVA: 0x0021EC4C File Offset: 0x0021CE4C
			// (set) Token: 0x06008479 RID: 33913 RVA: 0x0021EC74 File Offset: 0x0021CE74
			public unsafe Vector3 IKPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_IKPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_IKPosition)) = value;
				}
			}

			// Token: 0x17002D0C RID: 11532
			// (get) Token: 0x0600847A RID: 33914 RVA: 0x0021EC98 File Offset: 0x0021CE98
			// (set) Token: 0x0600847B RID: 33915 RVA: 0x0021ECC0 File Offset: 0x0021CEC0
			public unsafe Quaternion IKRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_IKRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_IKRotation)) = value;
				}
			}

			// Token: 0x17002D0D RID: 11533
			// (get) Token: 0x0600847C RID: 33916 RVA: 0x0021ECE4 File Offset: 0x0021CEE4
			// (set) Token: 0x0600847D RID: 33917 RVA: 0x0021ED0C File Offset: 0x0021CF0C
			public unsafe Vector3 footPositionOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footPositionOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footPositionOffset)) = value;
				}
			}

			// Token: 0x17002D0E RID: 11534
			// (get) Token: 0x0600847E RID: 33918 RVA: 0x0021ED30 File Offset: 0x0021CF30
			// (set) Token: 0x0600847F RID: 33919 RVA: 0x0021ED58 File Offset: 0x0021CF58
			public unsafe Vector3 heelPositionOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_heelPositionOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_heelPositionOffset)) = value;
				}
			}

			// Token: 0x17002D0F RID: 11535
			// (get) Token: 0x06008480 RID: 33920 RVA: 0x0021ED7C File Offset: 0x0021CF7C
			// (set) Token: 0x06008481 RID: 33921 RVA: 0x0021EDA4 File Offset: 0x0021CFA4
			public unsafe Quaternion footRotationOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footRotationOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footRotationOffset)) = value;
				}
			}

			// Token: 0x17002D10 RID: 11536
			// (get) Token: 0x06008482 RID: 33922 RVA: 0x0021EDC8 File Offset: 0x0021CFC8
			// (set) Token: 0x06008483 RID: 33923 RVA: 0x0021EDF0 File Offset: 0x0021CFF0
			public unsafe float currentMag
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_currentMag);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_currentMag)) = value;
				}
			}

			// Token: 0x17002D11 RID: 11537
			// (get) Token: 0x06008484 RID: 33924 RVA: 0x0021EE14 File Offset: 0x0021D014
			// (set) Token: 0x06008485 RID: 33925 RVA: 0x0021EE3C File Offset: 0x0021D03C
			public unsafe Vector3 _position_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__position_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__position_k__BackingField)) = value;
				}
			}

			// Token: 0x17002D12 RID: 11538
			// (get) Token: 0x06008486 RID: 33926 RVA: 0x0021EE60 File Offset: 0x0021D060
			// (set) Token: 0x06008487 RID: 33927 RVA: 0x0021EE88 File Offset: 0x0021D088
			public unsafe Quaternion _rotation_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__rotation_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__rotation_k__BackingField)) = value;
				}
			}

			// Token: 0x17002D13 RID: 11539
			// (get) Token: 0x06008488 RID: 33928 RVA: 0x0021EEAC File Offset: 0x0021D0AC
			// (set) Token: 0x06008489 RID: 33929 RVA: 0x0021EED4 File Offset: 0x0021D0D4
			public unsafe bool _hasToes_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__hasToes_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__hasToes_k__BackingField)) = value;
				}
			}

			// Token: 0x17002D14 RID: 11540
			// (get) Token: 0x0600848A RID: 33930 RVA: 0x0021EEF8 File Offset: 0x0021D0F8
			// (set) Token: 0x0600848B RID: 33931 RVA: 0x0021EF20 File Offset: 0x0021D120
			public unsafe Vector3 _thighRelativeToPelvis_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__thighRelativeToPelvis_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr__thighRelativeToPelvis_k__BackingField)) = value;
				}
			}

			// Token: 0x17002D15 RID: 11541
			// (get) Token: 0x0600848C RID: 33932 RVA: 0x0021EF44 File Offset: 0x0021D144
			// (set) Token: 0x0600848D RID: 33933 RVA: 0x0021EF6C File Offset: 0x0021D16C
			public unsafe Vector3 footPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footPosition)) = value;
				}
			}

			// Token: 0x17002D16 RID: 11542
			// (get) Token: 0x0600848E RID: 33934 RVA: 0x0021EF90 File Offset: 0x0021D190
			// (set) Token: 0x0600848F RID: 33935 RVA: 0x0021EFB8 File Offset: 0x0021D1B8
			public unsafe Quaternion footRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_footRotation)) = value;
				}
			}

			// Token: 0x17002D17 RID: 11543
			// (get) Token: 0x06008490 RID: 33936 RVA: 0x0021EFDC File Offset: 0x0021D1DC
			// (set) Token: 0x06008491 RID: 33937 RVA: 0x0021F004 File Offset: 0x0021D204
			public unsafe Vector3 bendNormal
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_bendNormal);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_bendNormal)) = value;
				}
			}

			// Token: 0x17002D18 RID: 11544
			// (get) Token: 0x06008492 RID: 33938 RVA: 0x0021F028 File Offset: 0x0021D228
			// (set) Token: 0x06008493 RID: 33939 RVA: 0x0021F050 File Offset: 0x0021D250
			public unsafe Quaternion calfRelToThigh
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_calfRelToThigh);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Leg.NativeFieldInfoPtr_calfRelToThigh)) = value;
				}
			}

			// Token: 0x0400586C RID: 22636
			private static readonly IntPtr NativeFieldInfoPtr_target;

			// Token: 0x0400586D RID: 22637
			private static readonly IntPtr NativeFieldInfoPtr_bendGoal;

			// Token: 0x0400586E RID: 22638
			private static readonly IntPtr NativeFieldInfoPtr_positionWeight;

			// Token: 0x0400586F RID: 22639
			private static readonly IntPtr NativeFieldInfoPtr_rotationWeight;

			// Token: 0x04005870 RID: 22640
			private static readonly IntPtr NativeFieldInfoPtr_bendGoalWeight;

			// Token: 0x04005871 RID: 22641
			private static readonly IntPtr NativeFieldInfoPtr_swivelOffset;

			// Token: 0x04005872 RID: 22642
			private static readonly IntPtr NativeFieldInfoPtr_IKPosition;

			// Token: 0x04005873 RID: 22643
			private static readonly IntPtr NativeFieldInfoPtr_IKRotation;

			// Token: 0x04005874 RID: 22644
			private static readonly IntPtr NativeFieldInfoPtr_footPositionOffset;

			// Token: 0x04005875 RID: 22645
			private static readonly IntPtr NativeFieldInfoPtr_heelPositionOffset;

			// Token: 0x04005876 RID: 22646
			private static readonly IntPtr NativeFieldInfoPtr_footRotationOffset;

			// Token: 0x04005877 RID: 22647
			private static readonly IntPtr NativeFieldInfoPtr_currentMag;

			// Token: 0x04005878 RID: 22648
			private static readonly IntPtr NativeFieldInfoPtr__position_k__BackingField;

			// Token: 0x04005879 RID: 22649
			private static readonly IntPtr NativeFieldInfoPtr__rotation_k__BackingField;

			// Token: 0x0400587A RID: 22650
			private static readonly IntPtr NativeFieldInfoPtr__hasToes_k__BackingField;

			// Token: 0x0400587B RID: 22651
			private static readonly IntPtr NativeFieldInfoPtr__thighRelativeToPelvis_k__BackingField;

			// Token: 0x0400587C RID: 22652
			private static readonly IntPtr NativeFieldInfoPtr_footPosition;

			// Token: 0x0400587D RID: 22653
			private static readonly IntPtr NativeFieldInfoPtr_footRotation;

			// Token: 0x0400587E RID: 22654
			private static readonly IntPtr NativeFieldInfoPtr_bendNormal;

			// Token: 0x0400587F RID: 22655
			private static readonly IntPtr NativeFieldInfoPtr_calfRelToThigh;

			// Token: 0x04005880 RID: 22656
			private static readonly IntPtr NativeMethodInfoPtr_get_position_Public_get_Vector3_0;

			// Token: 0x04005881 RID: 22657
			private static readonly IntPtr NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0;

			// Token: 0x04005882 RID: 22658
			private static readonly IntPtr NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0;

			// Token: 0x04005883 RID: 22659
			private static readonly IntPtr NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0;

			// Token: 0x04005884 RID: 22660
			private static readonly IntPtr NativeMethodInfoPtr_get_hasToes_Public_get_Boolean_0;

			// Token: 0x04005885 RID: 22661
			private static readonly IntPtr NativeMethodInfoPtr_set_hasToes_Private_set_Void_Boolean_0;

			// Token: 0x04005886 RID: 22662
			private static readonly IntPtr NativeMethodInfoPtr_get_thigh_Public_get_VirtualBone_0;

			// Token: 0x04005887 RID: 22663
			private static readonly IntPtr NativeMethodInfoPtr_get_calf_Private_get_VirtualBone_0;

			// Token: 0x04005888 RID: 22664
			private static readonly IntPtr NativeMethodInfoPtr_get_foot_Private_get_VirtualBone_0;

			// Token: 0x04005889 RID: 22665
			private static readonly IntPtr NativeMethodInfoPtr_get_toes_Private_get_VirtualBone_0;

			// Token: 0x0400588A RID: 22666
			private static readonly IntPtr NativeMethodInfoPtr_get_lastBone_Public_get_VirtualBone_0;

			// Token: 0x0400588B RID: 22667
			private static readonly IntPtr NativeMethodInfoPtr_get_thighRelativeToPelvis_Public_get_Vector3_0;

			// Token: 0x0400588C RID: 22668
			private static readonly IntPtr NativeMethodInfoPtr_set_thighRelativeToPelvis_Private_set_Void_Vector3_0;

			// Token: 0x0400588D RID: 22669
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x0400588E RID: 22670
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0;

			// Token: 0x0400588F RID: 22671
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0;

			// Token: 0x04005890 RID: 22672
			private static readonly IntPtr NativeMethodInfoPtr_ApplyPositionOffset_Private_Void_Vector3_Single_0;

			// Token: 0x04005891 RID: 22673
			private static readonly IntPtr NativeMethodInfoPtr_ApplyRotationOffset_Private_Void_Quaternion_Single_0;

			// Token: 0x04005892 RID: 22674
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_0;

			// Token: 0x04005893 RID: 22675
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005894 RID: 22676
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0;

			// Token: 0x04005895 RID: 22677
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x02000457 RID: 1111
		[Serializable]
		public class Locomotion : Il2CppSystem.Object
		{
			// Token: 0x17002D3E RID: 11582
			// (get) Token: 0x06008494 RID: 33940 RVA: 0x0021F074 File Offset: 0x0021D274
			// (set) Token: 0x06008495 RID: 33941 RVA: 0x0021F0C4 File Offset: 0x0021D2C4
			public unsafe Vector3 centerOfMass
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_get_centerOfMass_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_set_centerOfMass_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008496 RID: 33942 RVA: 0x0021F118 File Offset: 0x0021D318
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618374, RefRangeEnd = 618375, XrefRangeStart = 618322, XrefRangeEnd = 618374, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Initiate(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations, bool hasToes)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasToes;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_Initiate_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008497 RID: 33943 RVA: 0x0021F19C File Offset: 0x0021D39C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618382, RefRangeEnd = 618383, XrefRangeStart = 618375, XrefRangeEnd = 618382, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Reset(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_Reset_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008498 RID: 33944 RVA: 0x0021F210 File Offset: 0x0021D410
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618392, RefRangeEnd = 618393, XrefRangeStart = 618383, XrefRangeEnd = 618392, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void AddDeltaRotation(Quaternion delta, Vector3 pivot)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref delta;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pivot;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaRotation_Public_Void_Quaternion_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008499 RID: 33945 RVA: 0x0021F278 File Offset: 0x0021D478
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618394, RefRangeEnd = 618395, XrefRangeStart = 618393, XrefRangeEnd = 618394, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void AddDeltaPosition(Vector3 delta)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref delta;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaPosition_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x0600849A RID: 33946 RVA: 0x0021F2CC File Offset: 0x0021D4CC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618454, RefRangeEnd = 618455, XrefRangeStart = 618395, XrefRangeEnd = 618454, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Solve(IKSolverVR.VirtualBone rootBone, IKSolverVR.Spine spine, IKSolverVR.Leg leftLeg, IKSolverVR.Leg rightLeg, IKSolverVR.Arm leftArm, IKSolverVR.Arm rightArm, int supportLegIndex, out Vector3 leftFootPosition, out Vector3 rightFootPosition, out Quaternion leftFootRotation, out Quaternion rightFootRotation, out float leftFootOffset, out float rightFootOffset, out float leftHeelOffset, out float rightHeelOffset)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)15) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(rootBone);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(spine);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(leftLeg);
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rightLeg);
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(leftArm);
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rightArm);
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref supportLegIndex;
				ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &leftFootPosition;
				ptr[checked(unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &rightFootPosition;
				ptr[checked(unchecked((UIntPtr)9) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &leftFootRotation;
				ptr[checked(unchecked((UIntPtr)10) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &rightFootRotation;
				ptr[checked(unchecked((UIntPtr)11) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &leftFootOffset;
				ptr[checked(unchecked((UIntPtr)12) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &rightFootOffset;
				ptr[checked(unchecked((UIntPtr)13) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &leftHeelOffset;
				ptr[checked(unchecked((UIntPtr)14) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = &rightHeelOffset;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Spine_Leg_Leg_Arm_Arm_Int32_byref_Vector3_byref_Vector3_byref_Quaternion_byref_Quaternion_byref_Single_byref_Single_byref_Single_byref_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x17002D3F RID: 11583
			// (get) Token: 0x0600849B RID: 33947 RVA: 0x0021F458 File Offset: 0x0021D658
			public unsafe Vector3 leftFootstepPosition
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepPosition_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x17002D40 RID: 11584
			// (get) Token: 0x0600849C RID: 33948 RVA: 0x0021F4A8 File Offset: 0x0021D6A8
			public unsafe Vector3 rightFootstepPosition
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepPosition_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x17002D41 RID: 11585
			// (get) Token: 0x0600849D RID: 33949 RVA: 0x0021F4F8 File Offset: 0x0021D6F8
			public unsafe Quaternion leftFootstepRotation
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepRotation_Public_get_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x17002D42 RID: 11586
			// (get) Token: 0x0600849E RID: 33950 RVA: 0x0021F548 File Offset: 0x0021D748
			public unsafe Quaternion rightFootstepRotation
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepRotation_Public_get_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x0600849F RID: 33951 RVA: 0x0021F598 File Offset: 0x0021D798
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618459, RefRangeEnd = 618461, XrefRangeStart = 618455, XrefRangeEnd = 618459, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe bool StepBlocked(Vector3 fromPosition, Vector3 toPosition, Vector3 rootPosition)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref fromPosition;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref toPosition;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootPosition;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_StepBlocked_Private_Boolean_Vector3_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x060084A0 RID: 33952 RVA: 0x0021F620 File Offset: 0x0021D820
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618461, XrefRangeEnd = 618462, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe bool CanStep()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_CanStep_Private_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x060084A1 RID: 33953 RVA: 0x0021F670 File Offset: 0x0021D870
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618469, RefRangeEnd = 618470, XrefRangeStart = 618462, XrefRangeEnd = 618469, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static bool GetLineSphereCollision(Vector3 lineStart, Vector3 lineEnd, Vector3 sphereCenter, float sphereRadius)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref lineStart;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lineEnd;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sphereCenter;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sphereRadius;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr_GetLineSphereCollision_Private_Static_Boolean_Vector3_Vector3_Vector3_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x060084A2 RID: 33954 RVA: 0x0021F6FC File Offset: 0x0021D8FC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618484, RefRangeEnd = 618485, XrefRangeStart = 618470, XrefRangeEnd = 618484, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Locomotion()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Locomotion.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084A3 RID: 33955 RVA: 0x0021F748 File Offset: 0x0021D948
			// Note: this type is marked as 'beforefieldinit'.
			static Locomotion()
			{
				Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "Locomotion");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr);
				IKSolverVR.Locomotion.NativeFieldInfoPtr_weight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "weight");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_footDistance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "footDistance");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_stepThreshold = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "stepThreshold");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_angleThreshold = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "angleThreshold");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_comAngleMlp = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "comAngleMlp");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_maxVelocity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "maxVelocity");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_velocityFactor = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "velocityFactor");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_maxLegStretch = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "maxLegStretch");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_rootSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "rootSpeed");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_stepSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "stepSpeed");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_stepHeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "stepHeight");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_heelHeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "heelHeight");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_relaxLegTwistMinAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "relaxLegTwistMinAngle");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_relaxLegTwistSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "relaxLegTwistSpeed");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_stepInterpolation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "stepInterpolation");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_offset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "offset");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_blockingEnabled = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "blockingEnabled");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_blockingLayers = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "blockingLayers");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_raycastRadius = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "raycastRadius");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_raycastHeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "raycastHeight");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_onLeftFootstep = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "onLeftFootstep");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_onRightFootstep = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "onRightFootstep");
				IKSolverVR.Locomotion.NativeFieldInfoPtr__centerOfMass_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "<centerOfMass>k__BackingField");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_footsteps = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "footsteps");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_lastComPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "lastComPosition");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_comVelocity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "comVelocity");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_leftFootIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "leftFootIndex");
				IKSolverVR.Locomotion.NativeFieldInfoPtr_rightFootIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, "rightFootIndex");
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_centerOfMass_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673394);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_set_centerOfMass_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673395);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_Initiate_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673396);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_Reset_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673397);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaRotation_Public_Void_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673398);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaPosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673399);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Spine_Leg_Leg_Arm_Arm_Int32_byref_Vector3_byref_Vector3_byref_Quaternion_byref_Quaternion_byref_Single_byref_Single_byref_Single_byref_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673400);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673401);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673402);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673403);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673404);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_StepBlocked_Private_Boolean_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673405);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_CanStep_Private_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673406);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_GetLineSphereCollision_Private_Static_Boolean_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673407);
				IKSolverVR.Locomotion.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673408);
			}

			// Token: 0x060084A4 RID: 33956 RVA: 0x0000A74C File Offset: 0x0000894C
			public Locomotion(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D22 RID: 11554
			// (get) Token: 0x060084A5 RID: 33957 RVA: 0x0021FAD0 File Offset: 0x0021DCD0
			// (set) Token: 0x060084A6 RID: 33958 RVA: 0x0021FAF8 File Offset: 0x0021DCF8
			public unsafe float weight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_weight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_weight)) = value;
				}
			}

			// Token: 0x17002D23 RID: 11555
			// (get) Token: 0x060084A7 RID: 33959 RVA: 0x0021FB1C File Offset: 0x0021DD1C
			// (set) Token: 0x060084A8 RID: 33960 RVA: 0x0021FB44 File Offset: 0x0021DD44
			public unsafe float footDistance
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_footDistance);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_footDistance)) = value;
				}
			}

			// Token: 0x17002D24 RID: 11556
			// (get) Token: 0x060084A9 RID: 33961 RVA: 0x0021FB68 File Offset: 0x0021DD68
			// (set) Token: 0x060084AA RID: 33962 RVA: 0x0021FB90 File Offset: 0x0021DD90
			public unsafe float stepThreshold
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepThreshold);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepThreshold)) = value;
				}
			}

			// Token: 0x17002D25 RID: 11557
			// (get) Token: 0x060084AB RID: 33963 RVA: 0x0021FBB4 File Offset: 0x0021DDB4
			// (set) Token: 0x060084AC RID: 33964 RVA: 0x0021FBDC File Offset: 0x0021DDDC
			public unsafe float angleThreshold
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_angleThreshold);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_angleThreshold)) = value;
				}
			}

			// Token: 0x17002D26 RID: 11558
			// (get) Token: 0x060084AD RID: 33965 RVA: 0x0021FC00 File Offset: 0x0021DE00
			// (set) Token: 0x060084AE RID: 33966 RVA: 0x0021FC28 File Offset: 0x0021DE28
			public unsafe float comAngleMlp
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_comAngleMlp);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_comAngleMlp)) = value;
				}
			}

			// Token: 0x17002D27 RID: 11559
			// (get) Token: 0x060084AF RID: 33967 RVA: 0x0021FC4C File Offset: 0x0021DE4C
			// (set) Token: 0x060084B0 RID: 33968 RVA: 0x0021FC74 File Offset: 0x0021DE74
			public unsafe float maxVelocity
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_maxVelocity);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_maxVelocity)) = value;
				}
			}

			// Token: 0x17002D28 RID: 11560
			// (get) Token: 0x060084B1 RID: 33969 RVA: 0x0021FC98 File Offset: 0x0021DE98
			// (set) Token: 0x060084B2 RID: 33970 RVA: 0x0021FCC0 File Offset: 0x0021DEC0
			public unsafe float velocityFactor
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_velocityFactor);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_velocityFactor)) = value;
				}
			}

			// Token: 0x17002D29 RID: 11561
			// (get) Token: 0x060084B3 RID: 33971 RVA: 0x0021FCE4 File Offset: 0x0021DEE4
			// (set) Token: 0x060084B4 RID: 33972 RVA: 0x0021FD0C File Offset: 0x0021DF0C
			public unsafe float maxLegStretch
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_maxLegStretch);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_maxLegStretch)) = value;
				}
			}

			// Token: 0x17002D2A RID: 11562
			// (get) Token: 0x060084B5 RID: 33973 RVA: 0x0021FD30 File Offset: 0x0021DF30
			// (set) Token: 0x060084B6 RID: 33974 RVA: 0x0021FD58 File Offset: 0x0021DF58
			public unsafe float rootSpeed
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_rootSpeed);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_rootSpeed)) = value;
				}
			}

			// Token: 0x17002D2B RID: 11563
			// (get) Token: 0x060084B7 RID: 33975 RVA: 0x0021FD7C File Offset: 0x0021DF7C
			// (set) Token: 0x060084B8 RID: 33976 RVA: 0x0021FDA4 File Offset: 0x0021DFA4
			public unsafe float stepSpeed
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepSpeed);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepSpeed)) = value;
				}
			}

			// Token: 0x17002D2C RID: 11564
			// (get) Token: 0x060084B9 RID: 33977 RVA: 0x0021FDC8 File Offset: 0x0021DFC8
			// (set) Token: 0x060084BA RID: 33978 RVA: 0x0021FDFC File Offset: 0x0021DFFC
			public unsafe AnimationCurve stepHeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepHeight);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new AnimationCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepHeight), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D2D RID: 11565
			// (get) Token: 0x060084BB RID: 33979 RVA: 0x0021FE24 File Offset: 0x0021E024
			// (set) Token: 0x060084BC RID: 33980 RVA: 0x0021FE58 File Offset: 0x0021E058
			public unsafe AnimationCurve heelHeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_heelHeight);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new AnimationCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_heelHeight), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D2E RID: 11566
			// (get) Token: 0x060084BD RID: 33981 RVA: 0x0021FE80 File Offset: 0x0021E080
			// (set) Token: 0x060084BE RID: 33982 RVA: 0x0021FEA8 File Offset: 0x0021E0A8
			public unsafe float relaxLegTwistMinAngle
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_relaxLegTwistMinAngle);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_relaxLegTwistMinAngle)) = value;
				}
			}

			// Token: 0x17002D2F RID: 11567
			// (get) Token: 0x060084BF RID: 33983 RVA: 0x0021FECC File Offset: 0x0021E0CC
			// (set) Token: 0x060084C0 RID: 33984 RVA: 0x0021FEF4 File Offset: 0x0021E0F4
			public unsafe float relaxLegTwistSpeed
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_relaxLegTwistSpeed);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_relaxLegTwistSpeed)) = value;
				}
			}

			// Token: 0x17002D30 RID: 11568
			// (get) Token: 0x060084C1 RID: 33985 RVA: 0x0021FF18 File Offset: 0x0021E118
			// (set) Token: 0x060084C2 RID: 33986 RVA: 0x0021FF40 File Offset: 0x0021E140
			public unsafe InterpolationMode stepInterpolation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepInterpolation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_stepInterpolation)) = value;
				}
			}

			// Token: 0x17002D31 RID: 11569
			// (get) Token: 0x060084C3 RID: 33987 RVA: 0x0021FF64 File Offset: 0x0021E164
			// (set) Token: 0x060084C4 RID: 33988 RVA: 0x0021FF8C File Offset: 0x0021E18C
			public unsafe Vector3 offset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_offset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_offset)) = value;
				}
			}

			// Token: 0x17002D32 RID: 11570
			// (get) Token: 0x060084C5 RID: 33989 RVA: 0x0021FFB0 File Offset: 0x0021E1B0
			// (set) Token: 0x060084C6 RID: 33990 RVA: 0x0021FFD8 File Offset: 0x0021E1D8
			public unsafe bool blockingEnabled
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_blockingEnabled);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_blockingEnabled)) = value;
				}
			}

			// Token: 0x17002D33 RID: 11571
			// (get) Token: 0x060084C7 RID: 33991 RVA: 0x0021FFFC File Offset: 0x0021E1FC
			// (set) Token: 0x060084C8 RID: 33992 RVA: 0x00220024 File Offset: 0x0021E224
			public unsafe LayerMask blockingLayers
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_blockingLayers);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_blockingLayers)) = value;
				}
			}

			// Token: 0x17002D34 RID: 11572
			// (get) Token: 0x060084C9 RID: 33993 RVA: 0x00220048 File Offset: 0x0021E248
			// (set) Token: 0x060084CA RID: 33994 RVA: 0x00220070 File Offset: 0x0021E270
			public unsafe float raycastRadius
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_raycastRadius);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_raycastRadius)) = value;
				}
			}

			// Token: 0x17002D35 RID: 11573
			// (get) Token: 0x060084CB RID: 33995 RVA: 0x00220094 File Offset: 0x0021E294
			// (set) Token: 0x060084CC RID: 33996 RVA: 0x002200BC File Offset: 0x0021E2BC
			public unsafe float raycastHeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_raycastHeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_raycastHeight)) = value;
				}
			}

			// Token: 0x17002D36 RID: 11574
			// (get) Token: 0x060084CD RID: 33997 RVA: 0x002200E0 File Offset: 0x0021E2E0
			// (set) Token: 0x060084CE RID: 33998 RVA: 0x00220114 File Offset: 0x0021E314
			public unsafe UnityEvent onLeftFootstep
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_onLeftFootstep);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new UnityEvent(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_onLeftFootstep), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D37 RID: 11575
			// (get) Token: 0x060084CF RID: 33999 RVA: 0x0022013C File Offset: 0x0021E33C
			// (set) Token: 0x060084D0 RID: 34000 RVA: 0x00220170 File Offset: 0x0021E370
			public unsafe UnityEvent onRightFootstep
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_onRightFootstep);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new UnityEvent(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_onRightFootstep), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D38 RID: 11576
			// (get) Token: 0x060084D1 RID: 34001 RVA: 0x00220198 File Offset: 0x0021E398
			// (set) Token: 0x060084D2 RID: 34002 RVA: 0x002201C0 File Offset: 0x0021E3C0
			public unsafe Vector3 _centerOfMass_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr__centerOfMass_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr__centerOfMass_k__BackingField)) = value;
				}
			}

			// Token: 0x17002D39 RID: 11577
			// (get) Token: 0x060084D3 RID: 34003 RVA: 0x002201E4 File Offset: 0x0021E3E4
			// (set) Token: 0x060084D4 RID: 34004 RVA: 0x00220218 File Offset: 0x0021E418
			public unsafe Il2CppReferenceArray<IKSolverVR.Footstep> footsteps
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_footsteps);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppReferenceArray<IKSolverVR.Footstep>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_footsteps), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D3A RID: 11578
			// (get) Token: 0x060084D5 RID: 34005 RVA: 0x00220240 File Offset: 0x0021E440
			// (set) Token: 0x060084D6 RID: 34006 RVA: 0x00220268 File Offset: 0x0021E468
			public unsafe Vector3 lastComPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_lastComPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_lastComPosition)) = value;
				}
			}

			// Token: 0x17002D3B RID: 11579
			// (get) Token: 0x060084D7 RID: 34007 RVA: 0x0022028C File Offset: 0x0021E48C
			// (set) Token: 0x060084D8 RID: 34008 RVA: 0x002202B4 File Offset: 0x0021E4B4
			public unsafe Vector3 comVelocity
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_comVelocity);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_comVelocity)) = value;
				}
			}

			// Token: 0x17002D3C RID: 11580
			// (get) Token: 0x060084D9 RID: 34009 RVA: 0x002202D8 File Offset: 0x0021E4D8
			// (set) Token: 0x060084DA RID: 34010 RVA: 0x00220300 File Offset: 0x0021E500
			public unsafe int leftFootIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_leftFootIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_leftFootIndex)) = value;
				}
			}

			// Token: 0x17002D3D RID: 11581
			// (get) Token: 0x060084DB RID: 34011 RVA: 0x00220324 File Offset: 0x0021E524
			// (set) Token: 0x060084DC RID: 34012 RVA: 0x0022034C File Offset: 0x0021E54C
			public unsafe int rightFootIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_rightFootIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Locomotion.NativeFieldInfoPtr_rightFootIndex)) = value;
				}
			}

			// Token: 0x04005896 RID: 22678
			private static readonly IntPtr NativeFieldInfoPtr_weight;

			// Token: 0x04005897 RID: 22679
			private static readonly IntPtr NativeFieldInfoPtr_footDistance;

			// Token: 0x04005898 RID: 22680
			private static readonly IntPtr NativeFieldInfoPtr_stepThreshold;

			// Token: 0x04005899 RID: 22681
			private static readonly IntPtr NativeFieldInfoPtr_angleThreshold;

			// Token: 0x0400589A RID: 22682
			private static readonly IntPtr NativeFieldInfoPtr_comAngleMlp;

			// Token: 0x0400589B RID: 22683
			private static readonly IntPtr NativeFieldInfoPtr_maxVelocity;

			// Token: 0x0400589C RID: 22684
			private static readonly IntPtr NativeFieldInfoPtr_velocityFactor;

			// Token: 0x0400589D RID: 22685
			private static readonly IntPtr NativeFieldInfoPtr_maxLegStretch;

			// Token: 0x0400589E RID: 22686
			private static readonly IntPtr NativeFieldInfoPtr_rootSpeed;

			// Token: 0x0400589F RID: 22687
			private static readonly IntPtr NativeFieldInfoPtr_stepSpeed;

			// Token: 0x040058A0 RID: 22688
			private static readonly IntPtr NativeFieldInfoPtr_stepHeight;

			// Token: 0x040058A1 RID: 22689
			private static readonly IntPtr NativeFieldInfoPtr_heelHeight;

			// Token: 0x040058A2 RID: 22690
			private static readonly IntPtr NativeFieldInfoPtr_relaxLegTwistMinAngle;

			// Token: 0x040058A3 RID: 22691
			private static readonly IntPtr NativeFieldInfoPtr_relaxLegTwistSpeed;

			// Token: 0x040058A4 RID: 22692
			private static readonly IntPtr NativeFieldInfoPtr_stepInterpolation;

			// Token: 0x040058A5 RID: 22693
			private static readonly IntPtr NativeFieldInfoPtr_offset;

			// Token: 0x040058A6 RID: 22694
			private static readonly IntPtr NativeFieldInfoPtr_blockingEnabled;

			// Token: 0x040058A7 RID: 22695
			private static readonly IntPtr NativeFieldInfoPtr_blockingLayers;

			// Token: 0x040058A8 RID: 22696
			private static readonly IntPtr NativeFieldInfoPtr_raycastRadius;

			// Token: 0x040058A9 RID: 22697
			private static readonly IntPtr NativeFieldInfoPtr_raycastHeight;

			// Token: 0x040058AA RID: 22698
			private static readonly IntPtr NativeFieldInfoPtr_onLeftFootstep;

			// Token: 0x040058AB RID: 22699
			private static readonly IntPtr NativeFieldInfoPtr_onRightFootstep;

			// Token: 0x040058AC RID: 22700
			private static readonly IntPtr NativeFieldInfoPtr__centerOfMass_k__BackingField;

			// Token: 0x040058AD RID: 22701
			private static readonly IntPtr NativeFieldInfoPtr_footsteps;

			// Token: 0x040058AE RID: 22702
			private static readonly IntPtr NativeFieldInfoPtr_lastComPosition;

			// Token: 0x040058AF RID: 22703
			private static readonly IntPtr NativeFieldInfoPtr_comVelocity;

			// Token: 0x040058B0 RID: 22704
			private static readonly IntPtr NativeFieldInfoPtr_leftFootIndex;

			// Token: 0x040058B1 RID: 22705
			private static readonly IntPtr NativeFieldInfoPtr_rightFootIndex;

			// Token: 0x040058B2 RID: 22706
			private static readonly IntPtr NativeMethodInfoPtr_get_centerOfMass_Public_get_Vector3_0;

			// Token: 0x040058B3 RID: 22707
			private static readonly IntPtr NativeMethodInfoPtr_set_centerOfMass_Private_set_Void_Vector3_0;

			// Token: 0x040058B4 RID: 22708
			private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_0;

			// Token: 0x040058B5 RID: 22709
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x040058B6 RID: 22710
			private static readonly IntPtr NativeMethodInfoPtr_AddDeltaRotation_Public_Void_Quaternion_Vector3_0;

			// Token: 0x040058B7 RID: 22711
			private static readonly IntPtr NativeMethodInfoPtr_AddDeltaPosition_Public_Void_Vector3_0;

			// Token: 0x040058B8 RID: 22712
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Spine_Leg_Leg_Arm_Arm_Int32_byref_Vector3_byref_Vector3_byref_Quaternion_byref_Quaternion_byref_Single_byref_Single_byref_Single_byref_Single_0;

			// Token: 0x040058B9 RID: 22713
			private static readonly IntPtr NativeMethodInfoPtr_get_leftFootstepPosition_Public_get_Vector3_0;

			// Token: 0x040058BA RID: 22714
			private static readonly IntPtr NativeMethodInfoPtr_get_rightFootstepPosition_Public_get_Vector3_0;

			// Token: 0x040058BB RID: 22715
			private static readonly IntPtr NativeMethodInfoPtr_get_leftFootstepRotation_Public_get_Quaternion_0;

			// Token: 0x040058BC RID: 22716
			private static readonly IntPtr NativeMethodInfoPtr_get_rightFootstepRotation_Public_get_Quaternion_0;

			// Token: 0x040058BD RID: 22717
			private static readonly IntPtr NativeMethodInfoPtr_StepBlocked_Private_Boolean_Vector3_Vector3_Vector3_0;

			// Token: 0x040058BE RID: 22718
			private static readonly IntPtr NativeMethodInfoPtr_CanStep_Private_Boolean_0;

			// Token: 0x040058BF RID: 22719
			private static readonly IntPtr NativeMethodInfoPtr_GetLineSphereCollision_Private_Static_Boolean_Vector3_Vector3_Vector3_Single_0;

			// Token: 0x040058C0 RID: 22720
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x02000458 RID: 1112
		[Serializable]
		public class Spine : IKSolverVR.BodyPart
		{
			// Token: 0x17002D74 RID: 11636
			// (get) Token: 0x060084DD RID: 34013 RVA: 0x00220370 File Offset: 0x0021E570
			public unsafe IKSolverVR.VirtualBone pelvis
			{
				[CallerCount(14)]
				[CachedScanResults(RefRangeStart = 618485, RefRangeEnd = 618499, XrefRangeStart = 618485, XrefRangeEnd = 618485, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_get_pelvis_Public_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D75 RID: 11637
			// (get) Token: 0x060084DE RID: 34014 RVA: 0x002203C8 File Offset: 0x0021E5C8
			public unsafe IKSolverVR.VirtualBone firstSpineBone
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_get_firstSpineBone_Public_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D76 RID: 11638
			// (get) Token: 0x060084DF RID: 34015 RVA: 0x00220420 File Offset: 0x0021E620
			public unsafe IKSolverVR.VirtualBone chest
			{
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 618500, RefRangeEnd = 618502, XrefRangeStart = 618499, XrefRangeEnd = 618500, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_get_chest_Public_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D77 RID: 11639
			// (get) Token: 0x060084E0 RID: 34016 RVA: 0x00220478 File Offset: 0x0021E678
			public unsafe IKSolverVR.VirtualBone neck
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_get_neck_Private_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D78 RID: 11640
			// (get) Token: 0x060084E1 RID: 34017 RVA: 0x002204D0 File Offset: 0x0021E6D0
			public unsafe IKSolverVR.VirtualBone head
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_get_head_Public_get_VirtualBone_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new IKSolverVR.VirtualBone(intPtr3) : null;
				}
			}

			// Token: 0x17002D79 RID: 11641
			// (get) Token: 0x060084E2 RID: 34018 RVA: 0x00220528 File Offset: 0x0021E728
			// (set) Token: 0x060084E3 RID: 34019 RVA: 0x00220578 File Offset: 0x0021E778
			public unsafe Quaternion anchorRotation
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_get_anchorRotation_Public_get_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_set_anchorRotation_Private_set_Void_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x060084E4 RID: 34020 RVA: 0x002205CC File Offset: 0x0021E7CC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618502, XrefRangeEnd = 618555, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void OnRead(Il2CppStructArray<Vector3> positions, Il2CppStructArray<Quaternion> rotations, bool hasChest, bool hasNeck, bool hasShoulders, bool hasToes, int rootIndex, int index)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(positions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(rotations);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasChest;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasNeck;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasShoulders;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref hasToes;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rootIndex;
				ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Spine.NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084E5 RID: 34021 RVA: 0x002206BC File Offset: 0x0021E8BC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618555, XrefRangeEnd = 618572, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void PreSolve()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Spine.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084E6 RID: 34022 RVA: 0x0022070C File Offset: 0x0021E90C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618572, XrefRangeEnd = 618590, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void ApplyOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Spine.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084E7 RID: 34023 RVA: 0x0022075C File Offset: 0x0021E95C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618590, XrefRangeEnd = 618599, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void CalculateChestTargetRotation(IKSolverVR.VirtualBone rootBone, Il2CppReferenceArray<IKSolverVR.Arm> arms)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(rootBone);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(arms);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_CalculateChestTargetRotation_Private_Void_VirtualBone_Il2CppReferenceArray_1_Arm_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084E8 RID: 34024 RVA: 0x002207D0 File Offset: 0x0021E9D0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618642, RefRangeEnd = 618643, XrefRangeStart = 618599, XrefRangeEnd = 618642, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Solve(IKSolverVR.VirtualBone rootBone, Il2CppReferenceArray<IKSolverVR.Leg> legs, Il2CppReferenceArray<IKSolverVR.Arm> arms)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(rootBone);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(legs);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(arms);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Il2CppReferenceArray_1_Leg_Il2CppReferenceArray_1_Arm_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084E9 RID: 34025 RVA: 0x0022085C File Offset: 0x0021EA5C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618653, RefRangeEnd = 618654, XrefRangeStart = 618643, XrefRangeEnd = 618653, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void SolvePelvis()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_SolvePelvis_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084EA RID: 34026 RVA: 0x002208A0 File Offset: 0x0021EAA0
			[CallerCount(0)]
			public unsafe override void Write(ref Il2CppStructArray<Vector3> solvedPositions, ref Il2CppStructArray<Quaternion> solvedRotations)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedPositions);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtrNotNull(solvedRotations);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Spine.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084EB RID: 34027 RVA: 0x00220920 File Offset: 0x0021EB20
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618654, XrefRangeEnd = 618659, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void ResetOffsets()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolverVR.Spine.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084EC RID: 34028 RVA: 0x00220970 File Offset: 0x0021EB70
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618671, RefRangeEnd = 618673, XrefRangeStart = 618659, XrefRangeEnd = 618671, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void AdjustChestByHands(ref Quaternion chestTargetRotation, Il2CppReferenceArray<IKSolverVR.Arm> arms)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = &chestTargetRotation;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(arms);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_AdjustChestByHands_Private_Void_byref_Quaternion_Il2CppReferenceArray_1_Arm_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084ED RID: 34029 RVA: 0x002209E0 File Offset: 0x0021EBE0
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 618676, RefRangeEnd = 618679, XrefRangeStart = 618673, XrefRangeEnd = 618676, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void InverseTranslateToHead(Il2CppReferenceArray<IKSolverVR.Leg> legs, bool limited, bool useCurrentLegMag, Vector3 offset, float w)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(legs);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref limited;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref useCurrentLegMag;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref offset;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref w;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_InverseTranslateToHead_Public_Void_Il2CppReferenceArray_1_Leg_Boolean_Boolean_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084EE RID: 34030 RVA: 0x00220A88 File Offset: 0x0021EC88
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618692, RefRangeEnd = 618693, XrefRangeStart = 618679, XrefRangeEnd = 618692, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void TranslatePelvis(Il2CppReferenceArray<IKSolverVR.Leg> legs, Vector3 deltaPosition, Quaternion deltaRotation)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(legs);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref deltaPosition;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref deltaRotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_TranslatePelvis_Private_Void_Il2CppReferenceArray_1_Leg_Vector3_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084EF RID: 34031 RVA: 0x00220B08 File Offset: 0x0021ED08
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618699, RefRangeEnd = 618700, XrefRangeStart = 618693, XrefRangeEnd = 618699, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Vector3 LimitPelvisPosition(Il2CppReferenceArray<IKSolverVR.Leg> legs, Vector3 pelvisPosition, bool useCurrentLegMag, int it = 2)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(legs);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pelvisPosition;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref useCurrentLegMag;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref it;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_LimitPelvisPosition_Private_Vector3_Il2CppReferenceArray_1_Leg_Vector3_Boolean_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x060084F0 RID: 34032 RVA: 0x00220BA8 File Offset: 0x0021EDA8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618707, RefRangeEnd = 618708, XrefRangeStart = 618700, XrefRangeEnd = 618707, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Bend(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, int firstIndex, int lastIndex, Quaternion targetRotation, float clampWeight, bool uniformWeight, float w)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref firstIndex;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lastIndex;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref targetRotation;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref clampWeight;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref uniformWeight;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref w;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Single_Boolean_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084F1 RID: 34033 RVA: 0x00220C74 File Offset: 0x0021EE74
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618716, RefRangeEnd = 618718, XrefRangeStart = 618708, XrefRangeEnd = 618716, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Bend(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, int firstIndex, int lastIndex, Quaternion targetRotation, Quaternion rotationOffset, float clampWeight, bool uniformWeight, float w)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)8) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref firstIndex;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref lastIndex;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref targetRotation;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotationOffset;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref clampWeight;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref uniformWeight;
				ptr[checked(unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref w;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Quaternion_Single_Boolean_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084F2 RID: 34034 RVA: 0x00220D54 File Offset: 0x0021EF54
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618735, RefRangeEnd = 618736, XrefRangeStart = 618718, XrefRangeEnd = 618735, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Spine()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.Spine.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060084F3 RID: 34035 RVA: 0x00220DA0 File Offset: 0x0021EFA0
			// Note: this type is marked as 'beforefieldinit'.
			static Spine()
			{
				Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "Spine");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr);
				IKSolverVR.Spine.NativeFieldInfoPtr_headTarget = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headTarget");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisTarget = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisTarget");
				IKSolverVR.Spine.NativeFieldInfoPtr_positionWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "positionWeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_rotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "rotationWeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisPositionWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisPositionWeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisRotationWeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestGoal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestGoal");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestGoalWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestGoalWeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_minHeadHeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "minHeadHeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_bodyPosStiffness = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "bodyPosStiffness");
				IKSolverVR.Spine.NativeFieldInfoPtr_bodyRotStiffness = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "bodyRotStiffness");
				IKSolverVR.Spine.NativeFieldInfoPtr_neckStiffness = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "neckStiffness");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestClampWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestClampWeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_headClampWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headClampWeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_maintainPelvisPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "maintainPelvisPosition");
				IKSolverVR.Spine.NativeFieldInfoPtr_maxRootAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "maxRootAngle");
				IKSolverVR.Spine.NativeFieldInfoPtr_IKPositionHead = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "IKPositionHead");
				IKSolverVR.Spine.NativeFieldInfoPtr_IKRotationHead = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "IKRotationHead");
				IKSolverVR.Spine.NativeFieldInfoPtr_IKPositionPelvis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "IKPositionPelvis");
				IKSolverVR.Spine.NativeFieldInfoPtr_IKRotationPelvis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "IKRotationPelvis");
				IKSolverVR.Spine.NativeFieldInfoPtr_goalPositionChest = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "goalPositionChest");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisPositionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisPositionOffset");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestPositionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestPositionOffset");
				IKSolverVR.Spine.NativeFieldInfoPtr_headPositionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headPositionOffset");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisRotationOffset");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestRotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestRotationOffset");
				IKSolverVR.Spine.NativeFieldInfoPtr_headRotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headRotationOffset");
				IKSolverVR.Spine.NativeFieldInfoPtr_faceDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "faceDirection");
				IKSolverVR.Spine.NativeFieldInfoPtr_locomotionHeadPositionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "locomotionHeadPositionOffset");
				IKSolverVR.Spine.NativeFieldInfoPtr_headPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headPosition");
				IKSolverVR.Spine.NativeFieldInfoPtr__anchorRotation_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "<anchorRotation>k__BackingField");
				IKSolverVR.Spine.NativeFieldInfoPtr_headRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headRotation");
				IKSolverVR.Spine.NativeFieldInfoPtr_anchorRelativeToHead = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "anchorRelativeToHead");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRelativeRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisRelativeRotation");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestRelativeRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestRelativeRotation");
				IKSolverVR.Spine.NativeFieldInfoPtr_headDeltaPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headDeltaPosition");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisDeltaRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisDeltaRotation");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestTargetRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestTargetRotation");
				IKSolverVR.Spine.NativeFieldInfoPtr_pelvisIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "pelvisIndex");
				IKSolverVR.Spine.NativeFieldInfoPtr_spineIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "spineIndex");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestIndex");
				IKSolverVR.Spine.NativeFieldInfoPtr_neckIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "neckIndex");
				IKSolverVR.Spine.NativeFieldInfoPtr_headIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headIndex");
				IKSolverVR.Spine.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "length");
				IKSolverVR.Spine.NativeFieldInfoPtr_hasChest = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "hasChest");
				IKSolverVR.Spine.NativeFieldInfoPtr_hasNeck = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "hasNeck");
				IKSolverVR.Spine.NativeFieldInfoPtr_headHeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "headHeight");
				IKSolverVR.Spine.NativeFieldInfoPtr_sizeMlp = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "sizeMlp");
				IKSolverVR.Spine.NativeFieldInfoPtr_chestForward = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, "chestForward");
				IKSolverVR.Spine.NativeMethodInfoPtr_get_pelvis_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673409);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_firstSpineBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673410);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_chest_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673411);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_neck_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673412);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_head_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673413);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_anchorRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673414);
				IKSolverVR.Spine.NativeMethodInfoPtr_set_anchorRotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673415);
				IKSolverVR.Spine.NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673416);
				IKSolverVR.Spine.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673417);
				IKSolverVR.Spine.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673418);
				IKSolverVR.Spine.NativeMethodInfoPtr_CalculateChestTargetRotation_Private_Void_VirtualBone_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673419);
				IKSolverVR.Spine.NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Il2CppReferenceArray_1_Leg_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673420);
				IKSolverVR.Spine.NativeMethodInfoPtr_SolvePelvis_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673421);
				IKSolverVR.Spine.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673422);
				IKSolverVR.Spine.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673423);
				IKSolverVR.Spine.NativeMethodInfoPtr_AdjustChestByHands_Private_Void_byref_Quaternion_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673424);
				IKSolverVR.Spine.NativeMethodInfoPtr_InverseTranslateToHead_Public_Void_Il2CppReferenceArray_1_Leg_Boolean_Boolean_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673425);
				IKSolverVR.Spine.NativeMethodInfoPtr_TranslatePelvis_Private_Void_Il2CppReferenceArray_1_Leg_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673426);
				IKSolverVR.Spine.NativeMethodInfoPtr_LimitPelvisPosition_Private_Vector3_Il2CppReferenceArray_1_Leg_Vector3_Boolean_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673427);
				IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Single_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673428);
				IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Quaternion_Single_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673429);
				IKSolverVR.Spine.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673430);
			}

			// Token: 0x060084F4 RID: 34036 RVA: 0x0021C1EB File Offset: 0x0021A3EB
			public Spine(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D43 RID: 11587
			// (get) Token: 0x060084F5 RID: 34037 RVA: 0x00221358 File Offset: 0x0021F558
			// (set) Token: 0x060084F6 RID: 34038 RVA: 0x0022138C File Offset: 0x0021F58C
			public unsafe Transform headTarget
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headTarget);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headTarget), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D44 RID: 11588
			// (get) Token: 0x060084F7 RID: 34039 RVA: 0x002213B4 File Offset: 0x0021F5B4
			// (set) Token: 0x060084F8 RID: 34040 RVA: 0x002213E8 File Offset: 0x0021F5E8
			public unsafe Transform pelvisTarget
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisTarget);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisTarget), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D45 RID: 11589
			// (get) Token: 0x060084F9 RID: 34041 RVA: 0x00221410 File Offset: 0x0021F610
			// (set) Token: 0x060084FA RID: 34042 RVA: 0x00221438 File Offset: 0x0021F638
			public unsafe float positionWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_positionWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_positionWeight)) = value;
				}
			}

			// Token: 0x17002D46 RID: 11590
			// (get) Token: 0x060084FB RID: 34043 RVA: 0x0022145C File Offset: 0x0021F65C
			// (set) Token: 0x060084FC RID: 34044 RVA: 0x00221484 File Offset: 0x0021F684
			public unsafe float rotationWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_rotationWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_rotationWeight)) = value;
				}
			}

			// Token: 0x17002D47 RID: 11591
			// (get) Token: 0x060084FD RID: 34045 RVA: 0x002214A8 File Offset: 0x0021F6A8
			// (set) Token: 0x060084FE RID: 34046 RVA: 0x002214D0 File Offset: 0x0021F6D0
			public unsafe float pelvisPositionWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisPositionWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisPositionWeight)) = value;
				}
			}

			// Token: 0x17002D48 RID: 11592
			// (get) Token: 0x060084FF RID: 34047 RVA: 0x002214F4 File Offset: 0x0021F6F4
			// (set) Token: 0x06008500 RID: 34048 RVA: 0x0022151C File Offset: 0x0021F71C
			public unsafe float pelvisRotationWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRotationWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRotationWeight)) = value;
				}
			}

			// Token: 0x17002D49 RID: 11593
			// (get) Token: 0x06008501 RID: 34049 RVA: 0x00221540 File Offset: 0x0021F740
			// (set) Token: 0x06008502 RID: 34050 RVA: 0x00221574 File Offset: 0x0021F774
			public unsafe Transform chestGoal
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestGoal);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestGoal), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D4A RID: 11594
			// (get) Token: 0x06008503 RID: 34051 RVA: 0x0022159C File Offset: 0x0021F79C
			// (set) Token: 0x06008504 RID: 34052 RVA: 0x002215C4 File Offset: 0x0021F7C4
			public unsafe float chestGoalWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestGoalWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestGoalWeight)) = value;
				}
			}

			// Token: 0x17002D4B RID: 11595
			// (get) Token: 0x06008505 RID: 34053 RVA: 0x002215E8 File Offset: 0x0021F7E8
			// (set) Token: 0x06008506 RID: 34054 RVA: 0x00221610 File Offset: 0x0021F810
			public unsafe float minHeadHeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_minHeadHeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_minHeadHeight)) = value;
				}
			}

			// Token: 0x17002D4C RID: 11596
			// (get) Token: 0x06008507 RID: 34055 RVA: 0x00221634 File Offset: 0x0021F834
			// (set) Token: 0x06008508 RID: 34056 RVA: 0x0022165C File Offset: 0x0021F85C
			public unsafe float bodyPosStiffness
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_bodyPosStiffness);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_bodyPosStiffness)) = value;
				}
			}

			// Token: 0x17002D4D RID: 11597
			// (get) Token: 0x06008509 RID: 34057 RVA: 0x00221680 File Offset: 0x0021F880
			// (set) Token: 0x0600850A RID: 34058 RVA: 0x002216A8 File Offset: 0x0021F8A8
			public unsafe float bodyRotStiffness
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_bodyRotStiffness);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_bodyRotStiffness)) = value;
				}
			}

			// Token: 0x17002D4E RID: 11598
			// (get) Token: 0x0600850B RID: 34059 RVA: 0x002216CC File Offset: 0x0021F8CC
			// (set) Token: 0x0600850C RID: 34060 RVA: 0x002216F4 File Offset: 0x0021F8F4
			public unsafe float neckStiffness
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_neckStiffness);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_neckStiffness)) = value;
				}
			}

			// Token: 0x17002D4F RID: 11599
			// (get) Token: 0x0600850D RID: 34061 RVA: 0x00221718 File Offset: 0x0021F918
			// (set) Token: 0x0600850E RID: 34062 RVA: 0x00221740 File Offset: 0x0021F940
			public unsafe float chestClampWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestClampWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestClampWeight)) = value;
				}
			}

			// Token: 0x17002D50 RID: 11600
			// (get) Token: 0x0600850F RID: 34063 RVA: 0x00221764 File Offset: 0x0021F964
			// (set) Token: 0x06008510 RID: 34064 RVA: 0x0022178C File Offset: 0x0021F98C
			public unsafe float headClampWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headClampWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headClampWeight)) = value;
				}
			}

			// Token: 0x17002D51 RID: 11601
			// (get) Token: 0x06008511 RID: 34065 RVA: 0x002217B0 File Offset: 0x0021F9B0
			// (set) Token: 0x06008512 RID: 34066 RVA: 0x002217D8 File Offset: 0x0021F9D8
			public unsafe float maintainPelvisPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_maintainPelvisPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_maintainPelvisPosition)) = value;
				}
			}

			// Token: 0x17002D52 RID: 11602
			// (get) Token: 0x06008513 RID: 34067 RVA: 0x002217FC File Offset: 0x0021F9FC
			// (set) Token: 0x06008514 RID: 34068 RVA: 0x00221824 File Offset: 0x0021FA24
			public unsafe float maxRootAngle
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_maxRootAngle);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_maxRootAngle)) = value;
				}
			}

			// Token: 0x17002D53 RID: 11603
			// (get) Token: 0x06008515 RID: 34069 RVA: 0x00221848 File Offset: 0x0021FA48
			// (set) Token: 0x06008516 RID: 34070 RVA: 0x00221870 File Offset: 0x0021FA70
			public unsafe Vector3 IKPositionHead
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKPositionHead);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKPositionHead)) = value;
				}
			}

			// Token: 0x17002D54 RID: 11604
			// (get) Token: 0x06008517 RID: 34071 RVA: 0x00221894 File Offset: 0x0021FA94
			// (set) Token: 0x06008518 RID: 34072 RVA: 0x002218BC File Offset: 0x0021FABC
			public unsafe Quaternion IKRotationHead
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKRotationHead);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKRotationHead)) = value;
				}
			}

			// Token: 0x17002D55 RID: 11605
			// (get) Token: 0x06008519 RID: 34073 RVA: 0x002218E0 File Offset: 0x0021FAE0
			// (set) Token: 0x0600851A RID: 34074 RVA: 0x00221908 File Offset: 0x0021FB08
			public unsafe Vector3 IKPositionPelvis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKPositionPelvis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKPositionPelvis)) = value;
				}
			}

			// Token: 0x17002D56 RID: 11606
			// (get) Token: 0x0600851B RID: 34075 RVA: 0x0022192C File Offset: 0x0021FB2C
			// (set) Token: 0x0600851C RID: 34076 RVA: 0x00221954 File Offset: 0x0021FB54
			public unsafe Quaternion IKRotationPelvis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKRotationPelvis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_IKRotationPelvis)) = value;
				}
			}

			// Token: 0x17002D57 RID: 11607
			// (get) Token: 0x0600851D RID: 34077 RVA: 0x00221978 File Offset: 0x0021FB78
			// (set) Token: 0x0600851E RID: 34078 RVA: 0x002219A0 File Offset: 0x0021FBA0
			public unsafe Vector3 goalPositionChest
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_goalPositionChest);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_goalPositionChest)) = value;
				}
			}

			// Token: 0x17002D58 RID: 11608
			// (get) Token: 0x0600851F RID: 34079 RVA: 0x002219C4 File Offset: 0x0021FBC4
			// (set) Token: 0x06008520 RID: 34080 RVA: 0x002219EC File Offset: 0x0021FBEC
			public unsafe Vector3 pelvisPositionOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisPositionOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisPositionOffset)) = value;
				}
			}

			// Token: 0x17002D59 RID: 11609
			// (get) Token: 0x06008521 RID: 34081 RVA: 0x00221A10 File Offset: 0x0021FC10
			// (set) Token: 0x06008522 RID: 34082 RVA: 0x00221A38 File Offset: 0x0021FC38
			public unsafe Vector3 chestPositionOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestPositionOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestPositionOffset)) = value;
				}
			}

			// Token: 0x17002D5A RID: 11610
			// (get) Token: 0x06008523 RID: 34083 RVA: 0x00221A5C File Offset: 0x0021FC5C
			// (set) Token: 0x06008524 RID: 34084 RVA: 0x00221A84 File Offset: 0x0021FC84
			public unsafe Vector3 headPositionOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headPositionOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headPositionOffset)) = value;
				}
			}

			// Token: 0x17002D5B RID: 11611
			// (get) Token: 0x06008525 RID: 34085 RVA: 0x00221AA8 File Offset: 0x0021FCA8
			// (set) Token: 0x06008526 RID: 34086 RVA: 0x00221AD0 File Offset: 0x0021FCD0
			public unsafe Quaternion pelvisRotationOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRotationOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRotationOffset)) = value;
				}
			}

			// Token: 0x17002D5C RID: 11612
			// (get) Token: 0x06008527 RID: 34087 RVA: 0x00221AF4 File Offset: 0x0021FCF4
			// (set) Token: 0x06008528 RID: 34088 RVA: 0x00221B1C File Offset: 0x0021FD1C
			public unsafe Quaternion chestRotationOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestRotationOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestRotationOffset)) = value;
				}
			}

			// Token: 0x17002D5D RID: 11613
			// (get) Token: 0x06008529 RID: 34089 RVA: 0x00221B40 File Offset: 0x0021FD40
			// (set) Token: 0x0600852A RID: 34090 RVA: 0x00221B68 File Offset: 0x0021FD68
			public unsafe Quaternion headRotationOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headRotationOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headRotationOffset)) = value;
				}
			}

			// Token: 0x17002D5E RID: 11614
			// (get) Token: 0x0600852B RID: 34091 RVA: 0x00221B8C File Offset: 0x0021FD8C
			// (set) Token: 0x0600852C RID: 34092 RVA: 0x00221BB4 File Offset: 0x0021FDB4
			public unsafe Vector3 faceDirection
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_faceDirection);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_faceDirection)) = value;
				}
			}

			// Token: 0x17002D5F RID: 11615
			// (get) Token: 0x0600852D RID: 34093 RVA: 0x00221BD8 File Offset: 0x0021FDD8
			// (set) Token: 0x0600852E RID: 34094 RVA: 0x00221C00 File Offset: 0x0021FE00
			public unsafe Vector3 locomotionHeadPositionOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_locomotionHeadPositionOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_locomotionHeadPositionOffset)) = value;
				}
			}

			// Token: 0x17002D60 RID: 11616
			// (get) Token: 0x0600852F RID: 34095 RVA: 0x00221C24 File Offset: 0x0021FE24
			// (set) Token: 0x06008530 RID: 34096 RVA: 0x00221C4C File Offset: 0x0021FE4C
			public unsafe Vector3 headPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headPosition)) = value;
				}
			}

			// Token: 0x17002D61 RID: 11617
			// (get) Token: 0x06008531 RID: 34097 RVA: 0x00221C70 File Offset: 0x0021FE70
			// (set) Token: 0x06008532 RID: 34098 RVA: 0x00221C98 File Offset: 0x0021FE98
			public unsafe Quaternion _anchorRotation_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr__anchorRotation_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr__anchorRotation_k__BackingField)) = value;
				}
			}

			// Token: 0x17002D62 RID: 11618
			// (get) Token: 0x06008533 RID: 34099 RVA: 0x00221CBC File Offset: 0x0021FEBC
			// (set) Token: 0x06008534 RID: 34100 RVA: 0x00221CE4 File Offset: 0x0021FEE4
			public unsafe Quaternion headRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headRotation)) = value;
				}
			}

			// Token: 0x17002D63 RID: 11619
			// (get) Token: 0x06008535 RID: 34101 RVA: 0x00221D08 File Offset: 0x0021FF08
			// (set) Token: 0x06008536 RID: 34102 RVA: 0x00221D30 File Offset: 0x0021FF30
			public unsafe Quaternion anchorRelativeToHead
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_anchorRelativeToHead);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_anchorRelativeToHead)) = value;
				}
			}

			// Token: 0x17002D64 RID: 11620
			// (get) Token: 0x06008537 RID: 34103 RVA: 0x00221D54 File Offset: 0x0021FF54
			// (set) Token: 0x06008538 RID: 34104 RVA: 0x00221D7C File Offset: 0x0021FF7C
			public unsafe Quaternion pelvisRelativeRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRelativeRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisRelativeRotation)) = value;
				}
			}

			// Token: 0x17002D65 RID: 11621
			// (get) Token: 0x06008539 RID: 34105 RVA: 0x00221DA0 File Offset: 0x0021FFA0
			// (set) Token: 0x0600853A RID: 34106 RVA: 0x00221DC8 File Offset: 0x0021FFC8
			public unsafe Quaternion chestRelativeRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestRelativeRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestRelativeRotation)) = value;
				}
			}

			// Token: 0x17002D66 RID: 11622
			// (get) Token: 0x0600853B RID: 34107 RVA: 0x00221DEC File Offset: 0x0021FFEC
			// (set) Token: 0x0600853C RID: 34108 RVA: 0x00221E14 File Offset: 0x00220014
			public unsafe Vector3 headDeltaPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headDeltaPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headDeltaPosition)) = value;
				}
			}

			// Token: 0x17002D67 RID: 11623
			// (get) Token: 0x0600853D RID: 34109 RVA: 0x00221E38 File Offset: 0x00220038
			// (set) Token: 0x0600853E RID: 34110 RVA: 0x00221E60 File Offset: 0x00220060
			public unsafe Quaternion pelvisDeltaRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisDeltaRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisDeltaRotation)) = value;
				}
			}

			// Token: 0x17002D68 RID: 11624
			// (get) Token: 0x0600853F RID: 34111 RVA: 0x00221E84 File Offset: 0x00220084
			// (set) Token: 0x06008540 RID: 34112 RVA: 0x00221EAC File Offset: 0x002200AC
			public unsafe Quaternion chestTargetRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestTargetRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestTargetRotation)) = value;
				}
			}

			// Token: 0x17002D69 RID: 11625
			// (get) Token: 0x06008541 RID: 34113 RVA: 0x00221ED0 File Offset: 0x002200D0
			// (set) Token: 0x06008542 RID: 34114 RVA: 0x00221EF8 File Offset: 0x002200F8
			public unsafe int pelvisIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_pelvisIndex)) = value;
				}
			}

			// Token: 0x17002D6A RID: 11626
			// (get) Token: 0x06008543 RID: 34115 RVA: 0x00221F1C File Offset: 0x0022011C
			// (set) Token: 0x06008544 RID: 34116 RVA: 0x00221F44 File Offset: 0x00220144
			public unsafe int spineIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_spineIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_spineIndex)) = value;
				}
			}

			// Token: 0x17002D6B RID: 11627
			// (get) Token: 0x06008545 RID: 34117 RVA: 0x00221F68 File Offset: 0x00220168
			// (set) Token: 0x06008546 RID: 34118 RVA: 0x00221F90 File Offset: 0x00220190
			public unsafe int chestIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestIndex)) = value;
				}
			}

			// Token: 0x17002D6C RID: 11628
			// (get) Token: 0x06008547 RID: 34119 RVA: 0x00221FB4 File Offset: 0x002201B4
			// (set) Token: 0x06008548 RID: 34120 RVA: 0x00221FDC File Offset: 0x002201DC
			public unsafe int neckIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_neckIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_neckIndex)) = value;
				}
			}

			// Token: 0x17002D6D RID: 11629
			// (get) Token: 0x06008549 RID: 34121 RVA: 0x00222000 File Offset: 0x00220200
			// (set) Token: 0x0600854A RID: 34122 RVA: 0x00222028 File Offset: 0x00220228
			public unsafe int headIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headIndex)) = value;
				}
			}

			// Token: 0x17002D6E RID: 11630
			// (get) Token: 0x0600854B RID: 34123 RVA: 0x0022204C File Offset: 0x0022024C
			// (set) Token: 0x0600854C RID: 34124 RVA: 0x00222074 File Offset: 0x00220274
			public unsafe float length
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_length);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_length)) = value;
				}
			}

			// Token: 0x17002D6F RID: 11631
			// (get) Token: 0x0600854D RID: 34125 RVA: 0x00222098 File Offset: 0x00220298
			// (set) Token: 0x0600854E RID: 34126 RVA: 0x002220C0 File Offset: 0x002202C0
			public unsafe bool hasChest
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_hasChest);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_hasChest)) = value;
				}
			}

			// Token: 0x17002D70 RID: 11632
			// (get) Token: 0x0600854F RID: 34127 RVA: 0x002220E4 File Offset: 0x002202E4
			// (set) Token: 0x06008550 RID: 34128 RVA: 0x0022210C File Offset: 0x0022030C
			public unsafe bool hasNeck
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_hasNeck);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_hasNeck)) = value;
				}
			}

			// Token: 0x17002D71 RID: 11633
			// (get) Token: 0x06008551 RID: 34129 RVA: 0x00222130 File Offset: 0x00220330
			// (set) Token: 0x06008552 RID: 34130 RVA: 0x00222158 File Offset: 0x00220358
			public unsafe float headHeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headHeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_headHeight)) = value;
				}
			}

			// Token: 0x17002D72 RID: 11634
			// (get) Token: 0x06008553 RID: 34131 RVA: 0x0022217C File Offset: 0x0022037C
			// (set) Token: 0x06008554 RID: 34132 RVA: 0x002221A4 File Offset: 0x002203A4
			public unsafe float sizeMlp
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_sizeMlp);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_sizeMlp)) = value;
				}
			}

			// Token: 0x17002D73 RID: 11635
			// (get) Token: 0x06008555 RID: 34133 RVA: 0x002221C8 File Offset: 0x002203C8
			// (set) Token: 0x06008556 RID: 34134 RVA: 0x002221F0 File Offset: 0x002203F0
			public unsafe Vector3 chestForward
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestForward);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.Spine.NativeFieldInfoPtr_chestForward)) = value;
				}
			}

			// Token: 0x040058C1 RID: 22721
			private static readonly IntPtr NativeFieldInfoPtr_headTarget;

			// Token: 0x040058C2 RID: 22722
			private static readonly IntPtr NativeFieldInfoPtr_pelvisTarget;

			// Token: 0x040058C3 RID: 22723
			private static readonly IntPtr NativeFieldInfoPtr_positionWeight;

			// Token: 0x040058C4 RID: 22724
			private static readonly IntPtr NativeFieldInfoPtr_rotationWeight;

			// Token: 0x040058C5 RID: 22725
			private static readonly IntPtr NativeFieldInfoPtr_pelvisPositionWeight;

			// Token: 0x040058C6 RID: 22726
			private static readonly IntPtr NativeFieldInfoPtr_pelvisRotationWeight;

			// Token: 0x040058C7 RID: 22727
			private static readonly IntPtr NativeFieldInfoPtr_chestGoal;

			// Token: 0x040058C8 RID: 22728
			private static readonly IntPtr NativeFieldInfoPtr_chestGoalWeight;

			// Token: 0x040058C9 RID: 22729
			private static readonly IntPtr NativeFieldInfoPtr_minHeadHeight;

			// Token: 0x040058CA RID: 22730
			private static readonly IntPtr NativeFieldInfoPtr_bodyPosStiffness;

			// Token: 0x040058CB RID: 22731
			private static readonly IntPtr NativeFieldInfoPtr_bodyRotStiffness;

			// Token: 0x040058CC RID: 22732
			private static readonly IntPtr NativeFieldInfoPtr_neckStiffness;

			// Token: 0x040058CD RID: 22733
			private static readonly IntPtr NativeFieldInfoPtr_chestClampWeight;

			// Token: 0x040058CE RID: 22734
			private static readonly IntPtr NativeFieldInfoPtr_headClampWeight;

			// Token: 0x040058CF RID: 22735
			private static readonly IntPtr NativeFieldInfoPtr_maintainPelvisPosition;

			// Token: 0x040058D0 RID: 22736
			private static readonly IntPtr NativeFieldInfoPtr_maxRootAngle;

			// Token: 0x040058D1 RID: 22737
			private static readonly IntPtr NativeFieldInfoPtr_IKPositionHead;

			// Token: 0x040058D2 RID: 22738
			private static readonly IntPtr NativeFieldInfoPtr_IKRotationHead;

			// Token: 0x040058D3 RID: 22739
			private static readonly IntPtr NativeFieldInfoPtr_IKPositionPelvis;

			// Token: 0x040058D4 RID: 22740
			private static readonly IntPtr NativeFieldInfoPtr_IKRotationPelvis;

			// Token: 0x040058D5 RID: 22741
			private static readonly IntPtr NativeFieldInfoPtr_goalPositionChest;

			// Token: 0x040058D6 RID: 22742
			private static readonly IntPtr NativeFieldInfoPtr_pelvisPositionOffset;

			// Token: 0x040058D7 RID: 22743
			private static readonly IntPtr NativeFieldInfoPtr_chestPositionOffset;

			// Token: 0x040058D8 RID: 22744
			private static readonly IntPtr NativeFieldInfoPtr_headPositionOffset;

			// Token: 0x040058D9 RID: 22745
			private static readonly IntPtr NativeFieldInfoPtr_pelvisRotationOffset;

			// Token: 0x040058DA RID: 22746
			private static readonly IntPtr NativeFieldInfoPtr_chestRotationOffset;

			// Token: 0x040058DB RID: 22747
			private static readonly IntPtr NativeFieldInfoPtr_headRotationOffset;

			// Token: 0x040058DC RID: 22748
			private static readonly IntPtr NativeFieldInfoPtr_faceDirection;

			// Token: 0x040058DD RID: 22749
			private static readonly IntPtr NativeFieldInfoPtr_locomotionHeadPositionOffset;

			// Token: 0x040058DE RID: 22750
			private static readonly IntPtr NativeFieldInfoPtr_headPosition;

			// Token: 0x040058DF RID: 22751
			private static readonly IntPtr NativeFieldInfoPtr__anchorRotation_k__BackingField;

			// Token: 0x040058E0 RID: 22752
			private static readonly IntPtr NativeFieldInfoPtr_headRotation;

			// Token: 0x040058E1 RID: 22753
			private static readonly IntPtr NativeFieldInfoPtr_anchorRelativeToHead;

			// Token: 0x040058E2 RID: 22754
			private static readonly IntPtr NativeFieldInfoPtr_pelvisRelativeRotation;

			// Token: 0x040058E3 RID: 22755
			private static readonly IntPtr NativeFieldInfoPtr_chestRelativeRotation;

			// Token: 0x040058E4 RID: 22756
			private static readonly IntPtr NativeFieldInfoPtr_headDeltaPosition;

			// Token: 0x040058E5 RID: 22757
			private static readonly IntPtr NativeFieldInfoPtr_pelvisDeltaRotation;

			// Token: 0x040058E6 RID: 22758
			private static readonly IntPtr NativeFieldInfoPtr_chestTargetRotation;

			// Token: 0x040058E7 RID: 22759
			private static readonly IntPtr NativeFieldInfoPtr_pelvisIndex;

			// Token: 0x040058E8 RID: 22760
			private static readonly IntPtr NativeFieldInfoPtr_spineIndex;

			// Token: 0x040058E9 RID: 22761
			private static readonly IntPtr NativeFieldInfoPtr_chestIndex;

			// Token: 0x040058EA RID: 22762
			private static readonly IntPtr NativeFieldInfoPtr_neckIndex;

			// Token: 0x040058EB RID: 22763
			private static readonly IntPtr NativeFieldInfoPtr_headIndex;

			// Token: 0x040058EC RID: 22764
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x040058ED RID: 22765
			private static readonly IntPtr NativeFieldInfoPtr_hasChest;

			// Token: 0x040058EE RID: 22766
			private static readonly IntPtr NativeFieldInfoPtr_hasNeck;

			// Token: 0x040058EF RID: 22767
			private static readonly IntPtr NativeFieldInfoPtr_headHeight;

			// Token: 0x040058F0 RID: 22768
			private static readonly IntPtr NativeFieldInfoPtr_sizeMlp;

			// Token: 0x040058F1 RID: 22769
			private static readonly IntPtr NativeFieldInfoPtr_chestForward;

			// Token: 0x040058F2 RID: 22770
			private static readonly IntPtr NativeMethodInfoPtr_get_pelvis_Public_get_VirtualBone_0;

			// Token: 0x040058F3 RID: 22771
			private static readonly IntPtr NativeMethodInfoPtr_get_firstSpineBone_Public_get_VirtualBone_0;

			// Token: 0x040058F4 RID: 22772
			private static readonly IntPtr NativeMethodInfoPtr_get_chest_Public_get_VirtualBone_0;

			// Token: 0x040058F5 RID: 22773
			private static readonly IntPtr NativeMethodInfoPtr_get_neck_Private_get_VirtualBone_0;

			// Token: 0x040058F6 RID: 22774
			private static readonly IntPtr NativeMethodInfoPtr_get_head_Public_get_VirtualBone_0;

			// Token: 0x040058F7 RID: 22775
			private static readonly IntPtr NativeMethodInfoPtr_get_anchorRotation_Public_get_Quaternion_0;

			// Token: 0x040058F8 RID: 22776
			private static readonly IntPtr NativeMethodInfoPtr_set_anchorRotation_Private_set_Void_Quaternion_0;

			// Token: 0x040058F9 RID: 22777
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x040058FA RID: 22778
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0;

			// Token: 0x040058FB RID: 22779
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0;

			// Token: 0x040058FC RID: 22780
			private static readonly IntPtr NativeMethodInfoPtr_CalculateChestTargetRotation_Private_Void_VirtualBone_Il2CppReferenceArray_1_Arm_0;

			// Token: 0x040058FD RID: 22781
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Il2CppReferenceArray_1_Leg_Il2CppReferenceArray_1_Arm_0;

			// Token: 0x040058FE RID: 22782
			private static readonly IntPtr NativeMethodInfoPtr_SolvePelvis_Private_Void_0;

			// Token: 0x040058FF RID: 22783
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005900 RID: 22784
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0;

			// Token: 0x04005901 RID: 22785
			private static readonly IntPtr NativeMethodInfoPtr_AdjustChestByHands_Private_Void_byref_Quaternion_Il2CppReferenceArray_1_Arm_0;

			// Token: 0x04005902 RID: 22786
			private static readonly IntPtr NativeMethodInfoPtr_InverseTranslateToHead_Public_Void_Il2CppReferenceArray_1_Leg_Boolean_Boolean_Vector3_Single_0;

			// Token: 0x04005903 RID: 22787
			private static readonly IntPtr NativeMethodInfoPtr_TranslatePelvis_Private_Void_Il2CppReferenceArray_1_Leg_Vector3_Quaternion_0;

			// Token: 0x04005904 RID: 22788
			private static readonly IntPtr NativeMethodInfoPtr_LimitPelvisPosition_Private_Vector3_Il2CppReferenceArray_1_Leg_Vector3_Boolean_Int32_0;

			// Token: 0x04005905 RID: 22789
			private static readonly IntPtr NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Single_Boolean_Single_0;

			// Token: 0x04005906 RID: 22790
			private static readonly IntPtr NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Quaternion_Single_Boolean_Single_0;

			// Token: 0x04005907 RID: 22791
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x02000459 RID: 1113
		[Serializable]
		public enum PositionOffset
		{
			// Token: 0x04005909 RID: 22793
			Pelvis,
			// Token: 0x0400590A RID: 22794
			Chest,
			// Token: 0x0400590B RID: 22795
			Head,
			// Token: 0x0400590C RID: 22796
			LeftHand,
			// Token: 0x0400590D RID: 22797
			RightHand,
			// Token: 0x0400590E RID: 22798
			LeftFoot,
			// Token: 0x0400590F RID: 22799
			RightFoot,
			// Token: 0x04005910 RID: 22800
			LeftHeel,
			// Token: 0x04005911 RID: 22801
			RightHeel
		}

		// Token: 0x0200045A RID: 1114
		[Serializable]
		public enum RotationOffset
		{
			// Token: 0x04005913 RID: 22803
			Pelvis,
			// Token: 0x04005914 RID: 22804
			Chest,
			// Token: 0x04005915 RID: 22805
			Head
		}

		// Token: 0x0200045B RID: 1115
		[Serializable]
		public class VirtualBone : Il2CppSystem.Object
		{
			// Token: 0x06008557 RID: 34135 RVA: 0x00222214 File Offset: 0x00220414
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618737, RefRangeEnd = 618738, XrefRangeStart = 618736, XrefRangeEnd = 618737, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe VirtualBone(Vector3 position, Quaternion rotation)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref position;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008558 RID: 34136 RVA: 0x00222284 File Offset: 0x00220484
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618738, RefRangeEnd = 618739, XrefRangeStart = 618738, XrefRangeEnd = 618738, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Read(Vector3 position, Quaternion rotation)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref position;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_Read_Public_Void_Vector3_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008559 RID: 34137 RVA: 0x002222EC File Offset: 0x002204EC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618745, RefRangeEnd = 618746, XrefRangeStart = 618739, XrefRangeEnd = 618745, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void SwingRotation(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, int index, Vector3 swingTarget, float weight = 1f)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref swingTarget;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_SwingRotation_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600855A RID: 34138 RVA: 0x00222370 File Offset: 0x00220570
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618753, RefRangeEnd = 618754, XrefRangeStart = 618746, XrefRangeEnd = 618753, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static float PreSolve(ref Il2CppReferenceArray<IKSolverVR.VirtualBone> bones)
			{
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					ref IntPtr ptr2 = ref *ptr;
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtr(bones);
					ptr2 = &intPtr;
					IntPtr intPtr3;
					IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_PreSolve_Public_Static_Single_byref_Il2CppReferenceArray_1_VirtualBone_0, 0, (void**)ptr, ref intPtr3);
					Il2CppException.RaiseExceptionIfNecessary(intPtr3);
					IntPtr intPtr4 = intPtr;
					bones = ((intPtr4 == 0) ? null : new Il2CppReferenceArray(intPtr4));
					return *IL2CPP.il2cpp_object_unbox(intPtr2);
				}
			}

			// Token: 0x0600855B RID: 34139 RVA: 0x002223E8 File Offset: 0x002205E8
			[CallerCount(10)]
			[CachedScanResults(RefRangeStart = 618757, RefRangeEnd = 618767, XrefRangeStart = 618754, XrefRangeEnd = 618757, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void RotateAroundPoint(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, int index, Vector3 point, Quaternion rotation)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref point;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateAroundPoint_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Quaternion_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600855C RID: 34140 RVA: 0x0022246C File Offset: 0x0022066C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 618770, RefRangeEnd = 618771, XrefRangeStart = 618767, XrefRangeEnd = 618770, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void RotateBy(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, int index, Quaternion rotation)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600855D RID: 34141 RVA: 0x002224DC File Offset: 0x002206DC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618774, RefRangeEnd = 618776, XrefRangeStart = 618771, XrefRangeEnd = 618774, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void RotateBy(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, Quaternion rotation)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Quaternion_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600855E RID: 34142 RVA: 0x0022253C File Offset: 0x0022073C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618776, XrefRangeEnd = 618778, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void RotateTo(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, int index, Quaternion rotation)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateTo_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600855F RID: 34143 RVA: 0x002225AC File Offset: 0x002207AC
			[CallerCount(11)]
			[CachedScanResults(RefRangeStart = 618805, RefRangeEnd = 618816, XrefRangeStart = 618778, XrefRangeEnd = 618805, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void SolveTrigonometric(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, int first, int second, int third, Vector3 targetPosition, Vector3 bendNormal, float weight)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref first;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref second;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref third;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref targetPosition;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref bendNormal;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveTrigonometric_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Int32_Vector3_Vector3_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008560 RID: 34144 RVA: 0x00222668 File Offset: 0x00220868
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618816, XrefRangeEnd = 618828, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static Vector3 GetDirectionToBendPoint(Vector3 direction, float directionMag, Vector3 bendDirection, float sqrMag1, float sqrMag2)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref direction;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref directionMag;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref bendDirection;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sqrMag1;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref sqrMag2;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_GetDirectionToBendPoint_Private_Static_Vector3_Vector3_Single_Vector3_Single_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x06008561 RID: 34145 RVA: 0x00222708 File Offset: 0x00220908
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618837, RefRangeEnd = 618839, XrefRangeStart = 618828, XrefRangeEnd = 618837, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void SolveFABRIK(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, Vector3 startPosition, Vector3 targetPosition, float weight, float minNormalizedTargetDistance, int iterations, float length)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)7) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref startPosition;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref targetPosition;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref minNormalizedTargetDistance;
				ptr[checked(unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref iterations;
				ptr[checked(unchecked((UIntPtr)6) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref length;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIK_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Vector3_Single_Single_Int32_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008562 RID: 34146 RVA: 0x002227C4 File Offset: 0x002209C4
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 618840, RefRangeEnd = 618842, XrefRangeStart = 618839, XrefRangeEnd = 618840, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static Vector3 SolveFABRIKJoint(Vector3 pos1, Vector3 pos2, float length)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref pos1;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pos2;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref length;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Static_Vector3_Vector3_Vector3_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x06008563 RID: 34147 RVA: 0x00222840 File Offset: 0x00220A40
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 618842, XrefRangeEnd = 618846, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void SolveCCD(Il2CppReferenceArray<IKSolverVR.VirtualBone> bones, Vector3 targetPosition, float weight, int iterations)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref targetPosition;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref iterations;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveCCD_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Single_Int32_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008564 RID: 34148 RVA: 0x002228C4 File Offset: 0x00220AC4
			// Note: this type is marked as 'beforefieldinit'.
			static VirtualBone()
			{
				Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, "VirtualBone");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr);
				IKSolverVR.VirtualBone.NativeFieldInfoPtr_readPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, "readPosition");
				IKSolverVR.VirtualBone.NativeFieldInfoPtr_readRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, "readRotation");
				IKSolverVR.VirtualBone.NativeFieldInfoPtr_solverPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, "solverPosition");
				IKSolverVR.VirtualBone.NativeFieldInfoPtr_solverRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, "solverRotation");
				IKSolverVR.VirtualBone.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, "length");
				IKSolverVR.VirtualBone.NativeFieldInfoPtr_sqrMag = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, "sqrMag");
				IKSolverVR.VirtualBone.NativeFieldInfoPtr_axis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, "axis");
				IKSolverVR.VirtualBone.NativeMethodInfoPtr__ctor_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673431);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_Read_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673432);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SwingRotation_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673433);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_PreSolve_Public_Static_Single_byref_Il2CppReferenceArray_1_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673434);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateAroundPoint_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673435);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673436);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673437);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateTo_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673438);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveTrigonometric_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Int32_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673439);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_GetDirectionToBendPoint_Private_Static_Vector3_Vector3_Single_Vector3_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673440);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIK_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Vector3_Single_Single_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673441);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Static_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673442);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveCCD_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673443);
			}

			// Token: 0x06008565 RID: 34149 RVA: 0x0000A74C File Offset: 0x0000894C
			public VirtualBone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D7A RID: 11642
			// (get) Token: 0x06008566 RID: 34150 RVA: 0x00222A80 File Offset: 0x00220C80
			// (set) Token: 0x06008567 RID: 34151 RVA: 0x00222AA8 File Offset: 0x00220CA8
			public unsafe Vector3 readPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_readPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_readPosition)) = value;
				}
			}

			// Token: 0x17002D7B RID: 11643
			// (get) Token: 0x06008568 RID: 34152 RVA: 0x00222ACC File Offset: 0x00220CCC
			// (set) Token: 0x06008569 RID: 34153 RVA: 0x00222AF4 File Offset: 0x00220CF4
			public unsafe Quaternion readRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_readRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_readRotation)) = value;
				}
			}

			// Token: 0x17002D7C RID: 11644
			// (get) Token: 0x0600856A RID: 34154 RVA: 0x00222B18 File Offset: 0x00220D18
			// (set) Token: 0x0600856B RID: 34155 RVA: 0x00222B40 File Offset: 0x00220D40
			public unsafe Vector3 solverPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_solverPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_solverPosition)) = value;
				}
			}

			// Token: 0x17002D7D RID: 11645
			// (get) Token: 0x0600856C RID: 34156 RVA: 0x00222B64 File Offset: 0x00220D64
			// (set) Token: 0x0600856D RID: 34157 RVA: 0x00222B8C File Offset: 0x00220D8C
			public unsafe Quaternion solverRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_solverRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_solverRotation)) = value;
				}
			}

			// Token: 0x17002D7E RID: 11646
			// (get) Token: 0x0600856E RID: 34158 RVA: 0x00222BB0 File Offset: 0x00220DB0
			// (set) Token: 0x0600856F RID: 34159 RVA: 0x00222BD8 File Offset: 0x00220DD8
			public unsafe float length
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_length);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_length)) = value;
				}
			}

			// Token: 0x17002D7F RID: 11647
			// (get) Token: 0x06008570 RID: 34160 RVA: 0x00222BFC File Offset: 0x00220DFC
			// (set) Token: 0x06008571 RID: 34161 RVA: 0x00222C24 File Offset: 0x00220E24
			public unsafe float sqrMag
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_sqrMag);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_sqrMag)) = value;
				}
			}

			// Token: 0x17002D80 RID: 11648
			// (get) Token: 0x06008572 RID: 34162 RVA: 0x00222C48 File Offset: 0x00220E48
			// (set) Token: 0x06008573 RID: 34163 RVA: 0x00222C70 File Offset: 0x00220E70
			public unsafe Vector3 axis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_axis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolverVR.VirtualBone.NativeFieldInfoPtr_axis)) = value;
				}
			}

			// Token: 0x04005916 RID: 22806
			private static readonly IntPtr NativeFieldInfoPtr_readPosition;

			// Token: 0x04005917 RID: 22807
			private static readonly IntPtr NativeFieldInfoPtr_readRotation;

			// Token: 0x04005918 RID: 22808
			private static readonly IntPtr NativeFieldInfoPtr_solverPosition;

			// Token: 0x04005919 RID: 22809
			private static readonly IntPtr NativeFieldInfoPtr_solverRotation;

			// Token: 0x0400591A RID: 22810
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x0400591B RID: 22811
			private static readonly IntPtr NativeFieldInfoPtr_sqrMag;

			// Token: 0x0400591C RID: 22812
			private static readonly IntPtr NativeFieldInfoPtr_axis;

			// Token: 0x0400591D RID: 22813
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Quaternion_0;

			// Token: 0x0400591E RID: 22814
			private static readonly IntPtr NativeMethodInfoPtr_Read_Public_Void_Vector3_Quaternion_0;

			// Token: 0x0400591F RID: 22815
			private static readonly IntPtr NativeMethodInfoPtr_SwingRotation_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Single_0;

			// Token: 0x04005920 RID: 22816
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Static_Single_byref_Il2CppReferenceArray_1_VirtualBone_0;

			// Token: 0x04005921 RID: 22817
			private static readonly IntPtr NativeMethodInfoPtr_RotateAroundPoint_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Quaternion_0;

			// Token: 0x04005922 RID: 22818
			private static readonly IntPtr NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0;

			// Token: 0x04005923 RID: 22819
			private static readonly IntPtr NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Quaternion_0;

			// Token: 0x04005924 RID: 22820
			private static readonly IntPtr NativeMethodInfoPtr_RotateTo_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0;

			// Token: 0x04005925 RID: 22821
			private static readonly IntPtr NativeMethodInfoPtr_SolveTrigonometric_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Int32_Vector3_Vector3_Single_0;

			// Token: 0x04005926 RID: 22822
			private static readonly IntPtr NativeMethodInfoPtr_GetDirectionToBendPoint_Private_Static_Vector3_Vector3_Single_Vector3_Single_Single_0;

			// Token: 0x04005927 RID: 22823
			private static readonly IntPtr NativeMethodInfoPtr_SolveFABRIK_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Vector3_Single_Single_Int32_Single_0;

			// Token: 0x04005928 RID: 22824
			private static readonly IntPtr NativeMethodInfoPtr_SolveFABRIKJoint_Private_Static_Vector3_Vector3_Vector3_Single_0;

			// Token: 0x04005929 RID: 22825
			private static readonly IntPtr NativeMethodInfoPtr_SolveCCD_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Single_Int32_0;
		}
	}
}