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: 0x02000448 RID: 1096
	[Serializable]
	public class IKSolverVR : IKSolver
	{
		// Token: 0x060082B3 RID: 33459 RVA: 0x00216FEC File Offset: 0x002151EC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601265, RefRangeEnd = 601266, XrefRangeStart = 601233, XrefRangeEnd = 601265, 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: 0x060082B4 RID: 33460 RVA: 0x00217048 File Offset: 0x00215248
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 601281, RefRangeEnd = 601283, XrefRangeStart = 601266, XrefRangeEnd = 601281, 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: 0x060082B5 RID: 33461 RVA: 0x002170B4 File Offset: 0x002152B4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601298, RefRangeEnd = 601299, XrefRangeStart = 601283, XrefRangeEnd = 601298, 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: 0x060082B6 RID: 33462 RVA: 0x002170F8 File Offset: 0x002152F8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601299, RefRangeEnd = 601300, XrefRangeStart = 601299, XrefRangeEnd = 601299, 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: 0x060082B7 RID: 33463 RVA: 0x00217160 File Offset: 0x00215360
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601300, XrefRangeEnd = 601302, 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: 0x060082B8 RID: 33464 RVA: 0x002171C8 File Offset: 0x002153C8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601303, RefRangeEnd = 601304, XrefRangeStart = 601302, XrefRangeEnd = 601303, 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: 0x060082B9 RID: 33465 RVA: 0x00217230 File Offset: 0x00215430
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601307, RefRangeEnd = 601308, XrefRangeStart = 601304, XrefRangeEnd = 601307, 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: 0x060082BA RID: 33466 RVA: 0x002172AC File Offset: 0x002154AC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601308, XrefRangeEnd = 601314, 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: 0x060082BB RID: 33467 RVA: 0x002172F0 File Offset: 0x002154F0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601314, XrefRangeEnd = 601321, 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: 0x060082BC RID: 33468 RVA: 0x00217340 File Offset: 0x00215540
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601321, XrefRangeEnd = 601328, 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: 0x060082BD RID: 33469 RVA: 0x00217390 File Offset: 0x00215590
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601328, XrefRangeEnd = 601334, 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: 0x060082BE RID: 33470 RVA: 0x002173F4 File Offset: 0x002155F4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601334, XrefRangeEnd = 601340, 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: 0x060082BF RID: 33471 RVA: 0x0021746C File Offset: 0x0021566C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601340, XrefRangeEnd = 601357, 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: 0x060082C0 RID: 33472 RVA: 0x002174F8 File Offset: 0x002156F8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601357, XrefRangeEnd = 601366, 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: 0x060082C1 RID: 33473 RVA: 0x00217560 File Offset: 0x00215760
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 601372, RefRangeEnd = 601374, XrefRangeStart = 601366, XrefRangeEnd = 601372, 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: 0x060082C2 RID: 33474 RVA: 0x002175E0 File Offset: 0x002157E0
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 601396, RefRangeEnd = 601398, XrefRangeStart = 601374, XrefRangeEnd = 601396, 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: 0x060082C3 RID: 33475 RVA: 0x00217660 File Offset: 0x00215860
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 601407, RefRangeEnd = 601409, XrefRangeStart = 601398, XrefRangeEnd = 601407, 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: 0x060082C4 RID: 33476 RVA: 0x002176BC File Offset: 0x002158BC
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 601416, RefRangeEnd = 601419, XrefRangeStart = 601409, XrefRangeEnd = 601416, 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: 0x060082C5 RID: 33477 RVA: 0x00217700 File Offset: 0x00215900
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601419, XrefRangeEnd = 601421, 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: 0x060082C6 RID: 33478 RVA: 0x00217750 File Offset: 0x00215950
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601421, XrefRangeEnd = 601426, 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: 0x060082C7 RID: 33479 RVA: 0x002177A0 File Offset: 0x002159A0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601438, RefRangeEnd = 601439, XrefRangeStart = 601426, XrefRangeEnd = 601438, 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: 0x060082C8 RID: 33480 RVA: 0x002177E4 File Offset: 0x002159E4
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 601472, RefRangeEnd = 601475, XrefRangeStart = 601439, XrefRangeEnd = 601472, 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: 0x060082C9 RID: 33481 RVA: 0x002178A4 File Offset: 0x00215AA4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601543, RefRangeEnd = 601544, XrefRangeStart = 601475, XrefRangeEnd = 601543, 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: 0x060082CA RID: 33482 RVA: 0x002178E8 File Offset: 0x00215AE8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601550, RefRangeEnd = 601551, XrefRangeStart = 601544, XrefRangeEnd = 601550, 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: 0x060082CB RID: 33483 RVA: 0x0021794C File Offset: 0x00215B4C
		[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: 0x17002C9A RID: 11418
		// (get) Token: 0x060082CC RID: 33484 RVA: 0x002179B0 File Offset: 0x00215BB0
		// (set) Token: 0x060082CD RID: 33485 RVA: 0x00217A08 File Offset: 0x00215C08
		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: 0x060082CE RID: 33486 RVA: 0x00217A64 File Offset: 0x00215C64
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 601553, RefRangeEnd = 601555, XrefRangeStart = 601551, XrefRangeEnd = 601553, 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: 0x060082CF RID: 33487 RVA: 0x00217AA8 File Offset: 0x00215CA8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601590, RefRangeEnd = 601591, XrefRangeStart = 601555, XrefRangeEnd = 601590, 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: 0x060082D0 RID: 33488 RVA: 0x00217AF8 File Offset: 0x00215CF8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 601649, RefRangeEnd = 601650, XrefRangeStart = 601591, XrefRangeEnd = 601649, 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: 0x060082D1 RID: 33489 RVA: 0x00217B44 File Offset: 0x00215D44
		// 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, 100673247);
			IKSolverVR.NativeMethodInfoPtr_GuessHandOrientations_Public_Void_References_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673248);
			IKSolverVR.NativeMethodInfoPtr_DefaultAnimationCurves_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673249);
			IKSolverVR.NativeMethodInfoPtr_AddPositionOffset_Public_Void_PositionOffset_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673250);
			IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673251);
			IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673252);
			IKSolverVR.NativeMethodInfoPtr_AddPlatformMotion_Public_Void_Vector3_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673253);
			IKSolverVR.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673254);
			IKSolverVR.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673255);
			IKSolverVR.NativeMethodInfoPtr_FixTransforms_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673256);
			IKSolverVR.NativeMethodInfoPtr_GetPoints_Public_Virtual_Il2CppReferenceArray_1_Point_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673257);
			IKSolverVR.NativeMethodInfoPtr_GetPoint_Public_Virtual_Point_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673258);
			IKSolverVR.NativeMethodInfoPtr_IsValid_Public_Virtual_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673259);
			IKSolverVR.NativeMethodInfoPtr_GetNormal_Private_Vector3_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673260);
			IKSolverVR.NativeMethodInfoPtr_GuessWristToPalmAxis_Private_Vector3_Transform_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673261);
			IKSolverVR.NativeMethodInfoPtr_GuessPalmToThumbAxis_Private_Vector3_Transform_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673262);
			IKSolverVR.NativeMethodInfoPtr_GetSineKeyframes_Private_Static_Il2CppStructArray_1_Keyframe_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673263);
			IKSolverVR.NativeMethodInfoPtr_UpdateSolverTransforms_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673264);
			IKSolverVR.NativeMethodInfoPtr_OnInitiate_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673265);
			IKSolverVR.NativeMethodInfoPtr_OnUpdate_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673266);
			IKSolverVR.NativeMethodInfoPtr_WriteTransforms_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673267);
			IKSolverVR.NativeMethodInfoPtr_Read_Private_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673268);
			IKSolverVR.NativeMethodInfoPtr_Solve_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673269);
			IKSolverVR.NativeMethodInfoPtr_GetPosition_Private_Vector3_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673270);
			IKSolverVR.NativeMethodInfoPtr_GetRotation_Private_Quaternion_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673271);
			IKSolverVR.NativeMethodInfoPtr_get_rootBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673272);
			IKSolverVR.NativeMethodInfoPtr_set_rootBone_Private_set_Void_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673273);
			IKSolverVR.NativeMethodInfoPtr_Write_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673274);
			IKSolverVR.NativeMethodInfoPtr_GetPelvisOffset_Private_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673275);
			IKSolverVR.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673276);
		}

		// Token: 0x060082D2 RID: 33490 RVA: 0x002100C4 File Offset: 0x0020E2C4
		public IKSolverVR(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002C79 RID: 11385
		// (get) Token: 0x060082D3 RID: 33491 RVA: 0x00218060 File Offset: 0x00216260
		// (set) Token: 0x060082D4 RID: 33492 RVA: 0x00218094 File Offset: 0x00216294
		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: 0x17002C7A RID: 11386
		// (get) Token: 0x060082D5 RID: 33493 RVA: 0x002180BC File Offset: 0x002162BC
		// (set) Token: 0x060082D6 RID: 33494 RVA: 0x002180E4 File Offset: 0x002162E4
		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: 0x17002C7B RID: 11387
		// (get) Token: 0x060082D7 RID: 33495 RVA: 0x00218108 File Offset: 0x00216308
		// (set) Token: 0x060082D8 RID: 33496 RVA: 0x00218130 File Offset: 0x00216330
		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: 0x17002C7C RID: 11388
		// (get) Token: 0x060082D9 RID: 33497 RVA: 0x00218154 File Offset: 0x00216354
		// (set) Token: 0x060082DA RID: 33498 RVA: 0x0021817C File Offset: 0x0021637C
		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: 0x17002C7D RID: 11389
		// (get) Token: 0x060082DB RID: 33499 RVA: 0x002181A0 File Offset: 0x002163A0
		// (set) Token: 0x060082DC RID: 33500 RVA: 0x002181C8 File Offset: 0x002163C8
		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: 0x17002C7E RID: 11390
		// (get) Token: 0x060082DD RID: 33501 RVA: 0x002181EC File Offset: 0x002163EC
		// (set) Token: 0x060082DE RID: 33502 RVA: 0x00218220 File Offset: 0x00216420
		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: 0x17002C7F RID: 11391
		// (get) Token: 0x060082DF RID: 33503 RVA: 0x00218248 File Offset: 0x00216448
		// (set) Token: 0x060082E0 RID: 33504 RVA: 0x0021827C File Offset: 0x0021647C
		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: 0x17002C80 RID: 11392
		// (get) Token: 0x060082E1 RID: 33505 RVA: 0x002182A4 File Offset: 0x002164A4
		// (set) Token: 0x060082E2 RID: 33506 RVA: 0x002182D8 File Offset: 0x002164D8
		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: 0x17002C81 RID: 11393
		// (get) Token: 0x060082E3 RID: 33507 RVA: 0x00218300 File Offset: 0x00216500
		// (set) Token: 0x060082E4 RID: 33508 RVA: 0x00218334 File Offset: 0x00216534
		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: 0x17002C82 RID: 11394
		// (get) Token: 0x060082E5 RID: 33509 RVA: 0x0021835C File Offset: 0x0021655C
		// (set) Token: 0x060082E6 RID: 33510 RVA: 0x00218384 File Offset: 0x00216584
		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: 0x17002C83 RID: 11395
		// (get) Token: 0x060082E7 RID: 33511 RVA: 0x002183A8 File Offset: 0x002165A8
		// (set) Token: 0x060082E8 RID: 33512 RVA: 0x002183DC File Offset: 0x002165DC
		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: 0x17002C84 RID: 11396
		// (get) Token: 0x060082E9 RID: 33513 RVA: 0x00218404 File Offset: 0x00216604
		// (set) Token: 0x060082EA RID: 33514 RVA: 0x0021842C File Offset: 0x0021662C
		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: 0x17002C85 RID: 11397
		// (get) Token: 0x060082EB RID: 33515 RVA: 0x00218450 File Offset: 0x00216650
		// (set) Token: 0x060082EC RID: 33516 RVA: 0x00218478 File Offset: 0x00216678
		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: 0x17002C86 RID: 11398
		// (get) Token: 0x060082ED RID: 33517 RVA: 0x0021849C File Offset: 0x0021669C
		// (set) Token: 0x060082EE RID: 33518 RVA: 0x002184C4 File Offset: 0x002166C4
		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: 0x17002C87 RID: 11399
		// (get) Token: 0x060082EF RID: 33519 RVA: 0x002184E8 File Offset: 0x002166E8
		// (set) Token: 0x060082F0 RID: 33520 RVA: 0x00218510 File Offset: 0x00216710
		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: 0x17002C88 RID: 11400
		// (get) Token: 0x060082F1 RID: 33521 RVA: 0x00218534 File Offset: 0x00216734
		// (set) Token: 0x060082F2 RID: 33522 RVA: 0x0021855C File Offset: 0x0021675C
		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: 0x17002C89 RID: 11401
		// (get) Token: 0x060082F3 RID: 33523 RVA: 0x00218580 File Offset: 0x00216780
		// (set) Token: 0x060082F4 RID: 33524 RVA: 0x002185B4 File Offset: 0x002167B4
		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: 0x17002C8A RID: 11402
		// (get) Token: 0x060082F5 RID: 33525 RVA: 0x002185DC File Offset: 0x002167DC
		// (set) Token: 0x060082F6 RID: 33526 RVA: 0x00218610 File Offset: 0x00216810
		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: 0x17002C8B RID: 11403
		// (get) Token: 0x060082F7 RID: 33527 RVA: 0x00218638 File Offset: 0x00216838
		// (set) Token: 0x060082F8 RID: 33528 RVA: 0x0021866C File Offset: 0x0021686C
		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: 0x17002C8C RID: 11404
		// (get) Token: 0x060082F9 RID: 33529 RVA: 0x00218694 File Offset: 0x00216894
		// (set) Token: 0x060082FA RID: 33530 RVA: 0x002186C8 File Offset: 0x002168C8
		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: 0x17002C8D RID: 11405
		// (get) Token: 0x060082FB RID: 33531 RVA: 0x002186F0 File Offset: 0x002168F0
		// (set) Token: 0x060082FC RID: 33532 RVA: 0x00218724 File Offset: 0x00216924
		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: 0x17002C8E RID: 11406
		// (get) Token: 0x060082FD RID: 33533 RVA: 0x0021874C File Offset: 0x0021694C
		// (set) Token: 0x060082FE RID: 33534 RVA: 0x00218780 File Offset: 0x00216980
		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: 0x17002C8F RID: 11407
		// (get) Token: 0x060082FF RID: 33535 RVA: 0x002187A8 File Offset: 0x002169A8
		// (set) Token: 0x06008300 RID: 33536 RVA: 0x002187DC File Offset: 0x002169DC
		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: 0x17002C90 RID: 11408
		// (get) Token: 0x06008301 RID: 33537 RVA: 0x00218804 File Offset: 0x00216A04
		// (set) Token: 0x06008302 RID: 33538 RVA: 0x00218838 File Offset: 0x00216A38
		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: 0x17002C91 RID: 11409
		// (get) Token: 0x06008303 RID: 33539 RVA: 0x00218860 File Offset: 0x00216A60
		// (set) Token: 0x06008304 RID: 33540 RVA: 0x00218894 File Offset: 0x00216A94
		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: 0x17002C92 RID: 11410
		// (get) Token: 0x06008305 RID: 33541 RVA: 0x002188BC File Offset: 0x00216ABC
		// (set) Token: 0x06008306 RID: 33542 RVA: 0x002188E4 File Offset: 0x00216AE4
		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: 0x17002C93 RID: 11411
		// (get) Token: 0x06008307 RID: 33543 RVA: 0x00218908 File Offset: 0x00216B08
		// (set) Token: 0x06008308 RID: 33544 RVA: 0x00218930 File Offset: 0x00216B30
		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: 0x17002C94 RID: 11412
		// (get) Token: 0x06008309 RID: 33545 RVA: 0x00218954 File Offset: 0x00216B54
		// (set) Token: 0x0600830A RID: 33546 RVA: 0x0021897C File Offset: 0x00216B7C
		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: 0x17002C95 RID: 11413
		// (get) Token: 0x0600830B RID: 33547 RVA: 0x002189A0 File Offset: 0x00216BA0
		// (set) Token: 0x0600830C RID: 33548 RVA: 0x002189C8 File Offset: 0x00216BC8
		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: 0x17002C96 RID: 11414
		// (get) Token: 0x0600830D RID: 33549 RVA: 0x002189EC File Offset: 0x00216BEC
		// (set) Token: 0x0600830E RID: 33550 RVA: 0x00218A14 File Offset: 0x00216C14
		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: 0x17002C97 RID: 11415
		// (get) Token: 0x0600830F RID: 33551 RVA: 0x00218A38 File Offset: 0x00216C38
		// (set) Token: 0x06008310 RID: 33552 RVA: 0x00218A60 File Offset: 0x00216C60
		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: 0x17002C98 RID: 11416
		// (get) Token: 0x06008311 RID: 33553 RVA: 0x00218A84 File Offset: 0x00216C84
		// (set) Token: 0x06008312 RID: 33554 RVA: 0x00218AAC File Offset: 0x00216CAC
		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: 0x17002C99 RID: 11417
		// (get) Token: 0x06008313 RID: 33555 RVA: 0x00218AD0 File Offset: 0x00216CD0
		// (set) Token: 0x06008314 RID: 33556 RVA: 0x00218AF8 File Offset: 0x00216CF8
		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: 0x0400575B RID: 22363
		private static readonly IntPtr NativeFieldInfoPtr_solverTransforms;

		// Token: 0x0400575C RID: 22364
		private static readonly IntPtr NativeFieldInfoPtr_hasChest;

		// Token: 0x0400575D RID: 22365
		private static readonly IntPtr NativeFieldInfoPtr_hasNeck;

		// Token: 0x0400575E RID: 22366
		private static readonly IntPtr NativeFieldInfoPtr_hasShoulders;

		// Token: 0x0400575F RID: 22367
		private static readonly IntPtr NativeFieldInfoPtr_hasToes;

		// Token: 0x04005760 RID: 22368
		private static readonly IntPtr NativeFieldInfoPtr_readPositions;

		// Token: 0x04005761 RID: 22369
		private static readonly IntPtr NativeFieldInfoPtr_readRotations;

		// Token: 0x04005762 RID: 22370
		private static readonly IntPtr NativeFieldInfoPtr_solvedPositions;

		// Token: 0x04005763 RID: 22371
		private static readonly IntPtr NativeFieldInfoPtr_solvedRotations;

		// Token: 0x04005764 RID: 22372
		private static readonly IntPtr NativeFieldInfoPtr_defaultPelvisLocalPosition;

		// Token: 0x04005765 RID: 22373
		private static readonly IntPtr NativeFieldInfoPtr_defaultLocalRotations;

		// Token: 0x04005766 RID: 22374
		private static readonly IntPtr NativeFieldInfoPtr_rootV;

		// Token: 0x04005767 RID: 22375
		private static readonly IntPtr NativeFieldInfoPtr_rootVelocity;

		// Token: 0x04005768 RID: 22376
		private static readonly IntPtr NativeFieldInfoPtr_bodyOffset;

		// Token: 0x04005769 RID: 22377
		private static readonly IntPtr NativeFieldInfoPtr_supportLegIndex;

		// Token: 0x0400576A RID: 22378
		private static readonly IntPtr NativeFieldInfoPtr_plantFeet;

		// Token: 0x0400576B RID: 22379
		private static readonly IntPtr NativeFieldInfoPtr__rootBone_k__BackingField;

		// Token: 0x0400576C RID: 22380
		private static readonly IntPtr NativeFieldInfoPtr_spine;

		// Token: 0x0400576D RID: 22381
		private static readonly IntPtr NativeFieldInfoPtr_leftArm;

		// Token: 0x0400576E RID: 22382
		private static readonly IntPtr NativeFieldInfoPtr_rightArm;

		// Token: 0x0400576F RID: 22383
		private static readonly IntPtr NativeFieldInfoPtr_leftLeg;

		// Token: 0x04005770 RID: 22384
		private static readonly IntPtr NativeFieldInfoPtr_rightLeg;

		// Token: 0x04005771 RID: 22385
		private static readonly IntPtr NativeFieldInfoPtr_locomotion;

		// Token: 0x04005772 RID: 22386
		private static readonly IntPtr NativeFieldInfoPtr_legs;

		// Token: 0x04005773 RID: 22387
		private static readonly IntPtr NativeFieldInfoPtr_arms;

		// Token: 0x04005774 RID: 22388
		private static readonly IntPtr NativeFieldInfoPtr_headPosition;

		// Token: 0x04005775 RID: 22389
		private static readonly IntPtr NativeFieldInfoPtr_headDeltaPosition;

		// Token: 0x04005776 RID: 22390
		private static readonly IntPtr NativeFieldInfoPtr_raycastOriginPelvis;

		// Token: 0x04005777 RID: 22391
		private static readonly IntPtr NativeFieldInfoPtr_lastOffset;

		// Token: 0x04005778 RID: 22392
		private static readonly IntPtr NativeFieldInfoPtr_debugPos1;

		// Token: 0x04005779 RID: 22393
		private static readonly IntPtr NativeFieldInfoPtr_debugPos2;

		// Token: 0x0400577A RID: 22394
		private static readonly IntPtr NativeFieldInfoPtr_debugPos3;

		// Token: 0x0400577B RID: 22395
		private static readonly IntPtr NativeFieldInfoPtr_debugPos4;

		// Token: 0x0400577C RID: 22396
		private static readonly IntPtr NativeMethodInfoPtr_SetToReferences_Public_Void_References_0;

		// Token: 0x0400577D RID: 22397
		private static readonly IntPtr NativeMethodInfoPtr_GuessHandOrientations_Public_Void_References_Boolean_0;

		// Token: 0x0400577E RID: 22398
		private static readonly IntPtr NativeMethodInfoPtr_DefaultAnimationCurves_Public_Void_0;

		// Token: 0x0400577F RID: 22399
		private static readonly IntPtr NativeMethodInfoPtr_AddPositionOffset_Public_Void_PositionOffset_Vector3_0;

		// Token: 0x04005780 RID: 22400
		private static readonly IntPtr NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Vector3_0;

		// Token: 0x04005781 RID: 22401
		private static readonly IntPtr NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Quaternion_0;

		// Token: 0x04005782 RID: 22402
		private static readonly IntPtr NativeMethodInfoPtr_AddPlatformMotion_Public_Void_Vector3_Quaternion_Vector3_0;

		// Token: 0x04005783 RID: 22403
		private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

		// Token: 0x04005784 RID: 22404
		private static readonly IntPtr NativeMethodInfoPtr_StoreDefaultLocalState_Public_Virtual_Void_0;

		// Token: 0x04005785 RID: 22405
		private static readonly IntPtr NativeMethodInfoPtr_FixTransforms_Public_Virtual_Void_0;

		// Token: 0x04005786 RID: 22406
		private static readonly IntPtr NativeMethodInfoPtr_GetPoints_Public_Virtual_Il2CppReferenceArray_1_Point_0;

		// Token: 0x04005787 RID: 22407
		private static readonly IntPtr NativeMethodInfoPtr_GetPoint_Public_Virtual_Point_Transform_0;

		// Token: 0x04005788 RID: 22408
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Virtual_Boolean_byref_String_0;

		// Token: 0x04005789 RID: 22409
		private static readonly IntPtr NativeMethodInfoPtr_GetNormal_Private_Vector3_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x0400578A RID: 22410
		private static readonly IntPtr NativeMethodInfoPtr_GuessWristToPalmAxis_Private_Vector3_Transform_Transform_0;

		// Token: 0x0400578B RID: 22411
		private static readonly IntPtr NativeMethodInfoPtr_GuessPalmToThumbAxis_Private_Vector3_Transform_Transform_0;

		// Token: 0x0400578C RID: 22412
		private static readonly IntPtr NativeMethodInfoPtr_GetSineKeyframes_Private_Static_Il2CppStructArray_1_Keyframe_Single_0;

		// Token: 0x0400578D RID: 22413
		private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverTransforms_Private_Void_0;

		// Token: 0x0400578E RID: 22414
		private static readonly IntPtr NativeMethodInfoPtr_OnInitiate_Protected_Virtual_Void_0;

		// Token: 0x0400578F RID: 22415
		private static readonly IntPtr NativeMethodInfoPtr_OnUpdate_Protected_Virtual_Void_0;

		// Token: 0x04005790 RID: 22416
		private static readonly IntPtr NativeMethodInfoPtr_WriteTransforms_Private_Void_0;

		// Token: 0x04005791 RID: 22417
		private static readonly IntPtr NativeMethodInfoPtr_Read_Private_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_0;

		// Token: 0x04005792 RID: 22418
		private static readonly IntPtr NativeMethodInfoPtr_Solve_Private_Void_0;

		// Token: 0x04005793 RID: 22419
		private static readonly IntPtr NativeMethodInfoPtr_GetPosition_Private_Vector3_Int32_0;

		// Token: 0x04005794 RID: 22420
		private static readonly IntPtr NativeMethodInfoPtr_GetRotation_Private_Quaternion_Int32_0;

		// Token: 0x04005795 RID: 22421
		private static readonly IntPtr NativeMethodInfoPtr_get_rootBone_Public_get_VirtualBone_0;

		// Token: 0x04005796 RID: 22422
		private static readonly IntPtr NativeMethodInfoPtr_set_rootBone_Private_set_Void_VirtualBone_0;

		// Token: 0x04005797 RID: 22423
		private static readonly IntPtr NativeMethodInfoPtr_Write_Private_Void_0;

		// Token: 0x04005798 RID: 22424
		private static readonly IntPtr NativeMethodInfoPtr_GetPelvisOffset_Private_Vector3_0;

		// Token: 0x04005799 RID: 22425
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000449 RID: 1097
		[Serializable]
		public class Arm : IKSolverVR.BodyPart
		{
			// Token: 0x17002CB4 RID: 11444
			// (get) Token: 0x06008315 RID: 33557 RVA: 0x00218B1C File Offset: 0x00216D1C
			// (set) Token: 0x06008316 RID: 33558 RVA: 0x00218B6C File Offset: 0x00216D6C
			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: 0x17002CB5 RID: 11445
			// (get) Token: 0x06008317 RID: 33559 RVA: 0x00218BC0 File Offset: 0x00216DC0
			// (set) Token: 0x06008318 RID: 33560 RVA: 0x00218C10 File Offset: 0x00216E10
			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: 0x17002CB6 RID: 11446
			// (get) Token: 0x06008319 RID: 33561 RVA: 0x00218C64 File Offset: 0x00216E64
			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: 0x17002CB7 RID: 11447
			// (get) Token: 0x0600831A RID: 33562 RVA: 0x00218CBC File Offset: 0x00216EBC
			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: 0x17002CB8 RID: 11448
			// (get) Token: 0x0600831B RID: 33563 RVA: 0x00218D14 File Offset: 0x00216F14
			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: 0x17002CB9 RID: 11449
			// (get) Token: 0x0600831C RID: 33564 RVA: 0x00218D6C File Offset: 0x00216F6C
			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: 0x0600831D RID: 33565 RVA: 0x00218DC4 File Offset: 0x00216FC4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600298, XrefRangeEnd = 600346, 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: 0x0600831E RID: 33566 RVA: 0x00218EB4 File Offset: 0x002170B4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600346, XrefRangeEnd = 600357, 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: 0x0600831F RID: 33567 RVA: 0x00218F04 File Offset: 0x00217104
			[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: 0x06008320 RID: 33568 RVA: 0x00218F54 File Offset: 0x00217154
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600452, RefRangeEnd = 600453, XrefRangeStart = 600357, XrefRangeEnd = 600452, 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: 0x06008321 RID: 33569 RVA: 0x00218FA8 File Offset: 0x002171A8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600453, XrefRangeEnd = 600454, 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: 0x06008322 RID: 33570 RVA: 0x00218FF8 File Offset: 0x002171F8
			[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: 0x06008323 RID: 33571 RVA: 0x00219078 File Offset: 0x00217278
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600454, XrefRangeEnd = 600457, 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: 0x06008324 RID: 33572 RVA: 0x00219114 File Offset: 0x00217314
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 600486, RefRangeEnd = 600489, XrefRangeStart = 600457, XrefRangeEnd = 600486, 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: 0x06008325 RID: 33573 RVA: 0x00219178 File Offset: 0x00217378
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600489, XrefRangeEnd = 600494, 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: 0x06008326 RID: 33574 RVA: 0x00219214 File Offset: 0x00217414
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 600506, RefRangeEnd = 600508, XrefRangeStart = 600494, XrefRangeEnd = 600506, 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: 0x06008327 RID: 33575 RVA: 0x00219260 File Offset: 0x00217460
			// 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, 100673277);
				IKSolverVR.Arm.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673278);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673279);
				IKSolverVR.Arm.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673280);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_shoulder_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673281);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_upperArm_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673282);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_forearm_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673283);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_hand_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673284);
				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, 100673285);
				IKSolverVR.Arm.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673286);
				IKSolverVR.Arm.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673287);
				IKSolverVR.Arm.NativeMethodInfoPtr_Solve_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673288);
				IKSolverVR.Arm.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673289);
				IKSolverVR.Arm.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673290);
				IKSolverVR.Arm.NativeMethodInfoPtr_DamperValue_Private_Single_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673291);
				IKSolverVR.Arm.NativeMethodInfoPtr_GetBendNormal_Private_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673292);
				IKSolverVR.Arm.NativeMethodInfoPtr_Visualize_Private_Void_VirtualBone_VirtualBone_VirtualBone_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673293);
				IKSolverVR.Arm.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673294);
			}

			// Token: 0x06008328 RID: 33576 RVA: 0x002195E7 File Offset: 0x002177E7
			public Arm(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002C9B RID: 11419
			// (get) Token: 0x06008329 RID: 33577 RVA: 0x002195F0 File Offset: 0x002177F0
			// (set) Token: 0x0600832A RID: 33578 RVA: 0x00219624 File Offset: 0x00217824
			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: 0x17002C9C RID: 11420
			// (get) Token: 0x0600832B RID: 33579 RVA: 0x0021964C File Offset: 0x0021784C
			// (set) Token: 0x0600832C RID: 33580 RVA: 0x00219680 File Offset: 0x00217880
			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: 0x17002C9D RID: 11421
			// (get) Token: 0x0600832D RID: 33581 RVA: 0x002196A8 File Offset: 0x002178A8
			// (set) Token: 0x0600832E RID: 33582 RVA: 0x002196D0 File Offset: 0x002178D0
			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: 0x17002C9E RID: 11422
			// (get) Token: 0x0600832F RID: 33583 RVA: 0x002196F4 File Offset: 0x002178F4
			// (set) Token: 0x06008330 RID: 33584 RVA: 0x0021971C File Offset: 0x0021791C
			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: 0x17002C9F RID: 11423
			// (get) Token: 0x06008331 RID: 33585 RVA: 0x00219740 File Offset: 0x00217940
			// (set) Token: 0x06008332 RID: 33586 RVA: 0x00219768 File Offset: 0x00217968
			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: 0x17002CA0 RID: 11424
			// (get) Token: 0x06008333 RID: 33587 RVA: 0x0021978C File Offset: 0x0021798C
			// (set) Token: 0x06008334 RID: 33588 RVA: 0x002197B4 File Offset: 0x002179B4
			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: 0x17002CA1 RID: 11425
			// (get) Token: 0x06008335 RID: 33589 RVA: 0x002197D8 File Offset: 0x002179D8
			// (set) Token: 0x06008336 RID: 33590 RVA: 0x00219800 File Offset: 0x00217A00
			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: 0x17002CA2 RID: 11426
			// (get) Token: 0x06008337 RID: 33591 RVA: 0x00219824 File Offset: 0x00217A24
			// (set) Token: 0x06008338 RID: 33592 RVA: 0x0021984C File Offset: 0x00217A4C
			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: 0x17002CA3 RID: 11427
			// (get) Token: 0x06008339 RID: 33593 RVA: 0x00219870 File Offset: 0x00217A70
			// (set) Token: 0x0600833A RID: 33594 RVA: 0x00219898 File Offset: 0x00217A98
			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: 0x17002CA4 RID: 11428
			// (get) Token: 0x0600833B RID: 33595 RVA: 0x002198BC File Offset: 0x00217ABC
			// (set) Token: 0x0600833C RID: 33596 RVA: 0x002198E4 File Offset: 0x00217AE4
			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: 0x17002CA5 RID: 11429
			// (get) Token: 0x0600833D RID: 33597 RVA: 0x00219908 File Offset: 0x00217B08
			// (set) Token: 0x0600833E RID: 33598 RVA: 0x00219930 File Offset: 0x00217B30
			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: 0x17002CA6 RID: 11430
			// (get) Token: 0x0600833F RID: 33599 RVA: 0x00219954 File Offset: 0x00217B54
			// (set) Token: 0x06008340 RID: 33600 RVA: 0x0021997C File Offset: 0x00217B7C
			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: 0x17002CA7 RID: 11431
			// (get) Token: 0x06008341 RID: 33601 RVA: 0x002199A0 File Offset: 0x00217BA0
			// (set) Token: 0x06008342 RID: 33602 RVA: 0x002199C8 File Offset: 0x00217BC8
			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: 0x17002CA8 RID: 11432
			// (get) Token: 0x06008343 RID: 33603 RVA: 0x002199EC File Offset: 0x00217BEC
			// (set) Token: 0x06008344 RID: 33604 RVA: 0x00219A14 File Offset: 0x00217C14
			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: 0x17002CA9 RID: 11433
			// (get) Token: 0x06008345 RID: 33605 RVA: 0x00219A38 File Offset: 0x00217C38
			// (set) Token: 0x06008346 RID: 33606 RVA: 0x00219A60 File Offset: 0x00217C60
			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: 0x17002CAA RID: 11434
			// (get) Token: 0x06008347 RID: 33607 RVA: 0x00219A84 File Offset: 0x00217C84
			// (set) Token: 0x06008348 RID: 33608 RVA: 0x00219AAC File Offset: 0x00217CAC
			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: 0x17002CAB RID: 11435
			// (get) Token: 0x06008349 RID: 33609 RVA: 0x00219AD0 File Offset: 0x00217CD0
			// (set) Token: 0x0600834A RID: 33610 RVA: 0x00219AF8 File Offset: 0x00217CF8
			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: 0x17002CAC RID: 11436
			// (get) Token: 0x0600834B RID: 33611 RVA: 0x00219B1C File Offset: 0x00217D1C
			// (set) Token: 0x0600834C RID: 33612 RVA: 0x00219B44 File Offset: 0x00217D44
			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: 0x17002CAD RID: 11437
			// (get) Token: 0x0600834D RID: 33613 RVA: 0x00219B68 File Offset: 0x00217D68
			// (set) Token: 0x0600834E RID: 33614 RVA: 0x00219B90 File Offset: 0x00217D90
			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: 0x17002CAE RID: 11438
			// (get) Token: 0x0600834F RID: 33615 RVA: 0x00219BB4 File Offset: 0x00217DB4
			// (set) Token: 0x06008350 RID: 33616 RVA: 0x00219BDC File Offset: 0x00217DDC
			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: 0x17002CAF RID: 11439
			// (get) Token: 0x06008351 RID: 33617 RVA: 0x00219C00 File Offset: 0x00217E00
			// (set) Token: 0x06008352 RID: 33618 RVA: 0x00219C28 File Offset: 0x00217E28
			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: 0x17002CB0 RID: 11440
			// (get) Token: 0x06008353 RID: 33619 RVA: 0x00219C4C File Offset: 0x00217E4C
			// (set) Token: 0x06008354 RID: 33620 RVA: 0x00219C74 File Offset: 0x00217E74
			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: 0x17002CB1 RID: 11441
			// (get) Token: 0x06008355 RID: 33621 RVA: 0x00219C98 File Offset: 0x00217E98
			// (set) Token: 0x06008356 RID: 33622 RVA: 0x00219CC0 File Offset: 0x00217EC0
			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: 0x17002CB2 RID: 11442
			// (get) Token: 0x06008357 RID: 33623 RVA: 0x00219CE4 File Offset: 0x00217EE4
			// (set) Token: 0x06008358 RID: 33624 RVA: 0x00219D02 File Offset: 0x00217F02
			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: 0x17002CB3 RID: 11443
			// (get) Token: 0x06008359 RID: 33625 RVA: 0x00219D14 File Offset: 0x00217F14
			// (set) Token: 0x0600835A RID: 33626 RVA: 0x00219D32 File Offset: 0x00217F32
			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: 0x0400579A RID: 22426
			private static readonly IntPtr NativeFieldInfoPtr_target;

			// Token: 0x0400579B RID: 22427
			private static readonly IntPtr NativeFieldInfoPtr_bendGoal;

			// Token: 0x0400579C RID: 22428
			private static readonly IntPtr NativeFieldInfoPtr_positionWeight;

			// Token: 0x0400579D RID: 22429
			private static readonly IntPtr NativeFieldInfoPtr_rotationWeight;

			// Token: 0x0400579E RID: 22430
			private static readonly IntPtr NativeFieldInfoPtr_shoulderRotationMode;

			// Token: 0x0400579F RID: 22431
			private static readonly IntPtr NativeFieldInfoPtr_shoulderRotationWeight;

			// Token: 0x040057A0 RID: 22432
			private static readonly IntPtr NativeFieldInfoPtr_bendGoalWeight;

			// Token: 0x040057A1 RID: 22433
			private static readonly IntPtr NativeFieldInfoPtr_swivelOffset;

			// Token: 0x040057A2 RID: 22434
			private static readonly IntPtr NativeFieldInfoPtr_wristToPalmAxis;

			// Token: 0x040057A3 RID: 22435
			private static readonly IntPtr NativeFieldInfoPtr_palmToThumbAxis;

			// Token: 0x040057A4 RID: 22436
			private static readonly IntPtr NativeFieldInfoPtr_IKPosition;

			// Token: 0x040057A5 RID: 22437
			private static readonly IntPtr NativeFieldInfoPtr_IKRotation;

			// Token: 0x040057A6 RID: 22438
			private static readonly IntPtr NativeFieldInfoPtr_bendDirection;

			// Token: 0x040057A7 RID: 22439
			private static readonly IntPtr NativeFieldInfoPtr_handPositionOffset;

			// Token: 0x040057A8 RID: 22440
			private static readonly IntPtr NativeFieldInfoPtr__position_k__BackingField;

			// Token: 0x040057A9 RID: 22441
			private static readonly IntPtr NativeFieldInfoPtr__rotation_k__BackingField;

			// Token: 0x040057AA RID: 22442
			private static readonly IntPtr NativeFieldInfoPtr_hasShoulder;

			// Token: 0x040057AB RID: 22443
			private static readonly IntPtr NativeFieldInfoPtr_chestForwardAxis;

			// Token: 0x040057AC RID: 22444
			private static readonly IntPtr NativeFieldInfoPtr_chestUpAxis;

			// Token: 0x040057AD RID: 22445
			private static readonly IntPtr NativeFieldInfoPtr_chestRotation;

			// Token: 0x040057AE RID: 22446
			private static readonly IntPtr NativeFieldInfoPtr_chestForward;

			// Token: 0x040057AF RID: 22447
			private static readonly IntPtr NativeFieldInfoPtr_chestUp;

			// Token: 0x040057B0 RID: 22448
			private static readonly IntPtr NativeFieldInfoPtr_forearmRelToUpperArm;

			// Token: 0x040057B1 RID: 22449
			private static readonly IntPtr NativeFieldInfoPtr_yawOffsetAngle;

			// Token: 0x040057B2 RID: 22450
			private static readonly IntPtr NativeFieldInfoPtr_pitchOffsetAngle;

			// Token: 0x040057B3 RID: 22451
			private static readonly IntPtr NativeMethodInfoPtr_get_position_Public_get_Vector3_0;

			// Token: 0x040057B4 RID: 22452
			private static readonly IntPtr NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0;

			// Token: 0x040057B5 RID: 22453
			private static readonly IntPtr NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0;

			// Token: 0x040057B6 RID: 22454
			private static readonly IntPtr NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0;

			// Token: 0x040057B7 RID: 22455
			private static readonly IntPtr NativeMethodInfoPtr_get_shoulder_Private_get_VirtualBone_0;

			// Token: 0x040057B8 RID: 22456
			private static readonly IntPtr NativeMethodInfoPtr_get_upperArm_Private_get_VirtualBone_0;

			// Token: 0x040057B9 RID: 22457
			private static readonly IntPtr NativeMethodInfoPtr_get_forearm_Private_get_VirtualBone_0;

			// Token: 0x040057BA RID: 22458
			private static readonly IntPtr NativeMethodInfoPtr_get_hand_Private_get_VirtualBone_0;

			// Token: 0x040057BB RID: 22459
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x040057BC RID: 22460
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0;

			// Token: 0x040057BD RID: 22461
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0;

			// Token: 0x040057BE RID: 22462
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_Boolean_0;

			// Token: 0x040057BF RID: 22463
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0;

			// Token: 0x040057C0 RID: 22464
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x040057C1 RID: 22465
			private static readonly IntPtr NativeMethodInfoPtr_DamperValue_Private_Single_Single_Single_Single_Single_0;

			// Token: 0x040057C2 RID: 22466
			private static readonly IntPtr NativeMethodInfoPtr_GetBendNormal_Private_Vector3_Vector3_0;

			// Token: 0x040057C3 RID: 22467
			private static readonly IntPtr NativeMethodInfoPtr_Visualize_Private_Void_VirtualBone_VirtualBone_VirtualBone_Color_0;

			// Token: 0x040057C4 RID: 22468
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x0200044A RID: 1098
			[Serializable]
			public enum ShoulderRotationMode
			{
				// Token: 0x040057C6 RID: 22470
				YawPitch,
				// Token: 0x040057C7 RID: 22471
				FromTo
			}
		}

		// Token: 0x0200044B RID: 1099
		[Serializable]
		public class BodyPart : Il2CppSystem.Object
		{
			// Token: 0x0600835B RID: 33627 RVA: 0x00219D44 File Offset: 0x00217F44
			[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: 0x0600835C RID: 33628 RVA: 0x00219E34 File Offset: 0x00218034
			[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: 0x0600835D RID: 33629 RVA: 0x00219E84 File Offset: 0x00218084
			[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: 0x0600835E RID: 33630 RVA: 0x00219F04 File Offset: 0x00218104
			[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: 0x0600835F RID: 33631 RVA: 0x00219F54 File Offset: 0x00218154
			[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: 0x17002CC1 RID: 11457
			// (get) Token: 0x06008360 RID: 33632 RVA: 0x00219FA4 File Offset: 0x002181A4
			// (set) Token: 0x06008361 RID: 33633 RVA: 0x00219FF4 File Offset: 0x002181F4
			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: 0x17002CC2 RID: 11458
			// (get) Token: 0x06008362 RID: 33634 RVA: 0x0021A048 File Offset: 0x00218248
			// (set) Token: 0x06008363 RID: 33635 RVA: 0x0021A098 File Offset: 0x00218298
			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: 0x06008364 RID: 33636 RVA: 0x0021A0EC File Offset: 0x002182EC
			[CallerCount(6)]
			[CachedScanResults(RefRangeStart = 600509, RefRangeEnd = 600515, XrefRangeStart = 600508, XrefRangeEnd = 600509, 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: 0x06008365 RID: 33637 RVA: 0x0021A1D0 File Offset: 0x002183D0
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 600516, RefRangeEnd = 600519, XrefRangeStart = 600515, XrefRangeEnd = 600516, 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: 0x06008366 RID: 33638 RVA: 0x0021A224 File Offset: 0x00218424
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600519, XrefRangeEnd = 600521, 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: 0x06008367 RID: 33639 RVA: 0x0021A278 File Offset: 0x00218478
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600521, XrefRangeEnd = 600524, 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: 0x06008368 RID: 33640 RVA: 0x0021A2E0 File Offset: 0x002184E0
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 600527, RefRangeEnd = 600530, XrefRangeStart = 600524, XrefRangeEnd = 600527, 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: 0x06008369 RID: 33641 RVA: 0x0021A348 File Offset: 0x00218548
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 600535, RefRangeEnd = 600538, XrefRangeStart = 600530, XrefRangeEnd = 600535, 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: 0x0600836A RID: 33642 RVA: 0x0021A3C8 File Offset: 0x002185C8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600538, XrefRangeEnd = 600543, 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: 0x0600836B RID: 33643 RVA: 0x0021A41C File Offset: 0x0021861C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600543, XrefRangeEnd = 600549, 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: 0x0600836C RID: 33644 RVA: 0x0021A460 File Offset: 0x00218660
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600549, XrefRangeEnd = 600555, 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: 0x0600836D RID: 33645 RVA: 0x0021A4AC File Offset: 0x002186AC
			// 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, 100673295);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_PreSolve_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673296);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Write_Public_Abstract_Virtual_New_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673297);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_ApplyOffsets_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673298);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_ResetOffsets_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673299);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_get_sqrMag_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673300);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_set_sqrMag_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673301);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_get_mag_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673302);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_set_mag_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673303);
				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, 100673304);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_MovePosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673305);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_MoveRotation_Public_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673306);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Translate_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673307);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_TranslateRoot_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673308);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_RotateTo_Public_Void_VirtualBone_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673309);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673310);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673311);
				IKSolverVR.BodyPart.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100673312);
			}

			// Token: 0x0600836E RID: 33646 RVA: 0x0000A688 File Offset: 0x00008888
			public BodyPart(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002CBA RID: 11450
			// (get) Token: 0x0600836F RID: 33647 RVA: 0x0021A6CC File Offset: 0x002188CC
			// (set) Token: 0x06008370 RID: 33648 RVA: 0x0021A6F4 File Offset: 0x002188F4
			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: 0x17002CBB RID: 11451
			// (get) Token: 0x06008371 RID: 33649 RVA: 0x0021A718 File Offset: 0x00218918
			// (set) Token: 0x06008372 RID: 33650 RVA: 0x0021A740 File Offset: 0x00218940
			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: 0x17002CBC RID: 11452
			// (get) Token: 0x06008373 RID: 33651 RVA: 0x0021A764 File Offset: 0x00218964
			// (set) Token: 0x06008374 RID: 33652 RVA: 0x0021A798 File Offset: 0x00218998
			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: 0x17002CBD RID: 11453
			// (get) Token: 0x06008375 RID: 33653 RVA: 0x0021A7C0 File Offset: 0x002189C0
			// (set) Token: 0x06008376 RID: 33654 RVA: 0x0021A7E8 File Offset: 0x002189E8
			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: 0x17002CBE RID: 11454
			// (get) Token: 0x06008377 RID: 33655 RVA: 0x0021A80C File Offset: 0x00218A0C
			// (set) Token: 0x06008378 RID: 33656 RVA: 0x0021A834 File Offset: 0x00218A34
			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: 0x17002CBF RID: 11455
			// (get) Token: 0x06008379 RID: 33657 RVA: 0x0021A858 File Offset: 0x00218A58
			// (set) Token: 0x0600837A RID: 33658 RVA: 0x0021A880 File Offset: 0x00218A80
			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: 0x17002CC0 RID: 11456
			// (get) Token: 0x0600837B RID: 33659 RVA: 0x0021A8A4 File Offset: 0x00218AA4
			// (set) Token: 0x0600837C RID: 33660 RVA: 0x0021A8CC File Offset: 0x00218ACC
			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: 0x040057C8 RID: 22472
			private static readonly IntPtr NativeFieldInfoPtr__sqrMag_k__BackingField;

			// Token: 0x040057C9 RID: 22473
			private static readonly IntPtr NativeFieldInfoPtr__mag_k__BackingField;

			// Token: 0x040057CA RID: 22474
			private static readonly IntPtr NativeFieldInfoPtr_bones;

			// Token: 0x040057CB RID: 22475
			private static readonly IntPtr NativeFieldInfoPtr_initiated;

			// Token: 0x040057CC RID: 22476
			private static readonly IntPtr NativeFieldInfoPtr_rootPosition;

			// Token: 0x040057CD RID: 22477
			private static readonly IntPtr NativeFieldInfoPtr_rootRotation;

			// Token: 0x040057CE RID: 22478
			private static readonly IntPtr NativeFieldInfoPtr_index;

			// Token: 0x040057CF RID: 22479
			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: 0x040057D0 RID: 22480
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Abstract_Virtual_New_Void_0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x0200044C RID: 1100
		[Serializable]
		public class Footstep : Il2CppSystem.Object
		{
			// Token: 0x17002CD1 RID: 11473
			// (get) Token: 0x0600837D RID: 33661 RVA: 0x0021A8F0 File Offset: 0x00218AF0
			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: 0x17002CD2 RID: 11474
			// (get) Token: 0x0600837E RID: 33662 RVA: 0x0021A940 File Offset: 0x00218B40
			// (set) Token: 0x0600837F RID: 33663 RVA: 0x0021A990 File Offset: 0x00218B90
			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 = 218263, RefRangeEnd = 218265, XrefRangeStart = 218263, XrefRangeEnd = 218265, 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: 0x06008380 RID: 33664 RVA: 0x0021A9E4 File Offset: 0x00218BE4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600555, XrefRangeEnd = 600563, 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: 0x06008381 RID: 33665 RVA: 0x0021AA7C File Offset: 0x00218C7C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600563, XrefRangeEnd = 600565, 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: 0x06008382 RID: 33666 RVA: 0x0021AAF8 File Offset: 0x00218CF8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600565, XrefRangeEnd = 600566, 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: 0x06008383 RID: 33667 RVA: 0x0021AB60 File Offset: 0x00218D60
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600573, RefRangeEnd = 600574, XrefRangeStart = 600566, XrefRangeEnd = 600573, 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: 0x06008384 RID: 33668 RVA: 0x0021ABDC File Offset: 0x00218DDC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600582, RefRangeEnd = 600583, XrefRangeStart = 600574, XrefRangeEnd = 600582, 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: 0x06008385 RID: 33669 RVA: 0x0021AC58 File Offset: 0x00218E58
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 600591, RefRangeEnd = 600593, XrefRangeStart = 600583, XrefRangeEnd = 600591, 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: 0x06008386 RID: 33670 RVA: 0x0021ACC4 File Offset: 0x00218EC4
			// 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, 100673313);
				IKSolverVR.Footstep.NativeMethodInfoPtr_get_stepProgress_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673314);
				IKSolverVR.Footstep.NativeMethodInfoPtr_set_stepProgress_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673315);
				IKSolverVR.Footstep.NativeMethodInfoPtr__ctor_Public_Void_Quaternion_Vector3_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673316);
				IKSolverVR.Footstep.NativeMethodInfoPtr_Reset_Public_Void_Quaternion_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673317);
				IKSolverVR.Footstep.NativeMethodInfoPtr_StepTo_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673318);
				IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStepping_Public_Void_Vector3_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673319);
				IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStanding_Public_Void_Quaternion_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673320);
				IKSolverVR.Footstep.NativeMethodInfoPtr_Update_Public_Void_InterpolationMode_UnityEvent_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100673321);
			}

			// Token: 0x06008387 RID: 33671 RVA: 0x0000A688 File Offset: 0x00008888
			public Footstep(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002CC3 RID: 11459
			// (get) Token: 0x06008388 RID: 33672 RVA: 0x0021AEBC File Offset: 0x002190BC
			// (set) Token: 0x06008389 RID: 33673 RVA: 0x0021AEE4 File Offset: 0x002190E4
			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: 0x17002CC4 RID: 11460
			// (get) Token: 0x0600838A RID: 33674 RVA: 0x0021AF08 File Offset: 0x00219108
			// (set) Token: 0x0600838B RID: 33675 RVA: 0x0021AF30 File Offset: 0x00219130
			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: 0x17002CC5 RID: 11461
			// (get) Token: 0x0600838C RID: 33676 RVA: 0x0021AF54 File Offset: 0x00219154
			// (set) Token: 0x0600838D RID: 33677 RVA: 0x0021AF7C File Offset: 0x0021917C
			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: 0x17002CC6 RID: 11462
			// (get) Token: 0x0600838E RID: 33678 RVA: 0x0021AFA0 File Offset: 0x002191A0
			// (set) Token: 0x0600838F RID: 33679 RVA: 0x0021AFC8 File Offset: 0x002191C8
			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: 0x17002CC7 RID: 11463
			// (get) Token: 0x06008390 RID: 33680 RVA: 0x0021AFEC File Offset: 0x002191EC
			// (set) Token: 0x06008391 RID: 33681 RVA: 0x0021B014 File Offset: 0x00219214
			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: 0x17002CC8 RID: 11464
			// (get) Token: 0x06008392 RID: 33682 RVA: 0x0021B038 File Offset: 0x00219238
			// (set) Token: 0x06008393 RID: 33683 RVA: 0x0021B060 File Offset: 0x00219260
			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: 0x17002CC9 RID: 11465
			// (get) Token: 0x06008394 RID: 33684 RVA: 0x0021B084 File Offset: 0x00219284
			// (set) Token: 0x06008395 RID: 33685 RVA: 0x0021B0AC File Offset: 0x002192AC
			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: 0x17002CCA RID: 11466
			// (get) Token: 0x06008396 RID: 33686 RVA: 0x0021B0D0 File Offset: 0x002192D0
			// (set) Token: 0x06008397 RID: 33687 RVA: 0x0021B0F8 File Offset: 0x002192F8
			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: 0x17002CCB RID: 11467
			// (get) Token: 0x06008398 RID: 33688 RVA: 0x0021B11C File Offset: 0x0021931C
			// (set) Token: 0x06008399 RID: 33689 RVA: 0x0021B144 File Offset: 0x00219344
			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: 0x17002CCC RID: 11468
			// (get) Token: 0x0600839A RID: 33690 RVA: 0x0021B168 File Offset: 0x00219368
			// (set) Token: 0x0600839B RID: 33691 RVA: 0x0021B190 File Offset: 0x00219390
			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: 0x17002CCD RID: 11469
			// (get) Token: 0x0600839C RID: 33692 RVA: 0x0021B1B4 File Offset: 0x002193B4
			// (set) Token: 0x0600839D RID: 33693 RVA: 0x0021B1DC File Offset: 0x002193DC
			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: 0x17002CCE RID: 11470
			// (get) Token: 0x0600839E RID: 33694 RVA: 0x0021B200 File Offset: 0x00219400
			// (set) Token: 0x0600839F RID: 33695 RVA: 0x0021B228 File Offset: 0x00219428
			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: 0x17002CCF RID: 11471
			// (get) Token: 0x060083A0 RID: 33696 RVA: 0x0021B24C File Offset: 0x0021944C
			// (set) Token: 0x060083A1 RID: 33697 RVA: 0x0021B274 File Offset: 0x00219474
			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: 0x17002CD0 RID: 11472
			// (get) Token: 0x060083A2 RID: 33698 RVA: 0x0021B298 File Offset: 0x00219498
			// (set) Token: 0x060083A3 RID: 33699 RVA: 0x0021B2C0 File Offset: 0x002194C0
			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: 0x040057E1 RID: 22497
			private static readonly IntPtr NativeFieldInfoPtr_stepSpeed;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x0200044D RID: 1101
		[Serializable]
		public class Leg : IKSolverVR.BodyPart
		{
			// Token: 0x17002CE7 RID: 11495
			// (get) Token: 0x060083A4 RID: 33700 RVA: 0x0021B2E4 File Offset: 0x002194E4
			// (set) Token: 0x060083A5 RID: 33701 RVA: 0x0021B334 File Offset: 0x00219534
			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: 0x17002CE8 RID: 11496
			// (get) Token: 0x060083A6 RID: 33702 RVA: 0x0021B388 File Offset: 0x00219588
			// (set) Token: 0x060083A7 RID: 33703 RVA: 0x0021B3D8 File Offset: 0x002195D8
			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: 0x17002CE9 RID: 11497
			// (get) Token: 0x060083A8 RID: 33704 RVA: 0x0021B42C File Offset: 0x0021962C
			// (set) Token: 0x060083A9 RID: 33705 RVA: 0x0021B47C File Offset: 0x0021967C
			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: 0x17002CEA RID: 11498
			// (get) Token: 0x060083AA RID: 33706 RVA: 0x0021B4D0 File Offset: 0x002196D0
			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: 0x17002CEB RID: 11499
			// (get) Token: 0x060083AB RID: 33707 RVA: 0x0021B528 File Offset: 0x00219728
			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: 0x17002CEC RID: 11500
			// (get) Token: 0x060083AC RID: 33708 RVA: 0x0021B580 File Offset: 0x00219780
			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: 0x17002CED RID: 11501
			// (get) Token: 0x060083AD RID: 33709 RVA: 0x0021B5D8 File Offset: 0x002197D8
			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: 0x17002CEE RID: 11502
			// (get) Token: 0x060083AE RID: 33710 RVA: 0x0021B630 File Offset: 0x00219830
			public unsafe IKSolverVR.VirtualBone lastBone
			{
				[CallerCount(5)]
				[CachedScanResults(RefRangeStart = 600593, RefRangeEnd = 600598, XrefRangeStart = 600593, XrefRangeEnd = 600593, 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: 0x17002CEF RID: 11503
			// (get) Token: 0x060083AF RID: 33711 RVA: 0x0021B688 File Offset: 0x00219888
			// (set) Token: 0x060083B0 RID: 33712 RVA: 0x0021B6D8 File Offset: 0x002198D8
			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: 0x060083B1 RID: 33713 RVA: 0x0021B72C File Offset: 0x0021992C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600598, XrefRangeEnd = 600636, 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: 0x060083B2 RID: 33714 RVA: 0x0021B81C File Offset: 0x00219A1C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600636, XrefRangeEnd = 600650, 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: 0x060083B3 RID: 33715 RVA: 0x0021B86C File Offset: 0x00219A6C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600650, XrefRangeEnd = 600670, 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: 0x060083B4 RID: 33716 RVA: 0x0021B8BC File Offset: 0x00219ABC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 600670, RefRangeEnd = 600672, XrefRangeStart = 600670, XrefRangeEnd = 600670, 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: 0x060083B5 RID: 33717 RVA: 0x0021B924 File Offset: 0x00219B24
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 600678, RefRangeEnd = 600680, XrefRangeStart = 600672, XrefRangeEnd = 600678, 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: 0x060083B6 RID: 33718 RVA: 0x0021B98C File Offset: 0x00219B8C
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 600689, RefRangeEnd = 600693, XrefRangeStart = 600680, XrefRangeEnd = 600689, 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: 0x060083B7 RID: 33719 RVA: 0x0021B9D0 File Offset: 0x00219BD0
			[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: 0x060083B8 RID: 33720 RVA: 0x0021BA50 File Offset: 0x00219C50
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600693, XrefRangeEnd = 600696, 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: 0x060083B9 RID: 33721 RVA: 0x0021BAA0 File Offset: 0x00219CA0
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 600706, RefRangeEnd = 600709, XrefRangeStart = 600696, XrefRangeEnd = 600706, 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: 0x060083BA RID: 33722 RVA: 0x0021BAEC File Offset: 0x00219CEC
			// 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, 100673322);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673323);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673324);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673325);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_hasToes_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673326);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_hasToes_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673327);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_thigh_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673328);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_calf_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673329);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_foot_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673330);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_toes_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673331);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_lastBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673332);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_thighRelativeToPelvis_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673333);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_thighRelativeToPelvis_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673334);
				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, 100673335);
				IKSolverVR.Leg.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673336);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673337);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyPositionOffset_Private_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673338);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyRotationOffset_Private_Void_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673339);
				IKSolverVR.Leg.NativeMethodInfoPtr_Solve_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673340);
				IKSolverVR.Leg.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673341);
				IKSolverVR.Leg.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673342);
				IKSolverVR.Leg.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100673343);
			}

			// Token: 0x060083BB RID: 33723 RVA: 0x002195E7 File Offset: 0x002177E7
			public Leg(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002CD3 RID: 11475
			// (get) Token: 0x060083BC RID: 33724 RVA: 0x0021BE60 File Offset: 0x0021A060
			// (set) Token: 0x060083BD RID: 33725 RVA: 0x0021BE94 File Offset: 0x0021A094
			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: 0x17002CD4 RID: 11476
			// (get) Token: 0x060083BE RID: 33726 RVA: 0x0021BEBC File Offset: 0x0021A0BC
			// (set) Token: 0x060083BF RID: 33727 RVA: 0x0021BEF0 File Offset: 0x0021A0F0
			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: 0x17002CD5 RID: 11477
			// (get) Token: 0x060083C0 RID: 33728 RVA: 0x0021BF18 File Offset: 0x0021A118
			// (set) Token: 0x060083C1 RID: 33729 RVA: 0x0021BF40 File Offset: 0x0021A140
			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: 0x17002CD6 RID: 11478
			// (get) Token: 0x060083C2 RID: 33730 RVA: 0x0021BF64 File Offset: 0x0021A164
			// (set) Token: 0x060083C3 RID: 33731 RVA: 0x0021BF8C File Offset: 0x0021A18C
			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: 0x17002CD7 RID: 11479
			// (get) Token: 0x060083C4 RID: 33732 RVA: 0x0021BFB0 File Offset: 0x0021A1B0
			// (set) Token: 0x060083C5 RID: 33733 RVA: 0x0021BFD8 File Offset: 0x0021A1D8
			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: 0x17002CD8 RID: 11480
			// (get) Token: 0x060083C6 RID: 33734 RVA: 0x0021BFFC File Offset: 0x0021A1FC
			// (set) Token: 0x060083C7 RID: 33735 RVA: 0x0021C024 File Offset: 0x0021A224
			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: 0x17002CD9 RID: 11481
			// (get) Token: 0x060083C8 RID: 33736 RVA: 0x0021C048 File Offset: 0x0021A248
			// (set) Token: 0x060083C9 RID: 33737 RVA: 0x0021C070 File Offset: 0x0021A270
			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: 0x17002CDA RID: 11482
			// (get) Token: 0x060083CA RID: 33738 RVA: 0x0021C094 File Offset: 0x0021A294
			// (set) Token: 0x060083CB RID: 33739 RVA: 0x0021C0BC File Offset: 0x0021A2BC
			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: 0x17002CDB RID: 11483
			// (get) Token: 0x060083CC RID: 33740 RVA: 0x0021C0E0 File Offset: 0x0021A2E0
			// (set) Token: 0x060083CD RID: 33741 RVA: 0x0021C108 File Offset: 0x0021A308
			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: 0x17002CDC RID: 11484
			// (get) Token: 0x060083CE RID: 33742 RVA: 0x0021C12C File Offset: 0x0021A32C
			// (set) Token: 0x060083CF RID: 33743 RVA: 0x0021C154 File Offset: 0x0021A354
			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: 0x17002CDD RID: 11485
			// (get) Token: 0x060083D0 RID: 33744 RVA: 0x0021C178 File Offset: 0x0021A378
			// (set) Token: 0x060083D1 RID: 33745 RVA: 0x0021C1A0 File Offset: 0x0021A3A0
			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: 0x17002CDE RID: 11486
			// (get) Token: 0x060083D2 RID: 33746 RVA: 0x0021C1C4 File Offset: 0x0021A3C4
			// (set) Token: 0x060083D3 RID: 33747 RVA: 0x0021C1EC File Offset: 0x0021A3EC
			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: 0x17002CDF RID: 11487
			// (get) Token: 0x060083D4 RID: 33748 RVA: 0x0021C210 File Offset: 0x0021A410
			// (set) Token: 0x060083D5 RID: 33749 RVA: 0x0021C238 File Offset: 0x0021A438
			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: 0x17002CE0 RID: 11488
			// (get) Token: 0x060083D6 RID: 33750 RVA: 0x0021C25C File Offset: 0x0021A45C
			// (set) Token: 0x060083D7 RID: 33751 RVA: 0x0021C284 File Offset: 0x0021A484
			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: 0x17002CE1 RID: 11489
			// (get) Token: 0x060083D8 RID: 33752 RVA: 0x0021C2A8 File Offset: 0x0021A4A8
			// (set) Token: 0x060083D9 RID: 33753 RVA: 0x0021C2D0 File Offset: 0x0021A4D0
			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: 0x17002CE2 RID: 11490
			// (get) Token: 0x060083DA RID: 33754 RVA: 0x0021C2F4 File Offset: 0x0021A4F4
			// (set) Token: 0x060083DB RID: 33755 RVA: 0x0021C31C File Offset: 0x0021A51C
			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: 0x17002CE3 RID: 11491
			// (get) Token: 0x060083DC RID: 33756 RVA: 0x0021C340 File Offset: 0x0021A540
			// (set) Token: 0x060083DD RID: 33757 RVA: 0x0021C368 File Offset: 0x0021A568
			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: 0x17002CE4 RID: 11492
			// (get) Token: 0x060083DE RID: 33758 RVA: 0x0021C38C File Offset: 0x0021A58C
			// (set) Token: 0x060083DF RID: 33759 RVA: 0x0021C3B4 File Offset: 0x0021A5B4
			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: 0x17002CE5 RID: 11493
			// (get) Token: 0x060083E0 RID: 33760 RVA: 0x0021C3D8 File Offset: 0x0021A5D8
			// (set) Token: 0x060083E1 RID: 33761 RVA: 0x0021C400 File Offset: 0x0021A600
			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: 0x17002CE6 RID: 11494
			// (get) Token: 0x060083E2 RID: 33762 RVA: 0x0021C424 File Offset: 0x0021A624
			// (set) Token: 0x060083E3 RID: 33763 RVA: 0x0021C44C File Offset: 0x0021A64C
			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: 0x040057F8 RID: 22520
			private static readonly IntPtr NativeFieldInfoPtr_target;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x0200044E RID: 1102
		[Serializable]
		public class Locomotion : Il2CppSystem.Object
		{
			// Token: 0x17002D0C RID: 11532
			// (get) Token: 0x060083E4 RID: 33764 RVA: 0x0021C470 File Offset: 0x0021A670
			// (set) Token: 0x060083E5 RID: 33765 RVA: 0x0021C4C0 File Offset: 0x0021A6C0
			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: 0x060083E6 RID: 33766 RVA: 0x0021C514 File Offset: 0x0021A714
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600761, RefRangeEnd = 600762, XrefRangeStart = 600709, XrefRangeEnd = 600761, 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: 0x060083E7 RID: 33767 RVA: 0x0021C598 File Offset: 0x0021A798
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600769, RefRangeEnd = 600770, XrefRangeStart = 600762, XrefRangeEnd = 600769, 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: 0x060083E8 RID: 33768 RVA: 0x0021C60C File Offset: 0x0021A80C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600779, RefRangeEnd = 600780, XrefRangeStart = 600770, XrefRangeEnd = 600779, 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: 0x060083E9 RID: 33769 RVA: 0x0021C674 File Offset: 0x0021A874
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600781, RefRangeEnd = 600782, XrefRangeStart = 600780, XrefRangeEnd = 600781, 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: 0x060083EA RID: 33770 RVA: 0x0021C6C8 File Offset: 0x0021A8C8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600841, RefRangeEnd = 600842, XrefRangeStart = 600782, XrefRangeEnd = 600841, 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: 0x17002D0D RID: 11533
			// (get) Token: 0x060083EB RID: 33771 RVA: 0x0021C854 File Offset: 0x0021AA54
			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: 0x17002D0E RID: 11534
			// (get) Token: 0x060083EC RID: 33772 RVA: 0x0021C8A4 File Offset: 0x0021AAA4
			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: 0x17002D0F RID: 11535
			// (get) Token: 0x060083ED RID: 33773 RVA: 0x0021C8F4 File Offset: 0x0021AAF4
			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: 0x17002D10 RID: 11536
			// (get) Token: 0x060083EE RID: 33774 RVA: 0x0021C944 File Offset: 0x0021AB44
			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: 0x060083EF RID: 33775 RVA: 0x0021C994 File Offset: 0x0021AB94
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 600846, RefRangeEnd = 600848, XrefRangeStart = 600842, XrefRangeEnd = 600846, 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: 0x060083F0 RID: 33776 RVA: 0x0021CA1C File Offset: 0x0021AC1C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600848, XrefRangeEnd = 600849, 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: 0x060083F1 RID: 33777 RVA: 0x0021CA6C File Offset: 0x0021AC6C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600856, RefRangeEnd = 600857, XrefRangeStart = 600849, XrefRangeEnd = 600856, 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: 0x060083F2 RID: 33778 RVA: 0x0021CAF8 File Offset: 0x0021ACF8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 600871, RefRangeEnd = 600872, XrefRangeStart = 600857, XrefRangeEnd = 600871, 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: 0x060083F3 RID: 33779 RVA: 0x0021CB44 File Offset: 0x0021AD44
			// 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, 100673344);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_set_centerOfMass_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673345);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_Initiate_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673346);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_Reset_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673347);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaRotation_Public_Void_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673348);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaPosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673349);
				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, 100673350);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673351);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673352);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673353);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673354);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_StepBlocked_Private_Boolean_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673355);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_CanStep_Private_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673356);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_GetLineSphereCollision_Private_Static_Boolean_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673357);
				IKSolverVR.Locomotion.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100673358);
			}

			// Token: 0x060083F4 RID: 33780 RVA: 0x0000A688 File Offset: 0x00008888
			public Locomotion(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002CF0 RID: 11504
			// (get) Token: 0x060083F5 RID: 33781 RVA: 0x0021CECC File Offset: 0x0021B0CC
			// (set) Token: 0x060083F6 RID: 33782 RVA: 0x0021CEF4 File Offset: 0x0021B0F4
			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: 0x17002CF1 RID: 11505
			// (get) Token: 0x060083F7 RID: 33783 RVA: 0x0021CF18 File Offset: 0x0021B118
			// (set) Token: 0x060083F8 RID: 33784 RVA: 0x0021CF40 File Offset: 0x0021B140
			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: 0x17002CF2 RID: 11506
			// (get) Token: 0x060083F9 RID: 33785 RVA: 0x0021CF64 File Offset: 0x0021B164
			// (set) Token: 0x060083FA RID: 33786 RVA: 0x0021CF8C File Offset: 0x0021B18C
			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: 0x17002CF3 RID: 11507
			// (get) Token: 0x060083FB RID: 33787 RVA: 0x0021CFB0 File Offset: 0x0021B1B0
			// (set) Token: 0x060083FC RID: 33788 RVA: 0x0021CFD8 File Offset: 0x0021B1D8
			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: 0x17002CF4 RID: 11508
			// (get) Token: 0x060083FD RID: 33789 RVA: 0x0021CFFC File Offset: 0x0021B1FC
			// (set) Token: 0x060083FE RID: 33790 RVA: 0x0021D024 File Offset: 0x0021B224
			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: 0x17002CF5 RID: 11509
			// (get) Token: 0x060083FF RID: 33791 RVA: 0x0021D048 File Offset: 0x0021B248
			// (set) Token: 0x06008400 RID: 33792 RVA: 0x0021D070 File Offset: 0x0021B270
			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: 0x17002CF6 RID: 11510
			// (get) Token: 0x06008401 RID: 33793 RVA: 0x0021D094 File Offset: 0x0021B294
			// (set) Token: 0x06008402 RID: 33794 RVA: 0x0021D0BC File Offset: 0x0021B2BC
			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: 0x17002CF7 RID: 11511
			// (get) Token: 0x06008403 RID: 33795 RVA: 0x0021D0E0 File Offset: 0x0021B2E0
			// (set) Token: 0x06008404 RID: 33796 RVA: 0x0021D108 File Offset: 0x0021B308
			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: 0x17002CF8 RID: 11512
			// (get) Token: 0x06008405 RID: 33797 RVA: 0x0021D12C File Offset: 0x0021B32C
			// (set) Token: 0x06008406 RID: 33798 RVA: 0x0021D154 File Offset: 0x0021B354
			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: 0x17002CF9 RID: 11513
			// (get) Token: 0x06008407 RID: 33799 RVA: 0x0021D178 File Offset: 0x0021B378
			// (set) Token: 0x06008408 RID: 33800 RVA: 0x0021D1A0 File Offset: 0x0021B3A0
			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: 0x17002CFA RID: 11514
			// (get) Token: 0x06008409 RID: 33801 RVA: 0x0021D1C4 File Offset: 0x0021B3C4
			// (set) Token: 0x0600840A RID: 33802 RVA: 0x0021D1F8 File Offset: 0x0021B3F8
			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: 0x17002CFB RID: 11515
			// (get) Token: 0x0600840B RID: 33803 RVA: 0x0021D220 File Offset: 0x0021B420
			// (set) Token: 0x0600840C RID: 33804 RVA: 0x0021D254 File Offset: 0x0021B454
			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: 0x17002CFC RID: 11516
			// (get) Token: 0x0600840D RID: 33805 RVA: 0x0021D27C File Offset: 0x0021B47C
			// (set) Token: 0x0600840E RID: 33806 RVA: 0x0021D2A4 File Offset: 0x0021B4A4
			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: 0x17002CFD RID: 11517
			// (get) Token: 0x0600840F RID: 33807 RVA: 0x0021D2C8 File Offset: 0x0021B4C8
			// (set) Token: 0x06008410 RID: 33808 RVA: 0x0021D2F0 File Offset: 0x0021B4F0
			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: 0x17002CFE RID: 11518
			// (get) Token: 0x06008411 RID: 33809 RVA: 0x0021D314 File Offset: 0x0021B514
			// (set) Token: 0x06008412 RID: 33810 RVA: 0x0021D33C File Offset: 0x0021B53C
			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: 0x17002CFF RID: 11519
			// (get) Token: 0x06008413 RID: 33811 RVA: 0x0021D360 File Offset: 0x0021B560
			// (set) Token: 0x06008414 RID: 33812 RVA: 0x0021D388 File Offset: 0x0021B588
			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: 0x17002D00 RID: 11520
			// (get) Token: 0x06008415 RID: 33813 RVA: 0x0021D3AC File Offset: 0x0021B5AC
			// (set) Token: 0x06008416 RID: 33814 RVA: 0x0021D3D4 File Offset: 0x0021B5D4
			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: 0x17002D01 RID: 11521
			// (get) Token: 0x06008417 RID: 33815 RVA: 0x0021D3F8 File Offset: 0x0021B5F8
			// (set) Token: 0x06008418 RID: 33816 RVA: 0x0021D420 File Offset: 0x0021B620
			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: 0x17002D02 RID: 11522
			// (get) Token: 0x06008419 RID: 33817 RVA: 0x0021D444 File Offset: 0x0021B644
			// (set) Token: 0x0600841A RID: 33818 RVA: 0x0021D46C File Offset: 0x0021B66C
			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: 0x17002D03 RID: 11523
			// (get) Token: 0x0600841B RID: 33819 RVA: 0x0021D490 File Offset: 0x0021B690
			// (set) Token: 0x0600841C RID: 33820 RVA: 0x0021D4B8 File Offset: 0x0021B6B8
			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: 0x17002D04 RID: 11524
			// (get) Token: 0x0600841D RID: 33821 RVA: 0x0021D4DC File Offset: 0x0021B6DC
			// (set) Token: 0x0600841E RID: 33822 RVA: 0x0021D510 File Offset: 0x0021B710
			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: 0x17002D05 RID: 11525
			// (get) Token: 0x0600841F RID: 33823 RVA: 0x0021D538 File Offset: 0x0021B738
			// (set) Token: 0x06008420 RID: 33824 RVA: 0x0021D56C File Offset: 0x0021B76C
			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: 0x17002D06 RID: 11526
			// (get) Token: 0x06008421 RID: 33825 RVA: 0x0021D594 File Offset: 0x0021B794
			// (set) Token: 0x06008422 RID: 33826 RVA: 0x0021D5BC File Offset: 0x0021B7BC
			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: 0x17002D07 RID: 11527
			// (get) Token: 0x06008423 RID: 33827 RVA: 0x0021D5E0 File Offset: 0x0021B7E0
			// (set) Token: 0x06008424 RID: 33828 RVA: 0x0021D614 File Offset: 0x0021B814
			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: 0x17002D08 RID: 11528
			// (get) Token: 0x06008425 RID: 33829 RVA: 0x0021D63C File Offset: 0x0021B83C
			// (set) Token: 0x06008426 RID: 33830 RVA: 0x0021D664 File Offset: 0x0021B864
			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: 0x17002D09 RID: 11529
			// (get) Token: 0x06008427 RID: 33831 RVA: 0x0021D688 File Offset: 0x0021B888
			// (set) Token: 0x06008428 RID: 33832 RVA: 0x0021D6B0 File Offset: 0x0021B8B0
			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: 0x17002D0A RID: 11530
			// (get) Token: 0x06008429 RID: 33833 RVA: 0x0021D6D4 File Offset: 0x0021B8D4
			// (set) Token: 0x0600842A RID: 33834 RVA: 0x0021D6FC File Offset: 0x0021B8FC
			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: 0x17002D0B RID: 11531
			// (get) Token: 0x0600842B RID: 33835 RVA: 0x0021D720 File Offset: 0x0021B920
			// (set) Token: 0x0600842C RID: 33836 RVA: 0x0021D748 File Offset: 0x0021B948
			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: 0x04005822 RID: 22562
			private static readonly IntPtr NativeFieldInfoPtr_weight;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			// Token: 0x04005839 RID: 22585
			private static readonly IntPtr NativeFieldInfoPtr_footsteps;

			// Token: 0x0400583A RID: 22586
			private static readonly IntPtr NativeFieldInfoPtr_lastComPosition;

			// Token: 0x0400583B RID: 22587
			private static readonly IntPtr NativeFieldInfoPtr_comVelocity;

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

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

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

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

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

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

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

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

			// Token: 0x04005844 RID: 22596
			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: 0x04005845 RID: 22597
			private static readonly IntPtr NativeMethodInfoPtr_get_leftFootstepPosition_Public_get_Vector3_0;

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

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

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

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

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

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

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

		// Token: 0x0200044F RID: 1103
		[Serializable]
		public class Spine : IKSolverVR.BodyPart
		{
			// Token: 0x17002D42 RID: 11586
			// (get) Token: 0x0600842D RID: 33837 RVA: 0x0021D76C File Offset: 0x0021B96C
			public unsafe IKSolverVR.VirtualBone pelvis
			{
				[CallerCount(14)]
				[CachedScanResults(RefRangeStart = 600872, RefRangeEnd = 600886, XrefRangeStart = 600872, XrefRangeEnd = 600872, 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: 0x17002D43 RID: 11587
			// (get) Token: 0x0600842E RID: 33838 RVA: 0x0021D7C4 File Offset: 0x0021B9C4
			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: 0x17002D44 RID: 11588
			// (get) Token: 0x0600842F RID: 33839 RVA: 0x0021D81C File Offset: 0x0021BA1C
			public unsafe IKSolverVR.VirtualBone chest
			{
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 600887, RefRangeEnd = 600889, XrefRangeStart = 600886, XrefRangeEnd = 600887, 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: 0x17002D45 RID: 11589
			// (get) Token: 0x06008430 RID: 33840 RVA: 0x0021D874 File Offset: 0x0021BA74
			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: 0x17002D46 RID: 11590
			// (get) Token: 0x06008431 RID: 33841 RVA: 0x0021D8CC File Offset: 0x0021BACC
			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: 0x17002D47 RID: 11591
			// (get) Token: 0x06008432 RID: 33842 RVA: 0x0021D924 File Offset: 0x0021BB24
			// (set) Token: 0x06008433 RID: 33843 RVA: 0x0021D974 File Offset: 0x0021BB74
			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: 0x06008434 RID: 33844 RVA: 0x0021D9C8 File Offset: 0x0021BBC8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600889, XrefRangeEnd = 600942, 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: 0x06008435 RID: 33845 RVA: 0x0021DAB8 File Offset: 0x0021BCB8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600942, XrefRangeEnd = 600959, 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: 0x06008436 RID: 33846 RVA: 0x0021DB08 File Offset: 0x0021BD08
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600959, XrefRangeEnd = 600977, 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: 0x06008437 RID: 33847 RVA: 0x0021DB58 File Offset: 0x0021BD58
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 600977, XrefRangeEnd = 600986, 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: 0x06008438 RID: 33848 RVA: 0x0021DBCC File Offset: 0x0021BDCC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601029, RefRangeEnd = 601030, XrefRangeStart = 600986, XrefRangeEnd = 601029, 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: 0x06008439 RID: 33849 RVA: 0x0021DC58 File Offset: 0x0021BE58
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601040, RefRangeEnd = 601041, XrefRangeStart = 601030, XrefRangeEnd = 601040, 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: 0x0600843A RID: 33850 RVA: 0x0021DC9C File Offset: 0x0021BE9C
			[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: 0x0600843B RID: 33851 RVA: 0x0021DD1C File Offset: 0x0021BF1C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601041, XrefRangeEnd = 601046, 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: 0x0600843C RID: 33852 RVA: 0x0021DD6C File Offset: 0x0021BF6C
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 601058, RefRangeEnd = 601060, XrefRangeStart = 601046, XrefRangeEnd = 601058, 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: 0x0600843D RID: 33853 RVA: 0x0021DDDC File Offset: 0x0021BFDC
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 601063, RefRangeEnd = 601066, XrefRangeStart = 601060, XrefRangeEnd = 601063, 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: 0x0600843E RID: 33854 RVA: 0x0021DE84 File Offset: 0x0021C084
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601079, RefRangeEnd = 601080, XrefRangeStart = 601066, XrefRangeEnd = 601079, 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: 0x0600843F RID: 33855 RVA: 0x0021DF04 File Offset: 0x0021C104
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601086, RefRangeEnd = 601087, XrefRangeStart = 601080, XrefRangeEnd = 601086, 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: 0x06008440 RID: 33856 RVA: 0x0021DFA4 File Offset: 0x0021C1A4
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601094, RefRangeEnd = 601095, XrefRangeStart = 601087, XrefRangeEnd = 601094, 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: 0x06008441 RID: 33857 RVA: 0x0021E070 File Offset: 0x0021C270
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 601103, RefRangeEnd = 601105, XrefRangeStart = 601095, XrefRangeEnd = 601103, 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: 0x06008442 RID: 33858 RVA: 0x0021E150 File Offset: 0x0021C350
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601122, RefRangeEnd = 601123, XrefRangeStart = 601105, XrefRangeEnd = 601122, 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: 0x06008443 RID: 33859 RVA: 0x0021E19C File Offset: 0x0021C39C
			// 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, 100673359);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_firstSpineBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673360);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_chest_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673361);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_neck_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673362);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_head_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673363);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_anchorRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673364);
				IKSolverVR.Spine.NativeMethodInfoPtr_set_anchorRotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673365);
				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, 100673366);
				IKSolverVR.Spine.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673367);
				IKSolverVR.Spine.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673368);
				IKSolverVR.Spine.NativeMethodInfoPtr_CalculateChestTargetRotation_Private_Void_VirtualBone_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673369);
				IKSolverVR.Spine.NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Il2CppReferenceArray_1_Leg_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673370);
				IKSolverVR.Spine.NativeMethodInfoPtr_SolvePelvis_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673371);
				IKSolverVR.Spine.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673372);
				IKSolverVR.Spine.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673373);
				IKSolverVR.Spine.NativeMethodInfoPtr_AdjustChestByHands_Private_Void_byref_Quaternion_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673374);
				IKSolverVR.Spine.NativeMethodInfoPtr_InverseTranslateToHead_Public_Void_Il2CppReferenceArray_1_Leg_Boolean_Boolean_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673375);
				IKSolverVR.Spine.NativeMethodInfoPtr_TranslatePelvis_Private_Void_Il2CppReferenceArray_1_Leg_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673376);
				IKSolverVR.Spine.NativeMethodInfoPtr_LimitPelvisPosition_Private_Vector3_Il2CppReferenceArray_1_Leg_Vector3_Boolean_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673377);
				IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Single_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673378);
				IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Quaternion_Single_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673379);
				IKSolverVR.Spine.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100673380);
			}

			// Token: 0x06008444 RID: 33860 RVA: 0x002195E7 File Offset: 0x002177E7
			public Spine(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D11 RID: 11537
			// (get) Token: 0x06008445 RID: 33861 RVA: 0x0021E754 File Offset: 0x0021C954
			// (set) Token: 0x06008446 RID: 33862 RVA: 0x0021E788 File Offset: 0x0021C988
			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: 0x17002D12 RID: 11538
			// (get) Token: 0x06008447 RID: 33863 RVA: 0x0021E7B0 File Offset: 0x0021C9B0
			// (set) Token: 0x06008448 RID: 33864 RVA: 0x0021E7E4 File Offset: 0x0021C9E4
			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: 0x17002D13 RID: 11539
			// (get) Token: 0x06008449 RID: 33865 RVA: 0x0021E80C File Offset: 0x0021CA0C
			// (set) Token: 0x0600844A RID: 33866 RVA: 0x0021E834 File Offset: 0x0021CA34
			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: 0x17002D14 RID: 11540
			// (get) Token: 0x0600844B RID: 33867 RVA: 0x0021E858 File Offset: 0x0021CA58
			// (set) Token: 0x0600844C RID: 33868 RVA: 0x0021E880 File Offset: 0x0021CA80
			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: 0x17002D15 RID: 11541
			// (get) Token: 0x0600844D RID: 33869 RVA: 0x0021E8A4 File Offset: 0x0021CAA4
			// (set) Token: 0x0600844E RID: 33870 RVA: 0x0021E8CC File Offset: 0x0021CACC
			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: 0x17002D16 RID: 11542
			// (get) Token: 0x0600844F RID: 33871 RVA: 0x0021E8F0 File Offset: 0x0021CAF0
			// (set) Token: 0x06008450 RID: 33872 RVA: 0x0021E918 File Offset: 0x0021CB18
			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: 0x17002D17 RID: 11543
			// (get) Token: 0x06008451 RID: 33873 RVA: 0x0021E93C File Offset: 0x0021CB3C
			// (set) Token: 0x06008452 RID: 33874 RVA: 0x0021E970 File Offset: 0x0021CB70
			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: 0x17002D18 RID: 11544
			// (get) Token: 0x06008453 RID: 33875 RVA: 0x0021E998 File Offset: 0x0021CB98
			// (set) Token: 0x06008454 RID: 33876 RVA: 0x0021E9C0 File Offset: 0x0021CBC0
			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: 0x17002D19 RID: 11545
			// (get) Token: 0x06008455 RID: 33877 RVA: 0x0021E9E4 File Offset: 0x0021CBE4
			// (set) Token: 0x06008456 RID: 33878 RVA: 0x0021EA0C File Offset: 0x0021CC0C
			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: 0x17002D1A RID: 11546
			// (get) Token: 0x06008457 RID: 33879 RVA: 0x0021EA30 File Offset: 0x0021CC30
			// (set) Token: 0x06008458 RID: 33880 RVA: 0x0021EA58 File Offset: 0x0021CC58
			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: 0x17002D1B RID: 11547
			// (get) Token: 0x06008459 RID: 33881 RVA: 0x0021EA7C File Offset: 0x0021CC7C
			// (set) Token: 0x0600845A RID: 33882 RVA: 0x0021EAA4 File Offset: 0x0021CCA4
			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: 0x17002D1C RID: 11548
			// (get) Token: 0x0600845B RID: 33883 RVA: 0x0021EAC8 File Offset: 0x0021CCC8
			// (set) Token: 0x0600845C RID: 33884 RVA: 0x0021EAF0 File Offset: 0x0021CCF0
			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: 0x17002D1D RID: 11549
			// (get) Token: 0x0600845D RID: 33885 RVA: 0x0021EB14 File Offset: 0x0021CD14
			// (set) Token: 0x0600845E RID: 33886 RVA: 0x0021EB3C File Offset: 0x0021CD3C
			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: 0x17002D1E RID: 11550
			// (get) Token: 0x0600845F RID: 33887 RVA: 0x0021EB60 File Offset: 0x0021CD60
			// (set) Token: 0x06008460 RID: 33888 RVA: 0x0021EB88 File Offset: 0x0021CD88
			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: 0x17002D1F RID: 11551
			// (get) Token: 0x06008461 RID: 33889 RVA: 0x0021EBAC File Offset: 0x0021CDAC
			// (set) Token: 0x06008462 RID: 33890 RVA: 0x0021EBD4 File Offset: 0x0021CDD4
			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: 0x17002D20 RID: 11552
			// (get) Token: 0x06008463 RID: 33891 RVA: 0x0021EBF8 File Offset: 0x0021CDF8
			// (set) Token: 0x06008464 RID: 33892 RVA: 0x0021EC20 File Offset: 0x0021CE20
			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: 0x17002D21 RID: 11553
			// (get) Token: 0x06008465 RID: 33893 RVA: 0x0021EC44 File Offset: 0x0021CE44
			// (set) Token: 0x06008466 RID: 33894 RVA: 0x0021EC6C File Offset: 0x0021CE6C
			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: 0x17002D22 RID: 11554
			// (get) Token: 0x06008467 RID: 33895 RVA: 0x0021EC90 File Offset: 0x0021CE90
			// (set) Token: 0x06008468 RID: 33896 RVA: 0x0021ECB8 File Offset: 0x0021CEB8
			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: 0x17002D23 RID: 11555
			// (get) Token: 0x06008469 RID: 33897 RVA: 0x0021ECDC File Offset: 0x0021CEDC
			// (set) Token: 0x0600846A RID: 33898 RVA: 0x0021ED04 File Offset: 0x0021CF04
			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: 0x17002D24 RID: 11556
			// (get) Token: 0x0600846B RID: 33899 RVA: 0x0021ED28 File Offset: 0x0021CF28
			// (set) Token: 0x0600846C RID: 33900 RVA: 0x0021ED50 File Offset: 0x0021CF50
			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: 0x17002D25 RID: 11557
			// (get) Token: 0x0600846D RID: 33901 RVA: 0x0021ED74 File Offset: 0x0021CF74
			// (set) Token: 0x0600846E RID: 33902 RVA: 0x0021ED9C File Offset: 0x0021CF9C
			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: 0x17002D26 RID: 11558
			// (get) Token: 0x0600846F RID: 33903 RVA: 0x0021EDC0 File Offset: 0x0021CFC0
			// (set) Token: 0x06008470 RID: 33904 RVA: 0x0021EDE8 File Offset: 0x0021CFE8
			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: 0x17002D27 RID: 11559
			// (get) Token: 0x06008471 RID: 33905 RVA: 0x0021EE0C File Offset: 0x0021D00C
			// (set) Token: 0x06008472 RID: 33906 RVA: 0x0021EE34 File Offset: 0x0021D034
			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: 0x17002D28 RID: 11560
			// (get) Token: 0x06008473 RID: 33907 RVA: 0x0021EE58 File Offset: 0x0021D058
			// (set) Token: 0x06008474 RID: 33908 RVA: 0x0021EE80 File Offset: 0x0021D080
			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: 0x17002D29 RID: 11561
			// (get) Token: 0x06008475 RID: 33909 RVA: 0x0021EEA4 File Offset: 0x0021D0A4
			// (set) Token: 0x06008476 RID: 33910 RVA: 0x0021EECC File Offset: 0x0021D0CC
			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: 0x17002D2A RID: 11562
			// (get) Token: 0x06008477 RID: 33911 RVA: 0x0021EEF0 File Offset: 0x0021D0F0
			// (set) Token: 0x06008478 RID: 33912 RVA: 0x0021EF18 File Offset: 0x0021D118
			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: 0x17002D2B RID: 11563
			// (get) Token: 0x06008479 RID: 33913 RVA: 0x0021EF3C File Offset: 0x0021D13C
			// (set) Token: 0x0600847A RID: 33914 RVA: 0x0021EF64 File Offset: 0x0021D164
			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: 0x17002D2C RID: 11564
			// (get) Token: 0x0600847B RID: 33915 RVA: 0x0021EF88 File Offset: 0x0021D188
			// (set) Token: 0x0600847C RID: 33916 RVA: 0x0021EFB0 File Offset: 0x0021D1B0
			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: 0x17002D2D RID: 11565
			// (get) Token: 0x0600847D RID: 33917 RVA: 0x0021EFD4 File Offset: 0x0021D1D4
			// (set) Token: 0x0600847E RID: 33918 RVA: 0x0021EFFC File Offset: 0x0021D1FC
			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: 0x17002D2E RID: 11566
			// (get) Token: 0x0600847F RID: 33919 RVA: 0x0021F020 File Offset: 0x0021D220
			// (set) Token: 0x06008480 RID: 33920 RVA: 0x0021F048 File Offset: 0x0021D248
			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: 0x17002D2F RID: 11567
			// (get) Token: 0x06008481 RID: 33921 RVA: 0x0021F06C File Offset: 0x0021D26C
			// (set) Token: 0x06008482 RID: 33922 RVA: 0x0021F094 File Offset: 0x0021D294
			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: 0x17002D30 RID: 11568
			// (get) Token: 0x06008483 RID: 33923 RVA: 0x0021F0B8 File Offset: 0x0021D2B8
			// (set) Token: 0x06008484 RID: 33924 RVA: 0x0021F0E0 File Offset: 0x0021D2E0
			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: 0x17002D31 RID: 11569
			// (get) Token: 0x06008485 RID: 33925 RVA: 0x0021F104 File Offset: 0x0021D304
			// (set) Token: 0x06008486 RID: 33926 RVA: 0x0021F12C File Offset: 0x0021D32C
			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: 0x17002D32 RID: 11570
			// (get) Token: 0x06008487 RID: 33927 RVA: 0x0021F150 File Offset: 0x0021D350
			// (set) Token: 0x06008488 RID: 33928 RVA: 0x0021F178 File Offset: 0x0021D378
			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: 0x17002D33 RID: 11571
			// (get) Token: 0x06008489 RID: 33929 RVA: 0x0021F19C File Offset: 0x0021D39C
			// (set) Token: 0x0600848A RID: 33930 RVA: 0x0021F1C4 File Offset: 0x0021D3C4
			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: 0x17002D34 RID: 11572
			// (get) Token: 0x0600848B RID: 33931 RVA: 0x0021F1E8 File Offset: 0x0021D3E8
			// (set) Token: 0x0600848C RID: 33932 RVA: 0x0021F210 File Offset: 0x0021D410
			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: 0x17002D35 RID: 11573
			// (get) Token: 0x0600848D RID: 33933 RVA: 0x0021F234 File Offset: 0x0021D434
			// (set) Token: 0x0600848E RID: 33934 RVA: 0x0021F25C File Offset: 0x0021D45C
			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: 0x17002D36 RID: 11574
			// (get) Token: 0x0600848F RID: 33935 RVA: 0x0021F280 File Offset: 0x0021D480
			// (set) Token: 0x06008490 RID: 33936 RVA: 0x0021F2A8 File Offset: 0x0021D4A8
			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: 0x17002D37 RID: 11575
			// (get) Token: 0x06008491 RID: 33937 RVA: 0x0021F2CC File Offset: 0x0021D4CC
			// (set) Token: 0x06008492 RID: 33938 RVA: 0x0021F2F4 File Offset: 0x0021D4F4
			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: 0x17002D38 RID: 11576
			// (get) Token: 0x06008493 RID: 33939 RVA: 0x0021F318 File Offset: 0x0021D518
			// (set) Token: 0x06008494 RID: 33940 RVA: 0x0021F340 File Offset: 0x0021D540
			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: 0x17002D39 RID: 11577
			// (get) Token: 0x06008495 RID: 33941 RVA: 0x0021F364 File Offset: 0x0021D564
			// (set) Token: 0x06008496 RID: 33942 RVA: 0x0021F38C File Offset: 0x0021D58C
			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: 0x17002D3A RID: 11578
			// (get) Token: 0x06008497 RID: 33943 RVA: 0x0021F3B0 File Offset: 0x0021D5B0
			// (set) Token: 0x06008498 RID: 33944 RVA: 0x0021F3D8 File Offset: 0x0021D5D8
			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: 0x17002D3B RID: 11579
			// (get) Token: 0x06008499 RID: 33945 RVA: 0x0021F3FC File Offset: 0x0021D5FC
			// (set) Token: 0x0600849A RID: 33946 RVA: 0x0021F424 File Offset: 0x0021D624
			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: 0x17002D3C RID: 11580
			// (get) Token: 0x0600849B RID: 33947 RVA: 0x0021F448 File Offset: 0x0021D648
			// (set) Token: 0x0600849C RID: 33948 RVA: 0x0021F470 File Offset: 0x0021D670
			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: 0x17002D3D RID: 11581
			// (get) Token: 0x0600849D RID: 33949 RVA: 0x0021F494 File Offset: 0x0021D694
			// (set) Token: 0x0600849E RID: 33950 RVA: 0x0021F4BC File Offset: 0x0021D6BC
			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: 0x17002D3E RID: 11582
			// (get) Token: 0x0600849F RID: 33951 RVA: 0x0021F4E0 File Offset: 0x0021D6E0
			// (set) Token: 0x060084A0 RID: 33952 RVA: 0x0021F508 File Offset: 0x0021D708
			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: 0x17002D3F RID: 11583
			// (get) Token: 0x060084A1 RID: 33953 RVA: 0x0021F52C File Offset: 0x0021D72C
			// (set) Token: 0x060084A2 RID: 33954 RVA: 0x0021F554 File Offset: 0x0021D754
			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: 0x17002D40 RID: 11584
			// (get) Token: 0x060084A3 RID: 33955 RVA: 0x0021F578 File Offset: 0x0021D778
			// (set) Token: 0x060084A4 RID: 33956 RVA: 0x0021F5A0 File Offset: 0x0021D7A0
			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: 0x17002D41 RID: 11585
			// (get) Token: 0x060084A5 RID: 33957 RVA: 0x0021F5C4 File Offset: 0x0021D7C4
			// (set) Token: 0x060084A6 RID: 33958 RVA: 0x0021F5EC File Offset: 0x0021D7EC
			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: 0x0400584D RID: 22605
			private static readonly IntPtr NativeFieldInfoPtr_headTarget;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x02000450 RID: 1104
		[Serializable]
		public enum PositionOffset
		{
			// Token: 0x04005895 RID: 22677
			Pelvis,
			// Token: 0x04005896 RID: 22678
			Chest,
			// Token: 0x04005897 RID: 22679
			Head,
			// Token: 0x04005898 RID: 22680
			LeftHand,
			// Token: 0x04005899 RID: 22681
			RightHand,
			// Token: 0x0400589A RID: 22682
			LeftFoot,
			// Token: 0x0400589B RID: 22683
			RightFoot,
			// Token: 0x0400589C RID: 22684
			LeftHeel,
			// Token: 0x0400589D RID: 22685
			RightHeel
		}

		// Token: 0x02000451 RID: 1105
		[Serializable]
		public enum RotationOffset
		{
			// Token: 0x0400589F RID: 22687
			Pelvis,
			// Token: 0x040058A0 RID: 22688
			Chest,
			// Token: 0x040058A1 RID: 22689
			Head
		}

		// Token: 0x02000452 RID: 1106
		[Serializable]
		public class VirtualBone : Il2CppSystem.Object
		{
			// Token: 0x060084A7 RID: 33959 RVA: 0x0021F610 File Offset: 0x0021D810
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601124, RefRangeEnd = 601125, XrefRangeStart = 601123, XrefRangeEnd = 601124, 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: 0x060084A8 RID: 33960 RVA: 0x0021F680 File Offset: 0x0021D880
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601125, RefRangeEnd = 601126, XrefRangeStart = 601125, XrefRangeEnd = 601125, 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: 0x060084A9 RID: 33961 RVA: 0x0021F6E8 File Offset: 0x0021D8E8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601132, RefRangeEnd = 601133, XrefRangeStart = 601126, XrefRangeEnd = 601132, 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: 0x060084AA RID: 33962 RVA: 0x0021F76C File Offset: 0x0021D96C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601140, RefRangeEnd = 601141, XrefRangeStart = 601133, XrefRangeEnd = 601140, 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: 0x060084AB RID: 33963 RVA: 0x0021F7E4 File Offset: 0x0021D9E4
			[CallerCount(10)]
			[CachedScanResults(RefRangeStart = 601144, RefRangeEnd = 601154, XrefRangeStart = 601141, XrefRangeEnd = 601144, 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: 0x060084AC RID: 33964 RVA: 0x0021F868 File Offset: 0x0021DA68
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 601157, RefRangeEnd = 601158, XrefRangeStart = 601154, XrefRangeEnd = 601157, 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: 0x060084AD RID: 33965 RVA: 0x0021F8D8 File Offset: 0x0021DAD8
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 601161, RefRangeEnd = 601163, XrefRangeStart = 601158, XrefRangeEnd = 601161, 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: 0x060084AE RID: 33966 RVA: 0x0021F938 File Offset: 0x0021DB38
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601163, XrefRangeEnd = 601165, 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: 0x060084AF RID: 33967 RVA: 0x0021F9A8 File Offset: 0x0021DBA8
			[CallerCount(11)]
			[CachedScanResults(RefRangeStart = 601192, RefRangeEnd = 601203, XrefRangeStart = 601165, XrefRangeEnd = 601192, 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: 0x060084B0 RID: 33968 RVA: 0x0021FA64 File Offset: 0x0021DC64
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601203, XrefRangeEnd = 601215, 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: 0x060084B1 RID: 33969 RVA: 0x0021FB04 File Offset: 0x0021DD04
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 601224, RefRangeEnd = 601226, XrefRangeStart = 601215, XrefRangeEnd = 601224, 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: 0x060084B2 RID: 33970 RVA: 0x0021FBC0 File Offset: 0x0021DDC0
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 601227, RefRangeEnd = 601229, XrefRangeStart = 601226, XrefRangeEnd = 601227, 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: 0x060084B3 RID: 33971 RVA: 0x0021FC3C File Offset: 0x0021DE3C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 601229, XrefRangeEnd = 601233, 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: 0x060084B4 RID: 33972 RVA: 0x0021FCC0 File Offset: 0x0021DEC0
			// 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, 100673381);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_Read_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673382);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SwingRotation_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673383);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_PreSolve_Public_Static_Single_byref_Il2CppReferenceArray_1_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673384);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateAroundPoint_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673385);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673386);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673387);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateTo_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673388);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveTrigonometric_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Int32_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673389);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_GetDirectionToBendPoint_Private_Static_Vector3_Vector3_Single_Vector3_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673390);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIK_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Vector3_Single_Single_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673391);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Static_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673392);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveCCD_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100673393);
			}

			// Token: 0x060084B5 RID: 33973 RVA: 0x0000A688 File Offset: 0x00008888
			public VirtualBone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D48 RID: 11592
			// (get) Token: 0x060084B6 RID: 33974 RVA: 0x0021FE7C File Offset: 0x0021E07C
			// (set) Token: 0x060084B7 RID: 33975 RVA: 0x0021FEA4 File Offset: 0x0021E0A4
			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: 0x17002D49 RID: 11593
			// (get) Token: 0x060084B8 RID: 33976 RVA: 0x0021FEC8 File Offset: 0x0021E0C8
			// (set) Token: 0x060084B9 RID: 33977 RVA: 0x0021FEF0 File Offset: 0x0021E0F0
			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: 0x17002D4A RID: 11594
			// (get) Token: 0x060084BA RID: 33978 RVA: 0x0021FF14 File Offset: 0x0021E114
			// (set) Token: 0x060084BB RID: 33979 RVA: 0x0021FF3C File Offset: 0x0021E13C
			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: 0x17002D4B RID: 11595
			// (get) Token: 0x060084BC RID: 33980 RVA: 0x0021FF60 File Offset: 0x0021E160
			// (set) Token: 0x060084BD RID: 33981 RVA: 0x0021FF88 File Offset: 0x0021E188
			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: 0x17002D4C RID: 11596
			// (get) Token: 0x060084BE RID: 33982 RVA: 0x0021FFAC File Offset: 0x0021E1AC
			// (set) Token: 0x060084BF RID: 33983 RVA: 0x0021FFD4 File Offset: 0x0021E1D4
			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: 0x17002D4D RID: 11597
			// (get) Token: 0x060084C0 RID: 33984 RVA: 0x0021FFF8 File Offset: 0x0021E1F8
			// (set) Token: 0x060084C1 RID: 33985 RVA: 0x00220020 File Offset: 0x0021E220
			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: 0x17002D4E RID: 11598
			// (get) Token: 0x060084C2 RID: 33986 RVA: 0x00220044 File Offset: 0x0021E244
			// (set) Token: 0x060084C3 RID: 33987 RVA: 0x0022006C File Offset: 0x0021E26C
			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: 0x040058A2 RID: 22690
			private static readonly IntPtr NativeFieldInfoPtr_readPosition;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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